React Lifecycle Methods

Shailendra Chauhan  6 min read
20 Sep 2023

React Lifecycle Methods: An Overview

Developers have access to a powerful toolkit when using React, a well-liked JavaScript package for generating user interfaces, to build dynamic and interactive online apps. Component lifecycle, which describes the sequence of actions that take place over the course of a component's lifespan, is a key idea in React's functionality. For effectively managing state, handling updates, & maximizing speed in React apps, it's imperative to understand the components of React lifecycle methods. In this article, we'll learn the concepts of React Lifecycle Methods, lifecycle method in react, react component lifecycle, the life cycle of React js

React Component Lifecycle

React Class Based Component's lifecycle

The mounting phase

Mounting is the process of adding elements to the DOM. When mounting a component, React's four built-in functions are invoked in the following order:

  1. constructor()
  2. getDerivedStateFromProps()
  3. render()
  4. componentDidMount()

1. The constructor method

  • The constructor() method is the most obvious option to set up the initial state and other initial settings because it is called first when the component is launched.
  • The super(props) function should always be performed first since it will start the parent's constructor method and enable the component to inherit methods from its parent (React.Component).
  • The constructor() method is called with the props as arguments.

2. The static getDerivedStateFromProps method

  • Before rendering the DOM element(s), the getDerivedStateFromProps() function is used.
  • Based on the initial props, this is the logical place to set the state object.
  • It accepts the parameter state and returns an object containing the state's modifications.

3. The render method

  • The method that actually outputs the HTML to the DOM, render(), is necessary.

4. The componentDidMount method

  • After the component is rendered, the componentDidMount() function is invoked.
  • You execute instructions that need the component to be in the DOM at this point.

The updating phase

When a component is updated, the lifecycle moves on to the next step. Every time a component's state or props change, the component is updated. When a component is changed, React's five built-in methods are called in the following order:

  1. The static getDerivedStateFromProps
  2. The shouldComponentUpdate method
  3. The getSnapshotBeforeUpdate method
  4. The componentDidUpdate Method

1. The static getDerivedStateFromProps

  • getDerivedStateFromProps is the first lifecycle method to be invoked during the update phase.
  • If you have updated props and want the component's state to reflect that, this technique can be helpful. 
  • For instance, the value of a component's props could affect how it behaves.
  • Before the component was ever re-rendered, its state might already reflect the changes and be displayed (if appropriate) to the just-changed component using getDerivedStateFromProps.

2. The shouldComponentUpdate method

  • Another lifecycle method that is hardly used is shouldComponentUpdate.
  • It basically enables you to inform React when you don't need to re-render when a new state or props comes in, and it's designed primarily for performance optimization.
  • Although it can assist in avoiding re-renders, you shouldn't rely on it to do so because you risk losing an essential change and running into issues.
  • Although nextProps and nextState are available as arguments for this function, you can also define it without them.
  • A Boolean value is then returned by this procedure.
  • A re-render is determined by the Boolean value.
  • Re-rendering takes place in all circumstances whenever the state or props change when the default value is true.

3. The getSnapshotBeforeUpdate method

  • You can obtain the component's prior props and state before it is updated by using the getSnapshotBeforeUpdate function.
  • This enables you to alter or examine the state's or the props' earlier values.
  • Another infrequently employed technique is this one.
  • Managing scroll positions in a conversation app is a nice application for this technique.
  • It shouldn't force the older messages out of view when a new message arrives while the user is still seeing older messages.
  • After calling the render function, getSnapshotBeforeUpdate is called before componentDidUpdate.
  • If the getSnapshotBeforeUpdate method returns anything, the componentDidUpdate method will get it as a parameter.

4. The componentDidUpdate Method

  • The final lifecycle method used during the update phase is the componentDidUpdate method.
  • By using it, you can produce unintended consequences like launching network requests or invoking this.setState method.
  • It's critical to keep in mind that if the setState isn't always possible to avoid (via logic, for example), rendering will continue indefinitely.
  • If the getSnapshotBeforeUpdate method is used, this function can accept up to three parameters: prevProps, prevState, and snapshot.

The unmounting phase

The third and last phase of a React component is unmounting. The component is now eliminated from the DOM. There is only one lifecycle method involved in unmounting: 

  1. The componentWillUnmount Method

The componentWillUnmount Method

  • Just before the component is unmounted or deleted from the DOM, componentWillUnmount is called.
  • It is intended for any necessary cleanup of the component, such as canceling network requests or unsubscribing from any subscriptions (such as Redux).
  • The component will be destroyed after this method has completed its operation.


1. What are the three main lifecycle methods in Reactjs?

ComponentDidMount, ComponentDidUpdate, and ComponentWillUnmount are the three primary lifecycle methods in React.

2. Do hooks replace lifecycle methods?

React Lifecycle Hooks offer an alternate approach for managing component states and side effects within functional components; they do not replace lifecycle methods.

3. How many lifecycle Hooks are in React?

In earlier versions of React Lifecycle Hooks 10 hooks were introduced, however many of these are now regarded as a legacy. ComponentDidMount, ComponentDidUpdate, and ComponentWillUnmount are the three primary lifecycle hooks in modern React. Additional hooks like useEffect are also available to address other lifecycle-related activities.


We covered the react lifecycle methods in this comprehensive article. Initialization in react, mounting lifecycle in react, react update lifecycle, & unmounting are the four stages of a component's lifetime that we have learned about. We have looked at the function and application of important lifecycle methods inside each phase, including componentWillMount(), componentDidMount(), render(), shouldComponentUpdate(), & many others. Building reliable and effective applications requires an understanding of the React component lifecycle. You can manage state, handle updates, and enhance performance in your React projects by making the most of component lifecycles.

About Author
Shailendra Chauhan (Microsoft MVP, Founder & CEO at DotNetTricks)

Shailendra Chauhan is the Founder and CEO at ScholarHat by DotNetTricks which is a brand when it comes to e-Learning. He provides training and consultation over an array of technologies like Cloud, .NET, Angular, React, Node, Microservices, Containers and Mobile Apps development. He has been awarded Microsoft MVP 8th time in a row (2016-2023). He has changed many lives with his writings and unique training programs. He has a number of most sought-after books to his name which has helped job aspirants in cracking tough interviews with ease.
Accept cookies & close this