Most Commonly Asked React Interview Questions 2024 - Part 1
Tags: react, interview, webdev, beginners
Published: 2024-03-15 04:00:17

> If you like this blog, you can visit my personal blog [sehgaltech](https://blog.sehgaltech.com/) for more content.



## 1. What is React? Why is it used?

React is a popular JavaScript library for building user interfaces, particularly single-page applications where you need a fast, interactive user experience. It was developed by Facebook and is now maintained by Facebook and a community of individual developers and companies.

React allows developers to create large web applications that can update and render efficiently in response to data changes, without requiring a page reload. It does this by using a virtual DOM (Document Object Model) and only updating the parts of the page that changed, rather than the entire page. This makes it highly performant.

React also introduces a component-based architecture. This means you build encapsulated components that manage their own state, then compose them to make complex UIs. Each component is a piece of UI and can be reused wherever you need it. This leads to cleaner and more modular code, which is easier to maintain and test.

React is used for its efficiency, flexibility, and simplicity. It's efficient because it only updates the necessary parts of the UI and doesn't waste time re-rendering components that haven't changed. It's flexible because it allows you to create your own components and use them however you like. And it's simple because it uses JavaScript syntax extension (JSX), which allows you to write HTML-like syntax in your JavaScript code, making it easier to understand and write.

React is used by many large companies including Facebook, Instagram, Airbnb, Netflix, WhatsApp, and more. It's also widely used in startups and other web-based businesses.
<br>

## 2. Explain the difference between a class component and a functional component?

In React, you can define components in two ways: as Class components or as Functional components. Here are the main differences between the two:

1. **Class Components:**
   - Class components are ES6 classes that extend from `React.Component`.
   - They must have a `render` method which returns JSX.
   - They can have state (i.e., mutable data) and lifecycle methods (like `componentDidMount`, `componentDidUpdate`, and `componentWillUnmount`).
   - They are more verbose than functional components.
   - Here's an example of a class component:

```jsx

import React from 'react';

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

  componentDidMount() {
    console.log('Component mounted');
  }

  render() {
    return <h1>Hello, {this.props.name}</h1>;
  }
}

export default MyClassComponent;

```

2. **Functional Components:**
   - Functional components are simply JavaScript functions that return JSX.
   - They do not have their own state or lifecycle methods. However, with the introduction of Hooks in React 16.8, you can now use state and lifecycle features in functional components.
   - They are less verbose and easier to read and test.
   - Here's an example of a functional component:

```jsx

import React from 'react';

const MyFunctionalComponent = (props) => {
  return <h1>Hello, {props.name}</h1>;
}

export default MyFunctionalComponent;

```

In modern React development, functional components are preferred due to their simplicity and the introduction of Hooks, which allow you to use state and other React features without writing a class.
<br>

## 3. What are the main differences in syntax between class components and functional components?

The main differences in syntax between class components and functional components in React are as follows:

**Class Components:**
- Class components are ES6 classes. They must have a `render` method which returns JSX.
- They have a more complex syntax due to the need for a constructor to initialize state and the requirement of `this` keyword for handling events and accessing props and state.
- Here's an example of a class component:

```jsx

import React from 'react';

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

  componentDidMount() {
    console.log('Component mounted');
  }

  render() {
    return <h1>Hello, {this.props.name}</h1>;
  }
}

export default MyClassComponent;

```

**Functional Components:**
- Functional components are simply JavaScript functions that return JSX.
- They have a simpler syntax and are easier to read and test.
- Here's an example of a functional component:

```jsx

import React from 'react';

const MyFunctionalComponent = (props) => {
  return <h1>Hello, {props.name}</h1>;
}

export default MyFunctionalComponent;

```
<br>


## 4. How do class components handle state compared to functional components?

- Class components have a built-in state object that can be initialized in the constructor and updated with `this.setState()`.
- Functional components, prior to React 16.8, were stateless. However, with the introduction of Hooks, functional components can now use state via the `useState` Hook.
<br>

## 5. Can you explain the role of lifecycle methods in class components and how they differ from functional components?

- Class components have lifecycle methods like `componentDidMount`, `componentDidUpdate`, and `componentWillUnmount` which allow you to run code at specific points in the component's lifecycle.
- Functional components do not have lifecycle methods. However, the `useEffect` Hook in functional components can replicate the behavior of these lifecycle methods.

## 6. How does the introduction of Hooks impact the usage of state and lifecycle features in functional components?

- Hooks are a new addition in React 16.8 that let you use state and other React features without writing a class.
- The `useState` Hook lets you add state to functional components, and the `useEffect` Hook lets you perform side effects in functional components, such as data fetching, subscriptions, or manually changing the DOM.
- Hooks do not work inside classes — they let you use React without classes.
<br>

## 7. What are React hooks? Can you give some examples of how to use them?

React Hooks are a feature introduced in React 16.8 that allow you to use state and other React features without writing a class. They are functions that let you "hook into" React state and lifecycle features from functional components. 

Here are some of the most commonly used hooks:

1. **useState:** This hook lets you add React state to functional components.

```jsx

import React, { useState } from 'react';

function Counter() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

export default Counter;

```

In this example, `useState` is called with the initial state. It returns a pair of values: the current state and a function that updates it. This is why we write `const [count, setCount] = useState(0)`. This is similar to `this.state.count` and `this.setState` in a class, except you get them in a pair.

2. **useEffect:** This hook lets you perform side effects in functional components. It is a close replacement for `componentDidMount`, `componentDidUpdate`, and `componentWillUnmount`.

```jsx

import React, { useState, useEffect } from 'react';

function Example() {
  const [count, setCount] = useState(0);

  // Similar to componentDidMount and componentDidUpdate:
  useEffect(() => {
    // Update the document title using the browser API
    document.title = `You clicked ${count} times`;
  });

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

export default Example;

```

In this example, the `useEffect` hook is used to update the document title after React updates the DOM. The effect hook runs when the component mounts and also when it updates.

3. **useContext:** This hook lets you subscribe to React context without introducing nesting.

```jsx

import React, { useContext } from 'react';
const ThemeContext = React.createContext('light');

function ThemedButton() {
  const theme = useContext(ThemeContext);
  return <button theme={theme}>I am styled by theme context!</button>;
}

export default ThemedButton;

```

In this example, the `useContext` hook is used to consume a context value from the nearest `ThemeContext.Provider` up the tree from this component. This is a simpler way to consume context compared to the `Context.Consumer` component or the `contextType` class property.

Remember, hooks are only available in functional components. They cannot be used in class components.
<br>

## 8. What is JSX? How is it different from HTML and JavaScript?

JSX stands for JavaScript XML. It is a syntax extension for JavaScript, developed by Facebook, and is used with React to describe what the UI should look like. JSX produces React "elements" and has a syntax very similar to HTML.

Here are some key points about JSX:

1. **JSX is not HTML nor JavaScript, but it is very similar:** JSX looks a lot like HTML and can be written within JavaScript code. However, it's not exactly either of the two. It's a syntax extension for JavaScript that allows you to write HTML-like code in your JavaScript files.

2. **JSX is an Expression:** After compilation, JSX expressions become regular JavaScript function calls and evaluate to JavaScript objects. This means that you can use JSX inside of if statements and for loops, assign it to variables, accept it as arguments, and return it from functions.

3. **JSX Attributes & Expressions:** You can use quotes to specify string literals as attributes in JSX, or you can use curly braces to embed a JavaScript expression in an attribute. You can also embed JavaScript expressions in JSX using curly braces, excluding statements and flow control.

4. **JSX Prevents Injection Attacks:** It is safe to embed user input in JSX because React DOM escapes any values embedded in JSX before rendering them. This ensures that you can never inject anything that's not explicitly written in your application.

5. **JSX Represents Objects:** Babel compiles JSX down to `React.createElement()` calls, which means that a JSX tag is just syntactic sugar for calling `React.createElement(component, props, ...children)`.

Here's an example of JSX in a functional component:

```jsx

function HelloComponent() {
  return <h1>Hello, world!</h1>;
}

```

**Differences between JSX, HTML, and JavaScript:**

- **JSX vs HTML:** While JSX may look like HTML, there are some key differences. For example, because JSX is JavaScript, you can't use JavaScript reserved words. This is why `class` becomes `className` in JSX. Also, since JSX is closer to JavaScript than to HTML, React DOM uses camelCase property naming convention instead of HTML attribute names. For example, `tabindex` in HTML becomes `tabIndex` in JSX.

- **JSX vs JavaScript:** JSX is an extension to JavaScript, not a separate language. It's a way to write HTML-like code in your JavaScript files, but under the hood, it's all JavaScript. JSX code is transformed into regular JavaScript calls to `React.createElement()` before it reaches the browser.
<br>

9. What is the virtual DOM in React?

The Virtual DOM (VDOM) is a key feature of React that allows it to be highly performant and efficient. It's a programming concept where an ideal, or "virtual", representation of a UI is kept in memory and synced with the "real" DOM by a library such as ReactDOM. This process is called reconciliation.

Here's how it works:

1. When a component's state changes, a new virtual DOM tree is created. This tree is a representation of what the UI will look like after the state change.

2. React then compares this new virtual DOM tree with the old one (the one representing the current UI).

3. Through a process called "diffing", React identifies the differences between the new and old virtual DOM.

4. Once the differences are identified, React updates only those objects in the real DOM that need to change to reflect the new state. This is called "patching".

This process is much faster than updating the entire DOM, which is what happens in traditional web page rendering. The virtual DOM allows React to minimize interactions with the actual DOM, which is slow to touch and manipulate. This leads to a smoother and faster user experience.

It's important to note that the virtual DOM isn't a feature of React alone. Other libraries and frameworks also use a similar concept to improve performance. However, React was one of the first to use it effectively on a large scale.
<br>

10. What is Reconciliation in React?

Reconciliation is a process in React that allows it to efficiently update the user interface. It's the algorithm behind what makes React fast. Here's how it works:

1. **Render Phase**: When a component's state or props change, React triggers a re-render. During this phase, React calls the render method and generates a new virtual DOM tree. This tree represents what the UI should look like after the state or props change.

2. **Diffing Algorithm**: React then compares this new virtual DOM tree with the old one (the one representing the current UI). This comparison is done using a diffing algorithm. The algorithm goes through both trees and identifies the differences. 

3. **Update Phase**: Once the differences are identified, React proceeds to the update phase. In this phase, React updates only those objects in the real DOM that need to change to reflect the new state. This process is called "patching" or "committing updates". 

4. **Batching**: React also batches multiple updates together to minimize the number of times it has to interact with the real DOM, which is a relatively slow operation. 

This process allows React to be highly efficient, as it minimizes the number of manipulations with the real DOM, which is one of the slower operations in any web application. It also allows React to provide a smoother and faster user experience. 

It's important to note that reconciliation is a heuristic algorithm, and its performance is linear (O(n)) where n is the number of elements in the tree. This makes it very efficient even for large applications.
<br>


> If you like this blog, you can visit my personal blog [sehgaltech](https://blog.sehgaltech.com/) for more content.