React Interview Questions for Freshers 2023

Introduction to React

React is an efficient, flexible, and open-source JavaScript framework library that allows developers to the creation of simple, fast, and scalable web applications. Jordan Walke, a software engineer who was working for Facebook created React. It was first deployed on the news feed of Facebook in 2011 and on Instagram in 2012. Developers from the Javascript background can easily develop web applications with the help of React. React Hooks will allow you to use the state and other features of React in which requires a class to be written by you. In simple words, we can say   that, React Hooks are the functions that will connect React state with the lifecycle features from the function components. React Hooks is among the features that are implemented
latest in the version React 16.8.

Scope of React:

The selection of the right technology for application or web development is becoming more challenging. React has been considered to be the fastest-growing Javascript framework among all. The tools of Javascript are firming their roots slowly and steadily in the marketplace and the React certification demands exponentially increasing. React is a clear win for front-end developers as it has a quick learning curve, clean abstraction, and reusable components. Currently, there is no end in sight for React as it keeps evolving.

Question 1. What is React?

Answer: React is a front-end and open-source JavaScript library which is useful in developing  user interfaces specifically for applications with a single page. It is helpful in building complex and reusable user interface(UI) components of mobile and web applications as it follows the component-based approach. The important features of React are:

  • It supports server-side rendering.
  • It will make use of the virtual DOM rather than real DOM (Data Object Model) as Real DOM manipulations are expensive.
  • It follows unidirectional data binding or data flow.
  • It uses reusable or composable UI components for developing the view.

Question 2. What are the advantages of using React?

Answer: MVC is generally abbreviated as Model View Controller.

  • Use of Virtual DOM to improve efficiency: React uses virtual DOM to render the view. As the name suggests, virtual DOM is a virtual representation of the real DOM. Each time the data changes in a react app, a new virtual DOM gets created. Creating a virtual DOM is much faster than rendering the UI inside the browser. Therefore, with the use of virtual DOM, the efficiency of the app improves.
  • Gentle learning curve: React has a gentle learning curve when compared to frameworks like Angular. Anyone with little knowledge of java-script can start building web applications using React.
  • SEO friendly: React allows developers to develop engaging user interfaces that can be easily navigated in various search engines. It also allows server-side rendering, which boosts the SEO of an app.
  • Reusable components: React uses component-based architecture for developing applications. Components are independent and reusable bits of code. These components can be shared across various applications having similar functionality. The re-use of components increases the pace of development.
  • Huge ecosystem of libraries to choose from: React provides you with the freedom to choose the tools, libraries, and architecture for developing an application based on your requirement.

Also Read:

Question 3. What are the limitations of React?

Answer:  The few limitations of React are as given below:

  • React is not a full-blown framework as it is only a library.
  • The components of React are numerous and will take time to fully grasp the benefits of all.
  • It might be difficult for beginner programmers to understand React.
  • Coding might become complex as it will make use of inline templating and JSX

Question 4. What is useState() in React?

Answer: The useState() is a built-in React Hook that allows you for having state variables in functional components. It should be used when the DOM has something that is dynamically manipulating/controlling.  In the below-given example code, The useState(0) will return a tuple where the count is the first parameter that represents the counter’s current state and the second
parameter setCounter method will allow us to update the state of the counter.


const [count, setCounter] = useState(0);
const [otherStuffs, setOtherStuffs] = useState(…);

const setCount = () => {
setCounter(count + 1);
setOtherStuffs(…);

};

We can make use of setCounter() method for updating the state of count anywhere. In this example, we are using setCounter() inside the setCount function where various other things can also be done. The idea with the usage of hooks is that we will be able to keep our code more functional and avoid class-based components if they are not required.

Question 5. What are keys in React?

A key is a special string attribute that needs to be included when using lists of elements.

react decryptinfo

Example of a list using key –

const ids = [1,2,3,4,5];
const listElements = ids.map((id)=>{
return(
<li key={id.toString()}>
{id}
</li>
)
})

Importance of keys –

  • Keys help react identify which elements were added, changed or removed.
  • Keys should be given to array elements for providing a unique identity for each element.
  • Without keys, React does not understand the order or uniqueness of each element.
  • With keys, React has an idea of which particular element was deleted, edited, and added.
  • Keys are generally used for displaying a list of data coming from an API.

Question  6. What is JSX?

Answer: JSX stands for JavaScript XML. It allows us to write HTML inside JavaScript and place them in the DOM without using functions like appendChild( ) or createElement( ). As stated in the official docs of React, JSX provides syntactic sugar for React.createElement( ) function.

Note- We can create react applications without using JSX as well. Let’s understand how JSX works:
Without using JSX, we would have to create an element by the following process:

const text = React.createElement(‘p’, {}, ‘This is a text’);
const container = React.createElement(‘div’,'{}’,text );
ReactDOM.render(container,rootElement);

Using JSX, the above code can be simplified:
const container = (
<div>
<p>This is a text</p>
</div>
);
ReactDOM.render(container,rootElement);
As one can see in the code above, we are directly using HTML inside JavaScript.

Question 7. What are the differences between functional and class components?

Answer: Before the introduction of Hooks in React, functional components were called stateless components and were behind class components on a feature basis. After the introduction of Hooks, functional components are equivalent to class components

Although functional components are the new trend, the react team insists on  keeping class components in React. Therefore, it is important to know how these components differ.
On the following basis let’s compare functional and class components:

Declaration :

Functional components are nothing but JavaScript functions and therefore can be declared using an arrow function or the function keyword:

function card(props){
return(
<div className=”main-container”>
<h2>Title of the card</h2>
</div>
)
}
const card = (props) =>{
return(
<div className=”main-container”>
<h2>Title of the card</h2>
</div>
)
}

Also Read:

Class components, on the other hand, are declared using the ES6 class:

class Card extends React.Component{
constructor(props){
super(props);
}
render(){
return(
<div className=”main-container”>
<h2>Title of the card</h2>
</div>
)
}
}

Handling props :

Let’s render the following component with props and analyse how functional and  class components handle props:

<Student Info name=”Vivek” rollNumber=”23″ />

In functional components, the handling of props is pretty straightforward. Any prop provided as an argument to a functional component can be directly used inside HTML elements:

function StudentInfo(props){
return(
<div className=”main”>
<h2>{props.name}</h2>
<h4>{props.rollNumber}</h4>
</div>
)
}

In the case of class components, props are handled in a different way:

class StudentInfo extends React.Component{
constructor(props){
super(props);
}
render(){
return(
<div className=”main”>
<h2>{this.props.name}</h2>
<h4>{this.props.rollNumber}</h4>
</div>
)
}
}

As we can see in the code above, this keyword is used in the case of class components.

Handling state:

Functional components use React hooks to handle state. It uses the useState hook to set the state of a variable inside the component:

class ClassRoom extends React.Component{
constructor(props){
super(props);
this.state = {studentsCount : 0};
this.addStudent = this.addStudent.bind(this);
}
addStudent(){
this.setState((prevState)=>{
return {studentsCount: prevState.studentsCount++}
});
}
render(){
return(
<div>
<p>Number of students in class room: {this.state.studentsCount}</p>
<button onClick={this.addStudent}>Add Student</button>
</div>
)
}
}

In the code above, we see we are using this.state to add the variable studentsCount and setting the value to “0”. For reading the state, we are using this.state.studentsCount. For updating the state, we need to first bind the addStudent function to this. Only then, we will be able to use the setState function which is used to update the state.

Question 8. What is the virtual DOM? How does react use the virtual DOM to render the UI?

Answer:  As stated by the react team, virtual DOM is a concept where a virtual representation of the real DOM is kept inside the memory and is synced with the real DOM by a library such as ReactDOM.

DOM react decryptinfo

 

Why was virtual DOM introduced?

DOM manipulation is an integral part of any web application, but DOM manipulation is quite slow when compared to other operations in JavaScript. The efficiency of the application gets affected when several DOM manipulations are being done. Most JavaScript frameworks update the entire DOM even when a small part of the DOM changes. For example, consider a list that is being rendered inside the DOM. If one of the items in the list changes, the entire list gets rendered again instead of just rendering the item that was changed/updated. This is called inefficient updating.
To address the problem of inefficient updating, the react team introduced the concept of virtual DOM.

How does it work?

For every DOM object, there is a corresponding virtual DOM object(copy), which has the same properties. The main difference between the real DOM object and the virtual DOM object is that any changes in the virtual DOM object will not reflect on the screen directly.

react

Consider a virtual DOM object as a blueprint of the real DOM object. Whenever a JSX element gets rendered, every virtual DOM object gets updated.

React uses two virtual DOMs to render the user interface. One of them is used to store the current state of the objects and the other to store the previous state of the objects. Whenever the virtual DOM gets updated, react compares the two virtual DOMs and gets to know about which virtual DOM objects were updated. After knowing which objects were updated, react renders only those objects inside the real DOM instead of rendering the complete real DOM. This way, with the use of virtual DOM, react solves the problem of inefficient updating.

Question 9. What are the differences between controlled and uncontrolled components?

Answer: Controlled and uncontrolled components are just different approaches to handling input from elements in react.

react decyprtinfo

Controlled component: In a controlled component, the value of the input element is controlled by React. We store the state of the input element inside the code, and by using event-based callbacks, any changes made to the input element will be reflected in the code as well. When a user enters data inside the input element of a controlled component, onChange function gets triggered and inside the code, we check whether the value entered is valid or invalid. If the value is valid, we change the state and re-render the input element with the new value.

Example of a controlled component:

function FormValidation(props) {
let [inputValue, setInputValue] = useState(“”);
let updateInput = e => {
setInputValue(e.target.value);
};
return (
<div>
<form>
<input type=”text” value={inputValue} onChange={updateInput} />
</form>
</div>
);
}

As one can see in the code above, the value of the input element is determined by the state of the inputValue variable. Any changes made to the input element is handled
by the updateInput function. Uncontrolled component: In an uncontrolled component, the value of the input element is handled by the DOM itself. Input elements inside uncontrolled
components work just like normal HTML input form elements. The state of the input element is handled by the DOM. Whenever the value of the input element is changed, event-based callbacks are not called. Basically, react does not perform any action when there are changes made to the input element. Whenever use enters data inside the input field, the updated data is shown directly.
To access the value of the input element, we can use ref.

Example of an uncontrolled component:

function FormValidation(props) {
let inputValue = React.createRef();
let handleSubmit = e => {
alert(`Input value: ${inputValue.current.value}`);
e.preventDefault();
};
return (
<div>
<form onSubmit={handleSubmit}>
<input type=”text” ref={inputValue} />
<button type=”submit”>Submit</button>
</form>
</div>
);
}

As one can see in the code above, we are not using onChange function to govern the changes made to the input element. Instead, we are using ref to access the value of the input element.

Question 10. What are props in React?

Answer: The props in React are the inputs to a component of React. They can be single-valued or objects having a set of values that will be passed to components of React during creation by using a naming convention that almost looks similar to HTML-tag attributes. We can say that props are the data passed from a parent component into a child component.
The main purpose of props is to provide different component functionalities such as:

  • Passing custom data to the React component.
  • Using through this.props.reactProp inside render() method of the component
  • Triggering state changes.

For example, consider we are creating an element with reactProp property as given below: <Element reactProp = “1” /> This reactProp name will be considered as a property attached to the native props object of React which already exists on each component created with the help of React library: props.reactProp;

Also Read:

, , , , , , , , , ,

Leave a Reply