🔧 React Js Part 5 : Lifecycle Methods and Hooks in React

React is a JavaScript library that allows us to build user interfaces declaratively. One of the key concepts in React is how we manage the lifecycle of components. In this article, we will discuss two main aspects: lifecycle methods in class components and Hooks.

1. Lifecycle Methods in Class Components

Lifecycle methods are special methods that are called at different stages of a component's lifecycle. Here are some of the most common lifecycle methods and their purposes:

a. Mounting

• constructor(props): The first method called. Typically used for initializing state and binding methods.

constructor(props) {
  super(props);
  this.state = { count: 0 };
}

• componentDidMount(): Called after the component is first mounted to the DOM. Ideal for data fetching or initializing subscriptions.

componentDidMount() {
  this.fetchData();
}

b. Updating

componentDidUpdate(prevProps, prevState): Called after the component updates. Useful for responding to changes in props or state. Make sure to check for changes to avoid infinite loops.

componentDidUpdate(prevProps) {
  if (this.props.id !== prevProps.id) {
    this.fetchData();
  }
}

c. Unmounting

componentWillUnmount(): Called right before the component is removed from the DOM. Useful for cleaning up subscriptions, timers, or other operations that need cleanup.

componentWillUnmount() {
  this.cleanup();
}

d. Error Handling

componentDidCatch(error, info): Used to catch errors in child components. Useful for centralized error handling.

componentDidCatch(error, info) {
  logErrorToMyService(error, info);
}

2. Introduction to React Hooks

React Hooks are a feature that allows us to use state and lifecycle methods without writing class components. Here are some of the most commonly used Hooks:

a. useState()

Used to add state to functional components. This function returns a pair: the current state and a function to update it.

import React, { useState } from 'react';

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

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increment</button>
    </div>
  );
};

b. useEffect()

useEffect allows us to run side effects in functional components. It combines the functionalities of componentDidMount, componentDidUpdate, and componentWillUnmount.

• Example 1: useEffect with an Empty Array ([]) When useEffect is used with an empty array as a dependency, the effect runs only once after the component mounts.

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

const FetchDataOnce = () => {
  const [data, setData] = useState([]);

  useEffect(() => {
    const fetchData = async () => {
      const response = await fetch('https://api.example.com/data');
      const result = await response.json();
      setData(result);
    };

    fetchData();
  }, []); // Effect runs only once when the component mounts

  return (
    <ul>
      {data.map(item => (
        <li key={item.id}>{item.name}</li>
      ))}
    </ul>
  );
};

• Example 2: useEffect Without Dependency Array When useEffect is provided without a dependency array, the effect runs every time the component re-renders.

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

const CountComponent = () => {
  const [count, setCount] = useState(0);

  useEffect(() => {
    console.log(`Count updated: ${count}`);

    const fetchData = async () => {
      const response = await fetch(`https://api.example.com/data/${count}`);
      const result = await response.json();
      console.log(result);
    };

    fetchData();
  }); // Effect runs every time the component renders

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increment</button>
    </div>
  );
};

• Example 3: useEffect with an Array of Dependencies When you provide an array of dependencies, the effect runs whenever one of the values in the array changes.

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

const DependOnCount = () => {
  const [count, setCount] = useState(0);
  const [data, setData] = useState([]);

  useEffect(() => {
    const fetchData = async () => {
      const response = await fetch(`https://api.example.com/data/${count}`);
      const result = await response.json();
      setData(result);
    };

    fetchData();
  }, [count]); // Effect runs every time `count` changes

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increment</button>
      <ul>
        {data.map(item => (
          <li key={item.id}>{item.name}</li>
        ))}
      </ul>
    </div>
  );
};

c. useContext()

The useContext Hook is used to access context in functional components. This is especially useful for sharing global data, such as themes or user authentication status, without prop drilling.

Example: Theming with useContext
In this example, we'll create a simple theme context that allows us to toggle between light and dark themes.

1. Create the Theme Context
First, we create a context for the theme.

import React, { createContext, useContext, useState } from 'react';

// Create a Theme Context
const ThemeContext = createContext();

const ThemeProvider = ({ children }) => {
  const [theme, setTheme] = useState('light');

  const toggleTheme = () => {
    setTheme((prevTheme) => (prevTheme === 'light' ? 'dark' : 'light'));
  };

  return (
    <ThemeContext.Provider value={{ theme, toggleTheme }}>
      {children}
    </ThemeContext.Provider>
  );
};

2. Consume the Theme Context
Next, we can create a component that consumes the theme context to apply styles and provide a button to toggle the theme.

const ThemedComponent = () => {
  const { theme, toggleTheme } = useContext(ThemeContext);

  return (
    <div className={`theme-${theme}`}>
      <h1>{theme === 'light' ? 'Light Theme' : 'Dark Theme'}</h1>
      <button onClick={toggleTheme}>
        Switch to {theme === 'light' ? 'Dark' : 'Light'} Theme
      </button>
    </div>
  );
};

3. Wrap the Application with the Theme Provider
Finally, we wrap our application (or part of it) with the ThemeProvider to provide the theme context to its children.

const App = () => {
  return (
    <ThemeProvider>
      <ThemedComponent />
      {/* Other components can also access the ThemeContext here */}
    </ThemeProvider>
  );
};

export default App;

Explanation

• Theme Context Creation: We create a ThemeContext using createContext and a ThemeProvider component that manages the current theme state and provides a function to toggle it.

• Context Consumption: In the ThemedComponent, we use useContext(ThemeContext) to access the current theme and the toggle function. This component renders different content based on the current theme and includes a button to toggle it.

• Application Structure: The entire application (or part of it) is wrapped in the ThemeProvider, allowing any child component to access the theme context.

d. useMemo() and useCallback()

• useMemo(): Caches the result of expensive calculations to avoid re-calculating on every render.

const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);

• useCallback(): Caches functions to avoid re-creating them on every render.

const memoizedCallback = useCallback(() => {
  doSomething(a, b);
}, [a, b]);

3. Advantages of Using Hooks

Hooks provide flexibility and the ability to share logic between components without having to use Higher Order Components (HOCs) or render props. Some advantages of using Hooks include:

• Simplicity and clarity: Code becomes cleaner and easier to read.
• Flexibility: Logic can be divided into smaller functions that can be reused anywhere.
• Reduced complexity: Avoids the use of classes and complicated lifecycle methods.

Lifecycle methods and Hooks are two important aspects of React development. Understanding how both concepts work allows us to create more efficient and maintainable components. Hooks, in particular, open up new possibilities for developing functional components, changing the way we interact with state and side effects.

By mastering lifecycle methods and Hooks, you will be able to build more robust and responsive React applications. Happy coding!