Top 10 React Interview Questions & Answers

Oct. 12, 2021, 5:32 p.m.
React · 11 min read
Top 10 React Interview Questions & Answers
Last Modified: Oct. 13, 2021, 12:24 p.m.


Even though interviewing for a tech job is intimidating, it is a lot easier when you know what to expect and are well-prepared. The stressful part before the actual interview is preparing for it, no matter how many nights you have spent solving coding problems and watching YouTube videos on how to crack your interview, there is a gut feeling that you may be caught off guard with a question that makes your mind go blank and your months of struggle go down the drain. 

To reduce the chances of any of the above happening, we have come up with this compilation of top 10 React interview questions with the strongest probability of occurrence.


About React

React is one of the world's most popular JavaScript libraries by this time. It was launched in 2011, created by developers at Facebook. The purpose of React was to provide an effective pipeline for smooth front-end development. It is formed on a component-based approach where the priority is reusability and time efficiency because creating front-end components is a complex job and React makes sure to simplify this job where you can efficiently work with the tools. It helps in developing a lot of complex stuff be it mobile application interfaces or web applications. When it comes to developing interactive, dynamic user interfaces, nothing can beat it and it is due to this reason React has become an industry-standard framework over the last few years. 


1. What is the meaning of the component-based architecture of React?

One important aspect of React is that every single entity is considered to be a component and these components form the foundation for building User Interfaces for web applications. These parts are responsible for yielding a little, reusable piece of HTML code that can be reused any place you need them. The primary objective of component-based architecture is to ensure component reusability and hence reduced development costs. This is a major selling point for applications that need duplicates of their features to act independently. In the case of Facebook, the user can have multiple chat windows that resemble one another, but still, work independently.

While working on a Component-based architecture every single entity will become completely reusable in a way that you can play around with it, not only it makes your programming extremely efficient but also the application more streamlined and well organized. In terms of rendering your application, with component-based architecture, rendering is a smooth process and does not depend on any other components of the same user interface, which is a huge advantage of React owing to component-based architecture. 


2. What is the difference between Virtual DOM and Real DOM?

When you consider working with Virtual DOM, it is easier in terms of usability rather than Real DOM. The virtual DOM is a lightweight copy of the DOM, that has all the properties a real DOM object has, and it can be modified without affecting the actual DOM. Although Virtual DOM lacks the power to directly change the screen contents, it is much faster in manipulation. In Real DOM, manipulation is very expensive because, for any change in UI, the browser has to search, check, and parse the number of nodes to reflect the changes. When any change occurs in UI, React first checks the difference in its present Virtual DOM and previous Virtual DOM and only updates that node in Real DOM. Thus, increasing the efficiency of Browsers. Due to this, developers have the advantage to make complex UI.

With respect to memory efficiency, virtual DOM is more efficient than Real DOM, this is because Virtual DOM already exists in the memory but in the case of Real DOM, it has to be accessed from the page and loaded to the memory for the operation. 

Moreover when we talk about JavaScript XML elements, in virtual DOM it will only get updated when the element actually exists, on the other hand, Real DOM works in a different manner, what happens is that every time a new element gets updated a new DOM is created for it, and then the object is processed and passed to JavaScript then the browser and all of that, so in case of back-end efficiency Virtual DOM takes the leading position yet again.


3. What are the three phases of a component life cycle in React?

The three phases are Mounting, Updating, and Unmounting. 

  • Mounting means putting elements into the DOM, you can also call it the birth of a component. React has four built-in methods that gets called, in this order, when mounting a component:
    • constructor()
    • getDerivedStateFromprops()
    • render()
    • componentDidMount()


  • Then comes updating, which means growth of a component, a component is updated whenever there is a change in the component’s state or props. The five lifecycle methods are as following:
    • getDerivedStateFromProps()
    • shouldComponentUpdate()
    • render()
    • getSnapshotBeforeUpdate()
    • componentDidUpdate()


  • And Lastly Unmounting, or in other words, the death of a component, in this phase the component is removed from the DOM. React has only one built-in method that gets called when a component is unmounted:
    • componentWillUnmount()


Each component has several lifecycle methods that can be overridden to run code at particular times in the process. 

The most commonly used lifecycle method is render(), it is the only required method in a class component and we must define it in a React.component subclass. Implementation of all other methods is optional.



4. How is routing in React different from conventional routing?

The differences between Routing in React and conventional routing are very subtle but important to understand. These differences can be discussed in two aspects. 

One is by using pages, when we talk about conventional routing each page is considered as a new file, but in the case of React, every single view does not need a new file in fact all files become a single HTML entity. That is why instead of having a new file for each individual view page like in conventional routing methodologies, here we have a single file that takes care of all the views.

Coming to the second aspect, which is navigation, in terms of conventional routing users would have to manually navigate through different web pages and every time the user moves around the view model is refreshed, while that is not the case in React, the core view remains the same, the application is not refreshed as objects are re-issued to create new views, this is a key principle of React routing, This allows your user to move between the components of your app while preserving user state. In the case of conventional routing, creation of new objects and updating of DOM causes the view to refresh every time you click on a new web page.


5. What are props in React?

Props is the short form used for properties in React. Props allow us to pass information between components in an application, in this way components can interact among themselves; this is one of the coolest features of React. Props are passed to the component in the same way as arguments passed in a function. Props are read-only components and immutable in nature, thus we are not allowed to modify the content of a prop in real-time, no matter what the type of component is, functional or class-based, neither of them has the control to modify their props. 

In an application, some properties are passed down from parent to child components, which means props follow a hierarchal order. However, with a callback function, it’s possible to pass props back from a child to a parent component. Props make use of the key concept of React known as unidirectional data flow, which implies that data has only one way to be transferred to other parts of your application, giving you better control over it. 

This data comes in different forms including numbers, strings, arrays, functions, objects, etc. We can pass props to any component as we declare attributes for any HTML tag. There are no limitations to the number of props we can pass. We can access any props inside from the component’s class to which the props are passed.


6. How to Enable Server-Side Rendering for a React App?

React SSR (Server-Side Rendering) is a popular technique when you pre-render the initial state of your application on backend. It can greatly improve user experience if used correctly.

React is already equipped to handle rendering on Node servers. A special version of the DOM renderer is available, which follows the same pattern as on the client-side.

We use a method from ReactDOMServer, renderToString, to render our app to a static HTML string.

import ReactDOMServer from 'React-dom/server'
import App from './App'

ReactDOMServer.renderToString(<App />)

This method will output the regular HTML as a string, which can be then placed inside a page body as part of the server response. On the client side, React detects the pre-rendered content and seamlessly picks up where it left off.

Although Server-side rendering can be costly one major benefit of using it is having an app that can be easily indexed and crawled by search engines because the content can be rendered before the page is loaded, which also helps to load webpages efficiently for users with slow internet connection and outdated devices.


7. What is React Fiber?

React fiber is a new engine in React, it is in fact the reimplementation of the core algorithm that comes along with React 16. One of the main goals of React fiber is to make sure that there are incremental rendering facilities given for the virtual DOM. Why is this done? Again, the primary talk here is about efficiency, so whenever your application is required to render gestures, animations, and layouts this feature will make sure to help in giving the right priority to what updates need to happen at what point of the process. In this way, there is no delay or latency in terms of the gap that exists between multiple renders.

Basically, the idea of React Fiber is to not use the JavaScript stack but instead unroll what we would normally do on the stack and put it into heap objects. React Fiber reconciler makes it possible to divide the work into multiple units of work. It makes apps more fluid and responsible allowing high priority updates to jump ahead of low priority updates.  These units of work are known as fibers, A fiber is a JavaScript object that contains information about a component, its input, and output.

Below is a very simplified version of a fiber:










React Fiber opens the door to a lot of new functionalities. Some of the features include Better support for error boundaries, Portals, ability to return multiple elements from render().


8. What are error boundaries in React v16 and how are they handled?

Runtime Errors during rendering could put our application in a broken state,  Error boundaries are React components that catch JavaScript errors, these errors can exist anywhere in their child component tree, it also logs those errors, and displays a fallback UI to the user instead of the component tree crashed. The key point to remember about error boundaries is that they catch errors during rendering, in lifecycle methods, and in constructors of the whole tree.

For a class component to become an error boundary, it is necessary to define one (or both) of the following lifecycle methods:


  • Static getDerivedStateFromError:

This lifecycle method is called after an error has been thrown by a descendant component. It takes a parameter of the error that was thrown and returns a value to update the state. We make use of this method whenever we have to render a fallback UI after an error has been thrown.


static getDerivedStateFromError(error) {

    // Update state so the next render will show the fallback UI.

    return { hasError: true };


Where, error is the error that was thrown.



  • ComponentDidCatch():

This lifecycle method is invoked after an error has been thrown by a descendant component, componentDidCatch() is used to log error information.


componentDidCatch(error, errorInfo) {

    // You can also log the error to an error reporting service

    logErrorToMyService(error, errorInfo);



error- the error that was thrown.

info- An object with a componentStack Key containing the information about which component threw the error.



React 15 included very limited support for error boundaries under a different method name: unstable_handleError. It has been renamed to componentDidCatch in React v16.



9. What are the most common approaches for styling a React application?

When it comes to styling React applications or React components, we have a wide variety of options.

  • Using Inline CSS:

This is typically the approach you get started with when you first learn React.

All your style information is part of your JavaScript files. This is how you apply inline styles to HTML elements in one of your React components:

const Button = props => {

  return (
      style={{ border: '2px solid #f00', background: 'white', color: 'black' }}

This creates a <Button> component which should have a red border, white background, and black text.

  • CSS classes:

You might be inclined to work with real CSS code, outsourced into .css files. For this, you need to import a basic CSS file in your document and use it like you would a normal CSS document. 

  • CSS Modules:

Instead of using a giant, global CSS file you can use CSS modules to locally scope CSS inside your application in React. With CSS files, you could run into conflicts. The easiest way to avoid CSS conflicts between pages on React is to use CSS-modules.

  • CSS-in-JS Modules:

CSS-in-JS modules are a popular option for styling React applications because they integrate closely with React components. There are a few different libraries such as Styled Components, Emotion, and Styled-jsx. One of the most used ones is Styled Components; it uses the React philosophy to break everything down into small reusable chunks and it carries this philosophy to CSS as well.



10. What is the significance of refs in React?

Refs are a shorthand used for references in React. They are used to store a reference to a single React element or a React component, it provides us quick and simple access to the DOM Element represented by a React Element. This is later returned using the render function. Refs can be used in several  scenarios,

Let’s say if you have any imperative animations that keep running on a loop, or in case you have to work with third-party DOM libraries. And then one very important usage of refs is to manage focus on a specific element in your React component, such as when the component first mounts, or perhaps after form submission.

Refs can be either a string or a function. Using a string will tell React to automatically store the DOM Element as this.refs[refValue]. For example:

class List extends Component {



    render() {
        return <div onClick={e => this._printValue()}>
            <input type="text" ref="someThing" />

DOM.render(<List />, document.body)

React automatically attaches the DOM node to the ref, meaning that this.refs.someThing will directly point to a DOM Element instance.



Try to remember that interview questions are designed to determine whether you have the skills required to complete the job you are applying for. Being in a high-pressure situation like a programming interview might have you a little flustered but work through it. You have to prove that you have the skills required to do the job, rather than just tell the interviewer that you have them. If you deeply understand coding and JS, it makes you a great programmer, but having the ability and patience to pass your knowledge to people with these details and explanations makes you unique!

Post a Comment
Join the community

Written By