HomeTutorialsTypes of Hooks in React: The Ultimate Guide

Types of Hooks in React: The Ultimate Guide




Welcome to the ultimate guide on types of Hooks in React! If you’re a front-end developer, chances are you’re familiar with React, a popular JavaScript library used for building user interfaces. With the introduction of Hooks, React has undergone significant changes.

Hooks are a new addition to React that allows you to use state and other features without having to write a class. They are functions that allow you to “hook into” React features, such as state and lifecycle methods, inside functional components.

To build efficient and effective applications, it is important to understand the different types of React Hooks. In this guide, we’ll cover the main types of Hooks, how to use them, and their best use cases. So, let’s dive in!

List of React Hooks

State Hooks

State is an essential concept in React as it represents the data that changes over time in your application. In functional components, you can use the useState Hook to add state to your component. The useState Hook provides a pair of values in an array format:

  1. the current state value
  2. a function to update it

Let’s take a look at an example:

import React, { useState } from 'react'

function ColorPicker() {
  const [color, setColor] = useState('red')

  const handleColorChange = (event) => {

  return (
      <p>The selected color is: {color}</p>
        checked={color === 'red'}
      />{' '}
      <br />
        checked={color === 'blue'}
      />{' '}
      <br />
        checked={color === 'green'}
      />{' '}

In this example, we’ve created a ColorPicker component that uses the useState Hook to keep track of a color variable. Initially, the color is set to 'red' using the useState Hook. We then render the current color value to the screen and a set of radio buttons that, when clicked, updates the color value using the setColor function provided by the useState Hook.

Overall, the useState Hook is a powerful tool for working with state in functional components. It allows you to keep track of the state of your application and to update that state when necessary, making it a crucial tool for building dynamic and interactive UIs.

Effect Hooks

In React, you may often need to fetch data from an API endpoint and display it in your components. Effect Hooks in React allow you to do this in a concise and efficient manner.

useEffect is a built-in Hook in React that lets you perform side effects in your functional components. It takes two parameters:

  1. a callback function where you put the code for your side effect
  2. an optional array of dependencies to determine when the effect should run

Here is an example of using the useEffect Hook to fetch data from the API endpoint:

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

function PhotoList() {
  const [photos, setPhotos] = useState([])

  useEffect(() => {
      .then((response) => response.json())
      .then((data) => setPhotos(data))
      .catch((error) => console.error(error))
  }, [])

  return (
      {photos.map((photo) => (
        <div key={photo.id}>
          <img src={photo.thumbnailUrl} alt={photo.title} />

In this example, we’ve created a PhotoList component that uses the useEffect Hook to fetch data from an API endpoint. The useEffect Hook runs once on mount because we passed an empty array of dependencies as the second argument. This means that the fetch function only runs once and sets up a request to fetch the data.

Once the data is fetched, it is set to the state variable photos, which is then used to display the list of photos in the return statement.

Overall, the useEffect Hook is a powerful tool for fetching data from an API endpoint and handling other side effects in React. It allows you to perform these operations in functional components in a concise and readable way.

The useLayoutEffect Hook is similar to useEffect, but it fires synchronously after all DOM mutations are complete in the render phase. This makes it useful for code that requires precise DOM measurements and layout, such as animations or scroll position calculations.

Memoization Hooks

Memoization is a technique that optimizes the performance of a function by caching its results. In React, two Hooks – useMemo and useCallback – are used for memoization.

The useMemo Hook memoizes the result of a function call and returns the cached result if the input arguments of the function do not change. The syntax for useMemo is as follows:

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

Here, the function computeExpensiveValue is called only when the inputs a and b change. Otherwise, the memoized value memoizedValue is returned.

The useCallback Hook is used to memoize a function so that it is not recreated on every render cycle. The syntax for useCallback is as follows:

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

Here, the function memoizedCallback is memoized and will only be recreated when a and b change.

These two Hooks look similar but they are different in purpose. useMemo is used to memoize the result of a function, while useCallback is used to memoize the function itself.

The useMemo and useCallback Hooks are helpful in improving the performance of a React application. They are particularly useful when dealing with expensive computations or rendering components that depend on many props.

Consider the following code snippet:

import React, { useState, useMemo, useCallback } from 'react'

const MyComponent = () => {
  const [value1, setValue1] = useState(0)
  const [value2, setValue2] = useState(0)

  const expensiveFunction = useCallback((param) => {
    console.log('expensiveFunction called with param:', param)
    return param * 2
  }, [])

  const result = useMemo(() => {
    console.log('useMemo called with value1:', value1)
    return expensiveFunction(value1)
  }, [value1, expensiveFunction])

  return (
      <p>Value 1: {value1}</p>
      <button onClick={() => setValue1(value1 + 1)}>Increment Value 1</button>
      <p>Value 2: {value2}</p>
      <button onClick={() => setValue2(value2 + 1)}>Increment Value 2</button>
      <p>Result: {result}</p>

export default MyComponent

In this example, we have a functional component that uses useState to manage two values: value1 and value2. We also define a dummy expensive function expensiveFunction that doubles its input parameter.

We use useCallback to memoize the expensive function so that it only gets redefined if one of its dependencies changes. In this case, we pass an empty array as the dependency list since expensiveFunction doesn’t depend on any external values.

We use useMemo to memoize the result of the expensive function so that it only gets recalculated if one of its dependencies changes. We pass [value1, expensiveFunction] as the dependency list, so the result gets recalculated whenever value1 or the function itself changes.

In the return statement, we display the two values, two buttons to increment the values, and the result of the expensive function. If we click the “Increment Value 1” button, we’ll see that the useMemo hook gets called with the updated value1 and the expensiveFunction only gets called with the new value of value1 since it’s memoized using useCallback. On the other hand, if we click the “Increment Value 2” button, neither useMemo nor useCallback get called since they don’t depend on value2.

Context Hooks

In React, the Context API enables the passing of data down the component tree without the need for manual prop passing at each level. This can be especially useful when you have a deeply nested component tree where passing props can become cumbersome.

useContext is a built-in Hook in React that allows you to consume a Context. It takes a Context object as an argument and returns the current value of the Context. Here is an example of using the useContext Hook to consume a context value:

import React, { useContext } from 'react'
import { UserContext } from './UserContext'

function UserProfile() {
  const user = useContext(UserContext)

  return (

In this example, we’ve created a UserProfile component that uses the useContext Hook to consume the UserContext. The UserContext is an object that contains the current user’s name, email, and bio. By using the useContext Hook, we can easily access the current user object without having to pass it down as a prop from a parent component.

To create a context value, you can use the createContext function from the React library. Here is an example of creating a UserContext:

import React, { createContext } from 'react'

export const UserContext = createContext({})

function App() {
  const user = {
    name: 'Frontend Mag',
    email: 'hello@frontendmag.com',
    bio: 'A software engineer who loves React!',

  return (
    <UserContext.Provider value={user}>
      <UserProfile />

In this example, we’ve created a UserContext using the createContext function from the React library. The UserContext is then provided to the UserProfile component via the UserContext.Provider component. The value prop of the UserContext.Provider component sets the initial value of the UserContext to the user object.

Overall, the Context API and Context Hook provide a powerful way to manage and pass down data in your React application. By using Context Hook, you can easily consume context values within your functional components and avoid the need for passing down props at every level of your component tree.

Reducer Hooks

In React, the useReducer Hook is a powerful tool for managing state that is more complex and requires more control over how state is updated. It provides an alternative to useState and allows you to manage state using a reducer function, similar to how you would use a reducer in Redux.

The useReducer Hook takes two arguments:

  1. a reducer function that is responsible for updating the state based on the action that is dispatched;
  2. and an initial state, which is the initial value of the state.

Here is an example of using the useReducer Hook to manage state in a shopping cart:

import React, { useReducer } from 'react'

function reducer(state, action) {
  switch (action.type) {
    case 'ADD_TO_CART':
      return {
        items: [...state.items, action.payload],
        total: state.total + action.payload.price,
    case 'REMOVE_FROM_CART':
      const newItems = state.items.filter(
        (item) => item.id !== action.payload.id
      return {
        items: newItems,
        total: state.total - action.payload.price,
      return state

function ShoppingCart() {
  const [cartState, dispatch] = useReducer(reducer, {
    items: [],
    total: 0,

  function addToCart(item) {
    dispatch({ type: 'ADD_TO_CART', payload: item })

  function removeFromCart(item) {
    dispatch({ type: 'REMOVE_FROM_CART', payload: item })

  return (
      <h1>Shopping Cart</h1>
        {cartState.items.map((item) => (
          <li key={item.id}>
            {item.name} - ${item.price}
            <button onClick={() => removeFromCart(item)}>Remove</button>
      <p>Total: ${cartState.total}</p>
      <button onClick={() => addToCart({ id: 1, name: 'Item 1', price: 10 })}>
        Add Item

In this example, we’ve created a ShoppingCart component that uses the useReducer Hook to manage state. The reducer function is responsible for updating the state based on the action that is dispatched. In this case, the actions are 'ADD_TO_CART' and 'REMOVE_FROM_CART', which add and remove items from the shopping cart.

The initial state of the shopping cart is an object with two properties: items and total. The items property is an array of items in the cart, and the total property indicates the total cost of all cart’s items.

The ShoppingCart component renders the items in the cart and allows users to add and remove items by calling the addToCart and removeFromCart functions, respectively. When these functions are called, they dispatch an action to the reducer, which updates the state accordingly.

Overall, the useReducer Hook provides a powerful way to manage complex state in your React application. By using a reducer function and dispatching actions, you can easily update state in a predictable and scalable way.

Ref Hooks

Refs are a way to access the actual DOM elements that are created by React and then manipulate them as needed. Refs can be useful for accessing form input fields, triggering animations, or interacting with third-party libraries that require direct access to the DOM.

The useRef Hook is used to establish a reference to an element in the DOM. Unlike the state or props objects, which can trigger re-renders, the ref object does not. Therefore, it is an effective way to modify the DOM without re-rendering the component.

To create a ref, you call the useRef Hook and assign the result to a variable. This variable can then be passed to any element as a ref attribute, allowing you to reference the actual DOM node directly. Here’s a sample usage of the useRef Hook to retrieve an input field:

import { useRef } from 'react'

function MyForm() {
  const inputRef = useRef(null)

  function handleSubmit(e) {

  return (
    <form onSubmit={handleSubmit}>
      <label htmlFor="my-input">Enter your name:</label>
      <input id="my-input" type="text" ref={inputRef} />
      <button type="submit">Submit</button>

In this example, a reference is created using the useRef Hook and it is assigned to the inputRef variable. We then pass this variable to the ref attribute of the input field. After the form is submitted, we can access the value of the input field directly using inputRef.current.value.

Overall, useRef provide a powerful way to interact with the DOM directly from React, allowing you to create dynamic and responsive user interfaces.

Custom Hooks

In addition to the built-in Hooks provided by React, you can also create your own custom Hooks. Creating custom Hooks is a great way to keep your code organized and reusable. By extracting common logic into a custom Hook, you can reuse that logic in multiple components throughout your application.

To create a custom Hook, you simply create a function that uses one or more of the built-in Hooks. Here’s an example of a custom Hook that uses the useState and useEffect Hooks to fetch data from an API:

import { useState, useEffect } from 'react'

function useFetch(url) {
  const [data, setData] = useState(null)
  const [loading, setLoading] = useState(true)
  const [error, setError] = useState(null)

  useEffect(() => {
    async function fetchData() {
      try {
        const response = await fetch(url)
        const json = await response.json()
      } catch (error) {
      } finally {
  }, [url])

  return { data, loading, error }

export default useFetch

This custom Hook, useFetch, takes a URL as a parameter and uses the useState and useEffect Hooks to fetch data from that URL. It returns an object with three properties: data, loading, and error.

To use this custom Hook in a component, you simply import it and call it like any other Hook:

import useFetch from './useFetch'

function PhotoList() {
  const { data, loading, error } = useFetch(

  if (loading) {
    return <p>Loading...</p>

  if (error) {
    return <p>{error.message}</p>

  return (
      {data.map((photo) => (
        <img key={photo.id} src={photo.url} alt={photo.title} />

In this example, we’re using the useFetch custom Hook to fetch data from the API and render a list of photos.

Custom Hooks can be a powerful tool for building reusable logic in your application. When creating custom Hooks, it’s important to follow the same best practices as you would with built-in Hooks, such as keeping the Hook names prefixed with “use” and ensuring that the Hooks are pure functions.

Comparison of Class Components and Hooks

React introduced Hooks as a new way of managing state and lifecycle in functional components. Before Hooks, class components were the only way to manage state and lifecycle in React applications. In this section, we will compare class components and Hooks to understand their differences and similarities.

Firstly, class components have a longer and more verbose syntax compared to functional components with Hooks. Hooks provide a more concise way of managing state and lifecycle, making code more readable and easier to maintain.

Secondly, Hooks allow for better code reuse, as logic can be shared between multiple components using custom Hooks. On the other hand, class components require inheritance or higher-order components for code reuse, which can lead to complex and harder-to-maintain code.

Lastly, Hooks provide a simpler way to manage side effects and asynchronous code. Using the useEffect Hook, you can easily perform side effects like fetching data or updating the DOM without having to deal with complex lifecycle methods like componentDidMount and componentDidUpdate in class components.

In summary, Hooks provide a simpler, more concise, and more reusable way of managing state and lifecycle in React applications. While class components are still valid and widely used, Hooks provide a more modern and efficient way of developing React applications.

Best Practices for Using Hooks

Here are some guidelines to follow when working with Hooks in React:

  • Use Hooks only in functional components: Hooks are designed to work only with functional components and cannot be used in class components. Mixing Hooks and class components can lead to unexpected behavior.
  • Use Hooks at the top level of the component: Hooks must only be used at the top level of a component, not inside loops, conditions, or nested functions. This ensures that Hooks are called in the same order every time the component renders, preventing bugs and inconsistencies.
  • Use Hooks for specific use cases: Each Hook is designed to solve a specific use case, so it’s important to choose the right Hook for the job. For example, useState is used for managing component state, useEffect is used for performing side effects, and useContext is used for managing the global state with context.
  • Use custom Hooks for code reuse: Custom Hooks allow you to reuse logic across multiple components. By creating custom Hooks, you can encapsulate complex logic and share it across multiple components, making code more maintainable and reusable.
  • Use the useCallback and useMemo Hooks for optimization: The useCallback and useMemo Hooks can be used to optimize performance by memoizing functions and values. This prevents unnecessary re-renders and improves performance, especially in larger applications.

By following these best practices, you can use Hooks to build efficient, reusable, and maintainable React applications.

Types of Hooks in React: Conclusion

In conclusion, Hooks are an essential feature in React that provides a cleaner and more concise way of writing functional components. It allows you to reuse logic across multiple components, making code easier to maintain and reducing repetition.

We have covered the different types of Hooks, including State, Effect, Context, Reducer, Memoization, and Ref Hooks, as well as the best practices for using them in our code. We also discussed Custom Hooks and how they can be used to create reusable code.

It’s important to remember that Hooks aren’t intended to replace class components. Instead, they are designed to be an additional feature that enhances the capabilities of functional components. When using Hooks, you should follow best practices to avoid common issues and ensure the code is clean and maintainable.

By understanding and using Hooks correctly, you can write more efficient, reusable, and scalable code in React.

Consider checking out a blog post that compares the differences between useCallback vs useEffect if you’re interested in learning more about them. Thanks for reading!


  1. Can Hooks be used in class components?

No, Hooks are designed to work only with functional components and cannot be used in class components.

  1. When should I use custom Hooks?

Custom Hooks should be used when you need to reuse logic across multiple components. By encapsulating complex logic in custom Hooks, you can make your code more maintainable and reusable.

  1. How do I choose the right Hook for my use case?

Each Hook is designed to solve a specific use case, so it’s important to choose the right Hook for the right job. The following table summarizes key use cases for common React Hooks:

Hook Name Use Case
useState To manage state in functional components
useEffect To manage side effects and lifecycle in functional components
useContext To consume and update context in functional components
useReducer To manage complex state transitions in functional components
useMemo To memoize expensive computations in functional components
useCallback To memoize function references in functional components
useRef To access and manipulate DOM nodes or values in functional components
useImperativeHandle To expose functions to parent components from child components
useLayoutEffect To perform side effects after the DOM has been updated
  1. How can I optimize performance when using Hooks?

The useCallback and useMemo Hooks can be used to optimize performance by memoizing functions and values. This prevents unnecessary re-renders and improves performance, especially in larger applications.

  1. Can Hooks be used with Redux?

Yes, Hooks can be used with Redux to manage state and perform side effects. The react-redux library provides several Hooks that can be used for this purpose, including useSelector, useDispatch, and useStore.

  1. Are Hooks a replacement for HOCs (Higher Order Components) and Render Props?

Hooks are not a replacement for HOCs and Render Props, but rather an alternative way of achieving the same functionality. Hooks provide a simpler and more intuitive way of managing state and lifecycle in React components, while HOCs and Render Props provide more flexibility and customization options.


Please enter your comment!
Please enter your name here

Recent posts