ReactJS Interview Questions & Answers

1)What is React?
Ans:

React is an open-source frontend JavaScript library which is used for building user interfaces especially for single page applications. It is used for handling view layer for web and mobile apps. React was created by Jordan Walke, a software engineer working for Facebook. React was first deployed on Facebook’s News Feed in 2011 and on Instagram in 2012.

2)What are the major features of React?
Ans:

The major features of React are:

It uses VirtualDOM instead RealDOM considering that RealDOM manipulations are expensive.
Supports server-side rendering.
Follows Unidirectional* data flow or data binding.
Uses reusable/composable UI components to develop the view.

3)What is JSX?
Ans:

JSX is a XML-like syntax extension to ECMAScript (the acronym stands for JavaScript XML). Basically it just provides syntactic sugar for the React.createElement() function, giving us expressiveness of JavaScript along with HTML like template syntax.

In the example below text inside <h1> tag return as JavaScript function to the render function.

class App extends React.Component {
render() {
return(
<div>
<h1>{‘Welcome to React world!’}</h1>
</div>
)
}
}

4)What is the difference between Element and Component?
Ans:

An Element is a plain object describing what you want to appear on the screen in terms of the DOM nodes or other components. Elements can contain other Elements in their props. Creating a React element is cheap. Once an element is created, it is never mutated.

The object representation of React Element would be as follows:

const element = React.createElement(
‘div’,
{id: ‘login-btn’},
‘Login’
)
The above React.createElement() function returns an object:

{
type: ‘div’,
props: {
children: ‘Login’,
id: ‘login-btn’
}
}
And finally it renders to the DOM using ReactDOM.render():

<div id=’login-btn’>Login</div>

Whereas a component can be declared in several different ways. It can be a class with a render() method. Alternatively, in simple cases, it can be defined as a function. In either case, it takes props as an input, and returns a JSX tree as the output:

const Button = ({ onLogin }) =>
<div id={‘login-btn’} onClick={onLogin}>Login</div>
Then JSX gets transpiled to a React.createElement() function tree:

const Button = ({ onLogin }) => React.createElement(
‘div’,
{ id: ‘login-btn’, onClick: onLogin },
‘Login’
)

5)How to create components in React?
Ans:

There are two possible ways to create a component.

Function Components: This is the simplest way to create a component. Those are pure JavaScript functions that accept props object as first parameter and return React elements:

function Greeting({ message }) {
return <h1>{`Hello, ${message}`}</h1>?
}
Class Components: You can also use ES6 class to define a component. The above function component can be written as:

class Greeting extends React.Component {
render() {
return <h1>{`Hello, ${this.props.message}`}</h1>
}
}

6)When to use a Class Component over a Function Component?
Ans:

If the component needs state or lifecycle methods then use class component otherwise use function component.

7)What are Pure Components?
Ans:

React.PureComponent is exactly the same as React.Component except that it handles the shouldComponentUpdate() method for you. When props or state changes, PureComponent will do a shallow comparison on both props and state. Component on the other hand won’t compare current props and state to next out of the box. Thus, the component will re-render by default whenever shouldComponentUpdate is called.

8)What is the use of refs?
Ans:

The ref is used to return a reference to the element. They should be avoided in most cases, however, they can be useful when you need a direct access to the DOM element or an instance of a component.

9)How to create refs?
Ans:

There are two approaches

This is a recently added approach. Refs are created using React.createRef() method and attached to React elements via the ref attribute. In order to use refs throughout the component, just assign the ref to the instance property within constructor.
class MyComponent extends React.Component {
constructor(props) {
super(props)
this.myRef = React.createRef()
}
render() {
return <div ref={this.myRef} />
}
}
You can also use ref callbacks approach regardless of React version. For example, the search bar component’s input element accessed as follows,
class SearchBar extends Component {
constructor(props) {
super(props);
this.txtSearch = null;
this.state = { term: ” };
this.setInputSearchRef = e => {
this.txtSearch = e;
}
}
onInputChange(event) {
this.setState({ term: this.txtSearch.value });
}
render() {
return (
<input
value={this.state.term}
onChange={this.onInputChange.bind(this)}
ref={this.setInputSearchRef} />
);
}
}
You can also use refs in function components using closures. Note: You can also use inline ref callbacks even though it is not a recommended approach

10)What are forward refs?
Ans:

Ref forwarding is a feature that lets some components take a ref they receive, and pass it further down to a child.

const ButtonElement = React.forwardRef((props, ref) => (
<button ref={ref} className=”CustomButton”>
{props.children}
</button>
));

// Create ref to the DOM button:
const ref = React.createRef();
<ButtonElement ref={ref}>{‘Forward Ref’}</ButtonElement>

11)Which is preferred option with in callback refs and findDOMNode()?
Ans:

It is preferred to use callback refs over findDOMNode() API. Because findDOMNode() prevents certain improvements in React in the future.

The legacy approach of using findDOMNode:

class MyComponent extends Component {
componentDidMount() {
findDOMNode(this).scrollIntoView()
}

render() {
return <div />
}
}
The recommended approach is:

class MyComponent extends Component {
componentDidMount() {
this.node.scrollIntoView()
}

render() {
return <div ref={node => this.node = node} />
}
}

12)Why are String Refs legacy?
Ans:

If you worked with React before, you might be familiar with an older API where the ref attribute is a string, like ref={‘textInput’}, and the DOM node is accessed as this.refs.textInput. We advise against it because string refs have below issues, and are considered legacy. String refs were removed in React v16.

They force React to keep track of currently executing component. This is problematic because it makes react module stateful, and thus causes weird errors when react module is duplicated in the bundle.
They are not composable — if a library puts a ref on the passed child, the user can’t put another ref on it. Callback refs are perfectly composable.
They don’t work with static analysis like Flow. Flow can’t guess the magic that framework does to make the string ref appear on this.refs, as well as its type (which could be different). Callback refs are friendlier to static analysis.
It doesn’t work as most people would expect with the “render callback” pattern (e.g. )
class MyComponent extends Component {
renderRow = (index) => {
// This won’t work. Ref will get attached to DataTable rather than MyComponent:
return <input ref={‘input-‘ + index} />;

// This would work though! Callback refs are awesome.
return <input ref={input => this[‘input-‘ + index] = input} />;
}

render() {
return <DataTable data={this.props.data} renderRow={this.renderRow} />
}
}

13)What is Virtual DOM?
Ans:

The Virtual DOM (VDOM) is an in-memory representation of Real DOM. The representation of a UI is kept in memory and synced with the “real” DOM. It’s a step that happens between the render function being called and the displaying of elements on the screen. This entire process is called reconciliation.

14)What is the difference between Shadow DOM and Virtual DOM?
Ans:

The Shadow DOM is a browser technology designed primarily for scoping variables and CSS in web components. The Virtual DOM is a concept implemented by libraries in JavaScript on top of browser APIs.

15)What is React Fiber?
Ans:

Fiber is the new reconciliation engine or reimplementation of core algorithm in React v16. The goal of React Fiber is to increase its suitability for areas like animation, layout, gestures, ability to pause, abort, or reuse work and assign priority to different types of updates; and new concurrency primitives.

16)What is the main goal of React Fiber?
Ans:

The goal of React Fiber is to increase its suitability for areas like animation, layout, and gestures. Its headline feature is incremental rendering: the ability to split rendering work into chunks and spread it out over multiple frames.

17)What are controlled components?
Ans:

A component that controls the input elements within the forms on subsequent user input is called Controlled Component, i.e, every state mutation will have an associated handler function.

For example, to write all the names in uppercase letters, we use handleChange as below,

handleChange(event) {
this.setState({value: event.target.value.toUpperCase()})
}

18)What are uncontrolled components?
Ans:

The Uncontrolled Components are the ones that store their own state internally, and you query the DOM using a ref to find its current value when you need it. This is a bit more like traditional HTML.

In the below UserProfile component, the name input is accessed using ref.

class UserProfile extends React.Component {
constructor(props) {
super(props)
this.handleSubmit = this.handleSubmit.bind(this)
this.input = React.createRef()
}

handleSubmit(event) {
alert(‘A name was submitted: ‘ + this.input.current.value)
event.preventDefault()
}

render() {
return (
<form onSubmit={this.handleSubmit}>
<label>
{‘Name:’}
<input type=”text” ref={this.input} />
</label>
<input type=”submit” value=”Submit” />
</form>
);
}
}
In most cases, it’s recommend to use controlled components to implement forms.

19)What is the difference between createElement and cloneElement?
Ans:

JSX elements will be transpiled to React.createElement() functions to create React elements which are going to be used for the object representation of UI. Whereas cloneElement is used to clone an element and pass it new props.

20)What is Lifting State Up in React?
Ans:

When several components need to share the same changing data then it is recommended to lift the shared state up to their closest common ancestor. That means if two child components share the same data from its parent, then move the state to parent instead of maintaining local state in both of the child components.

21)What are Higher-Order Components?
Ans:

A higher-order component (HOC) is a function that takes a component and returns a new component. Basically, it’s a pattern that is derived from React’s compositional nature.

We call them pure components because they can accept any dynamically provided child component but they won’t modify or copy any behavior from their input components.

const EnhancedComponent = higherOrderComponent(WrappedComponent)
HOC can be used for many use cases:

Code reuse, logic and bootstrap abstraction.
Render hijacking.
State abstraction and manipulation.
Props manipulation.

22)How to create props proxy for HOC component?
Ans:

You can add/edit props passed to the component using props proxy pattern like this:

function HOC(WrappedComponent) {
return class Test extends Component {
render() {
const newProps = {
title: ‘New Header’,
footer: false,
showFeatureX: false,
showFeatureY: true
}

return <WrappedComponent {…this.props} {…newProps} />
}
}
}

23)What is context?
Ans:

Context provides a way to pass data through the component tree without having to pass props down manually at every level. For example, authenticated user, locale preference, UI theme need to be accessed in the application by many components.

const {Provider, Consumer} = React.createContext(defaultValue)

24)What is children prop?
Ans:

Children is a prop (this.prop.children) that allow you to pass components as data to other components, just like any other prop you use. Component tree put between component’s opening and closing tag will be passed to that component as children prop.

There are a number of methods available in the React API to work with this prop. These include React.Children.map, React.Children.forEach, React.Children.count, React.Children.only, React.Children.toArray. A simple usage of children prop looks as below,

const MyDiv = React.createClass({
render: function() {
return <div>{this.props.children}</div>
}
})

ReactDOM.render(
<MyDiv>
<span>{‘Hello’}</span>
<span>{‘World’}</span>
</MyDiv>,
node
)

25)How to write comments in React?
Ans:

The comments in React/JSX are similar to JavaScript Multiline comments but are wrapped in curly braces.

Single-line comments:

<div>
{/* Single-line comments(In vanilla JavaScript, the single-line comments are represented by double slash(//)) */}
{`Welcome ${user}, let’s play React`}
</div>
Multi-line comments:

<div>
{/* Multi-line comments for more than
one line */}
{`Welcome ${user}, let’s play React`}
</div>

26)What is the purpose of using super constructor with props argument?
Ans:

A child class constructor cannot make use of this reference until super() method has been called. The same applies for ES6 sub-classes as well. The main reason of passing props parameter to super() call is to access this.props in your child constructors.

Passing props:

class MyComponent extends React.Component {
constructor(props) {
super(props)

console.log(this.props) // prints { name: ‘John’, age: 42 }
}
}
Not passing props:

class MyComponent extends React.Component {
constructor(props) {
super()

console.log(this.props) // prints undefined

// but props parameter is still available
console.log(props) // prints { name: ‘John’, age: 42 }
}

render() {
// no difference outside constructor
console.log(this.props) // prints { name: ‘John’, age: 42 }
}
}
The above code snippets reveals that this.props is different only within the constructor. It would be the same outside the constructor.

27)What is reconciliation?
Ans:

When a component’s props or state change, React decides whether an actual DOM update is necessary by comparing the newly returned element with the previously rendered one. When they are not equal, React will update the DOM. This process is called reconciliation.

28)How to set state with a dynamic key name?
Ans:

If you are using ES6 or the Babel transpiler to transform your JSX code then you can accomplish this with computed property names.

handleInputChange(event) {
this.setState({ [event.target.id]: event.target.value })
}

29)What would be the common mistake of function being called every time the component renders?
Ans:

You need to make sure that function is not being called while passing the function as a parameter.

render() {
// Wrong: handleClick is called instead of passed as a reference!
return <button onClick={this.handleClick()}>{‘Click Me’}</button>
}
Instead, pass the function itself without parenthesis:

render() {
// Correct: handleClick is passed as a reference!
return <button onClick={this.handleClick}>{‘Click Me’}</button>
}

30)Why is it necessary to capitalize component names?
Ans:

It is necessary because components are not DOM elements, they are constructors. Also, in JSX lowercase tag names are referring to HTML elements, not components.

31)Why React uses className over class attribute?
Ans:

class is a keyword in JavaScript, and JSX is an extension of JavaScript. That’s the principal reason why React uses className instead of class. Pass a string as the className prop.

render() {
return <span className={‘menu navigation-menu’}>{‘Menu’}</span>
}

32)What are fragments?
Ans:

It’s common pattern in React which is used for a component to return multiple elements. Fragments let you group a list of children without adding extra nodes to the DOM.

render() {
return (
<React.Fragment>
<ChildA />
<ChildB />
<ChildC />
</React.Fragment>
)
}
There is also a shorter syntax, but it’s not supported in many tools:

render() {
return (
<>
<ChildA />
<ChildB />
<ChildC />
</>
)
}

33)Why fragments are better than container divs?
Ans:

Fragments are a bit faster and use less memory by not creating an extra DOM node. This only has a real benefit on very large and deep trees.
Some CSS mechanisms like Flexbox and CSS Grid have a special parent-child relationships, and adding divs in the middle makes it hard to keep the desired layout.
The DOM Inspector is less cluttered.

34)What are portals in React?
Ans:

Portal is a recommended way to render children into a DOM node that exists outside the DOM hierarchy of the parent component.

ReactDOM.createPortal(child, container)
The first argument is any render-able React child, such as an element, string, or fragment. The second argument is a DOM element.

35)What are stateless components?
Ans:

If the behaviour is independent of its state then it can be a stateless component. You can use either a function or a class for creating stateless components. But unless you need to use a lifecycle hook in your components, you should go for function components. There are a lot of benefits if you decide to use function components here; they are easy to write, understand, and test, a little faster, and you can avoid the this keyword altogether.

36)What are stateful components?
Ans:

If the behaviour of a component is dependent on the state of the component then it can be termed as stateful component. These stateful components are always class components and have a state that gets initialized in the constructor.

class App extends Component {
constructor(props) {
super(props)
this.state = { count: 0 }
}

render() {
// …
}
}

37)How to apply validation on props in React?
Ans:

When the application is running in development mode, React will automatically check all props that we set on components to make sure they have correct type. If the type is incorrect, React will generate warning messages in the console. It’s disabled in production mode due performance impact. The mandatory props are defined with isRequired.

The set of predefined prop types:

PropTypes.number
PropTypes.string
PropTypes.array
PropTypes.object
PropTypes.func
PropTypes.node
PropTypes.element
PropTypes.bool
PropTypes.symbol
PropTypes.any
We can define propTypes for User component as below:

import React from ‘react’
import PropTypes from ‘prop-types’

class User extends React.Component {
static propTypes = {
name: PropTypes.string.isRequired,
age: PropTypes.number.isRequired
}

render() {
return (
<>
<h1>{`Welcome, ${this.props.name}`}</h1>
<h2>{`Age, ${this.props.age}`}</h2>
</>
)
}
}
Note: In React v15.5 PropTypes were moved from React.PropTypes to prop-types library.

38)What are the advantages of React?
Ans:

Increases the application’s performance with Virtual DOM.
JSX makes code easy to read and write.
It renders both on client and server side (SSR).
Easy to integrate with frameworks (Angular, Backbone) since it is only a view library.
Easy to write unit and integration tests with tools such as Jest.

39)What are the limitations of React?
Ans:

React is just a view library, not a full framework.
There is a learning curve for beginners who are new to web development.
Integrating React into a traditional MVC framework requires some additional configuration.
The code complexity increases with inline templating and JSX.
Too many smaller components leading to over engineering or boilerplate.

40)What are error boundaries in React v16?
Ans:

Error boundaries are components that catch JavaScript errors anywhere in their child component tree, log those errors, and display a fallback UI instead of the component tree that crashed.

A class component becomes an error boundary if it defines a new lifecycle method called componentDidCatch(error, info) or static getDerivedStateFromError() :

class ErrorBoundary extends React.Component {
constructor(props) {
super(props)
this.state = { hasError: false }
}

componentDidCatch(error, info) {
// You can also log the error to an error reporting service
logErrorToMyService(error, info)
}

static getDerivedStateFromError(error) {
// Update state so the next render will show the fallback UI.
return { hasError: true };
}

render() {
if (this.state.hasError) {
// You can render any custom fallback UI
return <h1>{‘Something went wrong.’}</h1>
}
return this.props.children
}
}
After that use it as a regular component:

<ErrorBoundary>
<MyWidget />
</ErrorBoundary>

41)How error boundaries handled in React v15?
Ans:

React v15 provided very basic support for error boundaries using unstable_handleError method. It has been renamed to componentDidCatch in React v16.

42)What are the recommended ways for static type checking?
Ans:

Normally we use PropTypes library (React.PropTypes moved to a prop-types package since React v15.5) for type checking in the React applications. For large code bases, it is recommended to use static type checkers such as Flow or TypeScript, that perform type checking at compile time and provide auto-completion features.

43)What is the use of react-dom package?
Ans:

The react-dom package provides DOM-specific methods that can be used at the top level of your app. Most of the components are not required to use this module. Some of the methods of this package are:

render()
hydrate()
unmountComponentAtNode()
findDOMNode()
createPortal()

44)What is the purpose of render method of react-dom?
Ans:

This method is used to render a React element into the DOM in the supplied container and return a reference to the component. If the React element was previously rendered into container, it will perform an update on it and only mutate the DOM as necessary to reflect the latest changes.

ReactDOM.render(element, container[, callback])
If the optional callback is provided, it will be executed after the component is rendered or updated.

45)What is ReactDOMServer?
Ans:

The ReactDOMServer object enables you to render components to static markup (typically used on node server). This object is mainly used for server-side rendering (SSR). The following methods can be used in both the server and browser environments:

renderToString()
renderToStaticMarkup()
For example, you generally run a Node-based web server like Express, Hapi, or Koa, and you call renderToString to render your root component to a string, which you then send as response.

// using Express
import { renderToString } from ‘react-dom/server’
import MyPage from ‘./MyPage’

app.get(‘/’, (req, res) => {
res.write(‘<!DOCTYPE html><html><head><title>My Page</title></head><body>’)
res.write(‘<div id=”content”>’)
res.write(renderToString(<MyPage/>))
res.write(‘</div></body></html>’)
res.end()
})

46)How to use innerHTML in React?
Ans:

The dangerouslySetInnerHTML attribute is React’s replacement for using innerHTML in the browser DOM. Just like innerHTML, it is risky to use this attribute considering cross-site scripting (XSS) attacks. You just need to pass a __html object as key and HTML text as value.

In this example MyComponent uses dangerouslySetInnerHTML attribute for setting HTML markup:

function createMarkup() {
return { __html: ‘First &middot; Second’ }
}

function MyComponent() {
return <div dangerouslySetInnerHTML={createMarkup()} />
}

47)How to use styles in React?
Ans:

The style attribute accepts a JavaScript object with camelCased properties rather than a CSS string. This is consistent with the DOM style JavaScript property, is more efficient, and prevents XSS security holes.

const divStyle = {
color: ‘blue’,
backgroundImage: ‘url(‘ + imgUrl + ‘)’
};

function HelloWorldComponent() {
return <div style={divStyle}>Hello World!</div>
}
Style keys are camelCased in order to be consistent with accessing the properties on DOM nodes in JavaScript (e.g. node.style.backgroundImage).

48)How events are different in React?
Ans:

Handling events in React elements has some syntactic differences:

React event handlers are named using camelCase, rather than lowercase.
With JSX you pass a function as the event handler, rather than a string.

49)What will happen if you use setState() in constructor?
Ans:

When you use setState(), then apart from assigning to the object state React also re-renders the component and all its children. You would get error like this: Can only update a mounted or mounting component. So we need to use this.state to initialize variables inside constructor.

50)What is the impact of indexes as keys?
Ans:

Keys should be stable, predictable, and unique so that React can keep track of elements.

In the below code snippet each element’s key will be based on ordering, rather than tied to the data that is being represented. This limits the optimizations that React can do.

{todos.map((todo, index) =>
<Todo
{…todo}
key={index}
/>
)}
If you use element data for unique key, assuming todo.id is unique to this list and stable, React would be able to reorder elements without needing to reevaluate them as much.

{todos.map((todo) =>
<Todo {…todo}
key={todo.id} />
)}

51)Is it good to use setState() in componentWillMount() method?
Ans:

It is recommended to avoid async initialization in componentWillMount() lifecycle method. componentWillMount() is invoked immediately before mounting occurs. It is called before render(), therefore setting state in this method will not trigger a re-render. Avoid introducing any side-effects or subscriptions in this method. We need to make sure async calls for component initialization happened in componentDidMount() instead of componentWillMount().

componentDidMount() {
axios.get(`api/todos`)
.then((result) => {
this.setState({
messages: […result.data]})
})
}

52)What will happen if you use props in initial state?
Ans:

If the props on the component are changed without the component being refreshed, the new prop value will never be displayed because the constructor function will never update the current state of the component. The initialization of state from props only runs when the component is first created.

The below component won’t display the updated input value:

class MyComponent extends React.Component {
constructor(props) {
super(props)

this.state = {
records: [],
inputValue: this.props.inputValue
};
}

render() {
return <div>{this.state.inputValue}</div>
}
}
Using props inside render method will update the value:

class MyComponent extends React.Component {
constructor(props) {
super(props)

this.state = {
record: []}
}

render() {
return <div>{this.props.inputValue}</div>
}
}

53)How do you conditionally render components?
Ans:

In some cases you want to render different components depending on some state. JSX does not render false or undefined, so you can use conditional short-circuiting to render a given part of your component only if a certain condition is true.

const MyComponent = ({ name, address }) => (
<div>
<h2>{name}</h2>
{address &&
<p>{address}</p>
}
</div>
)
If you need an if-else condition then use ternary operator.

const MyComponent = ({ name, address }) => (
<div>
<h2>{name}</h2>
{address
? <p>{address}</p>
: <p>{‘Address is not available’}</p>
}
</div>
)

54)Why we need to be careful when spreading props on DOM elements?
Ans:

When we spread props we run into the risk of adding unknown HTML attributes, which is a bad practice. Instead we can use prop destructuring with …rest operator, so it will add only required props. For example,

const ComponentA = () =>
<ComponentB isDisplay={true} className={‘componentStyle’} />

const ComponentB = ({ isDisplay, …domProps }) =>
<div {…domProps}>{‘ComponentB’}</div>

55)How you use decorators in React?
Ans:

You can decorate your class components, which is the same as passing the component into a function. Decorators are flexible and readable way of modifying component functionality.

@setTitle(‘Profile’)
class Profile extends React.Component {
//….
}

/*
title is a string that will be set as a document title
WrappedComponent is what our decorator will receive when
put directly above a component class as seen in the example above
*/
const setTitle = (title) => (WrappedComponent) => {
return class extends React.Component {
componentDidMount() {
document.title = title
}

render() {
return <WrappedComponent {…this.props} />
}
}
}
Note: Decorators are a feature that didn’t make it into ES7, but are currently a stage 2 proposal.

56)How do you memoize a component?
Ans:

There are memoize libraries available which can be used on function components. For example moize library can memoize the component in another component.

import moize from ‘moize’
import Component from ‘./components/Component’ // this module exports a non-memoized component

const MemoizedFoo = moize.react(Component)

const Consumer = () => {
<div>
{‘I will memoize the following entry:’}
<MemoizedFoo/>
</div>
}

For more  Click Here

---

For Course Content  Click Here