Skip to main content

Lifecycle of react components for beginners

· 3 min read
Parth Maheta

let's discuss the basic React component lifecycle for beginners. The React component lifecycle refers to the series of phases a component goes through, from its birth to its removal from the DOM. In React, components have several lifecycle methods that you can override to perform actions at different stages.

Here are the key phases in the React component lifecycle:

1. Mounting Phase:

  • These methods are called when an instance of a component is being created and inserted into the DOM.

a. constructor():

  • This is the first method called when a component is created.
  • Initialize state and bind methods here.

b. static getDerivedStateFromProps(props, state):

  • This is called before every render.
  • Used to update state based on changes in props.

c. render():

  • This method is required and responsible for rendering the component.

d. componentDidMount():

  • Called after the component is rendered for the first time.
  • Ideal for performing initial setup, data fetching, or interacting with the DOM.

2. Updating Phase:

  • These methods are called when a component is being re-rendered as a result of changes to either its props or state.

a. static getDerivedStateFromProps(props, state):

  • Similar to the mounting phase, used to update state based on changes in props.

b. shouldComponentUpdate(nextProps, nextState):

  • Allows you to control if the component should re-render.
  • Can be used for performance optimization.

c. render():

  • Renders the component.

d. getSnapshotBeforeUpdate(prevProps, prevState):

  • Called before the most recent render to capture some information from the DOM.
  • Used in conjunction with componentDidUpdate for operations like scrolling.

e. componentDidUpdate(prevProps, prevState, snapshot):

  • Called after the component is re-rendered.
  • Ideal for performing side effects, data fetching, or interacting with the DOM.

3. Unmounting Phase:

  • This method is called when a component is being removed from the DOM.

a. componentWillUnmount():

  • Called before the component is removed from the DOM.
  • Used for cleanup, such as cancelling network requests or clearing up subscriptions.

Additional Lifecycle Methods (Advanced):

  • React 16.3 introduced additional lifecycle methods, which are considered safer alternatives to certain methods that might be deprecated in the future.

a. static getDerivedStateFromError(error):

  • Used to render a fallback UI when a child component throws an error.

b. componentDidCatch(error, info):

  • Called after an error has been thrown by a descendant component.


  • Functional Components with Hooks:

    • With the introduction of Hooks in React, functional components can now use lifecycle methods and state using the useState, useEffect, etc., hooks.
  • Lifecycle in Class Components:

    • The lifecycle methods discussed here are specific to class components. Functional components can use the useEffect hook to achieve similar functionality.

Remember, not all components need to implement every lifecycle method. The choice of methods depends on the specific needs of your component. As of React 17, some of the lifecycle methods are considered unsafe, and it's recommended to use alternatives for certain use cases. Always refer to the official React documentation for the latest and most accurate information.