Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
TCS · React Native
Practice React Native questions specifically asked in TCS interviews – ideal for online test preparation, technical rounds and final HR discussions.
Questions
24
Tagged for this company + subject
Company
TCS
View company-wise questions
Subject
React Native
Explore topic-wise practice
Go through each question and its explanation. Use this page for targeted revision just before your TCS React Native round.
The Context API provides a way to share values like theme or user data across components without prop drilling. You wrap parts of the app in a Provider and access the context value anywhere using useContext. It’s great for global data, but for complex scenarios, libraries like Redux offer more structure.
For complete preparation, combine this company + subject page with full company-wise practice and subject-wise practice. You can also explore other companies and topics from the links below.
React Native supports 'absolute' and 'relative' positioning through the position property. When set to 'absolute', an element can be placed anywhere using top, left, right, and bottom values.
Stack Navigator allows navigation between screens in a stack-like manner. Each new screen is pushed on top of the previous one, and going back pops the current screen off the stack.
useState allows a functional component to hold local state. It returns an array containing the current state value and a function to update it. Updating the state automatically re-renders the component.
const [count, setCount] = useState(0);
The Redux flow starts when a user interacts with the view, which dispatches an action. The reducer processes the action, updates the store, and the updated state re-renders the view.
You can use AsyncStorage along with redux-persist to save and rehydrate state. This ensures that user data, preferences, or login sessions are retained even when the app restarts.
Use FormData to append file objects and send them via POST requests. Make sure headers include 'Content-Type': 'multipart/form-data'. Axios handles boundary setup automatically, while Fetch requires manual setup.
In Android native modules, methods annotated with @ReactMethod become accessible from JavaScript. These methods are exported automatically when the module is registered with ReactPackage.
Native view managers allow developers to create custom UI components using native platform views. They expose these views to JavaScript so React Native can render them like regular components. Each view manager defines properties and methods accessible from JS.
useMemo caches the result of a function between renders so it only recalculates when dependencies change. It prevents expensive operations from running unnecessarily, improving performance during re-renders.
const value = useMemo(() => computeExpensiveValue(a, b), [a, b]);
React Developer Tools includes a Profiler tab that records rendering times of components. It helps identify slow components and optimize re-render-heavy areas in the app.
Detox is used for end-to-end (E2E) testing in React Native. It automates user interactions on real devices or emulators. It ensures the entire app flow works as expected — from UI to backend communication.
First, make JavaScript or asset changes and bundle them using the React Native CLI. Then, use the appcenter CLI to push the update to CodePush servers. The next time the user opens the app, CodePush downloads and applies the update automatically without requiring reinstallation.
The new architecture improves performance, enables synchronous native access, and supports concurrent rendering. It also simplifies native integration, reduces bridge latency, and improves developer tooling for debugging and profiling.
useEffect allows you to perform side effects that are not directly related to rendering, such as fetching data or setting up event listeners. You can also return a cleanup function to handle unmounting logic.
useEffect(() => { fetchData(); return () => cleanup(); }, []);StyleSheet.create() helps improve performance by freezing style definitions and preventing new object creation on each render. It also validates property names, catching typos early during development.
const styles = StyleSheet.create({
container: { flex: 1, padding: 20 }
});Common tools include Flipper, React Developer Tools, Chrome DevTools, and Reactotron. They allow inspecting component hierarchy, viewing logs, tracking Redux actions, and analyzing network performance in real-time.
Props are short for properties. They are read-only values passed from parent components to children. Props make components reusable and configurable without changing their internal logic.
React Native is a JavaScript framework that allows developers to build native mobile applications for iOS and Android using the React library. It bridges JavaScript with native platform components, offering near-native performance and a single shared codebase.
Avoid deeply nested Views; it increases rendering cost. Use flexbox efficiently to adapt to different screens without absolute positioning everywhere. Reuse styles with StyleSheet.create to avoid creating new objects each render. Also, minimize unnecessary re-renders with React.memo or PureComponent.
async / await helps structure asynchronous code in a linear, readable way. It improves error handling using try / catch and avoids deeply nested then / catch chains.
const res = await fetch(url); const data = await res.json();
Props are inputs passed to components, similar to function arguments. They are read-only. State is local data managed within the component and can change over time, causing re-renders.
The useState hook lets you add internal component state to functional components. It returns a pair: the current state value and a function to update it.
const [count, setCount] = useState(0);
React Native uses React’s virtual DOM concept to decide which parts of the UI need updating. When state or props change, React recalculates a virtual representation and compares it with the previous one. Only changed elements are sent to the native side through the bridge, minimizing performance cost. Understanding this helps developers optimize components and avoid unnecessary re-renders.