Creating Custom Hooks with React: Mastering Reusable Functionality

Are you tired of repeating the same code across multiple React components? Do you find yourself facing a common functionality pattern repeatedly? Don't worry! In this guide, you're going to take your web development skills to the next level by creating custom hooks in React, maximizing the reusability of your code, and saving yourself a lot of time and energy in the process.

What are React Custom Hooks?

React hooks are used to extend functionality by allowing function components to have state and lifecycle methods. Custom hooks, as the name suggests, are hooks that you define yourself. Custom hooks can be made to encapsulate common logic that can be reused across components, or they can be used to encapsulate complex logic that could clutter components. Custom hooks allow you to cleanly separate concerns, and they're an excellent way of making your code more reusable.

Let's Create our First Custom Hook

Let's get started with the basics of creating custom hooks. To start, we'll create a simple hook that sets up state and returns the current value and a function to update the value. Here's the code:

  import React, { useState } from 'react';
  function useCustomHook(initialState) {
    const [state, setState] = useState(initialState);
    function updateState(newState) {
    return [state, updateState];

As you can see, we've created a function called 'useCustomHook' that takes an 'initialState' parameter. We then use the 'useState' hook to create state and initialize it with the provided 'initialState' value. This custom hook returns an array with two elements: the first element is the current state and the second is the 'updateState' function, which you can use to update the state.

Now, let's see how we can use this custom hook in our function components. First, let's import and use the 'useCustomHook' in our component:

  import React from 'react';
  import useCustomHook from 'path/to/useCustomHook';
  function MyComponent() {
    const [count, setCount] = useCustomHook(0);
    return (
        <p>Count: {count}</p>
        <button onClick={() => setCount(count + 1)}>Increment</button>

As you can see, we were able to use the 'useCustomHook' function inside our component to encapsulate the 'useState' hook and provide an interface for updating the state. This is a simple example, but you can see how powerful the custom hook is in keeping our code clean and organized.

Creating a Custom Hook with Side Effects

Now that we've built a basic custom hook, let's take it to the next level by adding a side effect. In this example, we'll create a hook that fetches data from an API and updates the component's state when the data is received.

  import { useState, useEffect } from 'react';
  function useAPI(endpoint) {
    const [data, setData] = useState(null);
    useEffect(() => {
    }, []);
    async function fetchData() {
      const response = await fetch(`${endpoint}`);
      const data = await response.json();
    return data;

Here, we've defined a custom hook called 'useAPI' that takes an 'endpoint' parameter. The hook uses the 'useState' hook to create state and set it to null initially. We then use the 'useEffect' hook to tell React to fetch data when the component mounts. Once the data is fetched, we update the state.

Let's see how we can use our new custom hook in a component:

  import React from 'react';
  import useAPI from 'path/to/useAPI';
  function MyComponent() {
    const data = useAPI('my-data-endpoint');
    return (
        <p>Data: {JSON.stringify(data)}</p>

As you can see, our component has access to the data returned by the 'useAPI' hook. This is just an example, and you can see that it's quite easy to add any kind of side effect to your custom hooks. Perhaps you want to add a non-essential animation or progress bar in your view updates on external APIs, authentications, or anything that could be thought of.

Tips for Creating Great Custom Hooks

Here are a few tips for creating great custom hooks:

  • Make sure to name your custom hooks with a 'use' prefix, to follow the React convention for hooks.
  • Keep your hooks small. If the hook is doing too many different things, it will become harder to understand and use.
  • Think about the functionality you need and if you can encapsulate it. If you're repeating yourself in multiple components, there's probably a good use case for a custom hook.
  • Use the React's useContext hook for global state management situations, such as authentication status, theme data, and more.
  • Add detailed documentation to your custom hooks commenting and even write examples for use. This is important because it makes it easier for others- and yourself- to use will understanding the function and how it works!


Creating custom hooks in React is a great way to make your code more reusable and keep things organized. The examples in this guide are just the tip of the iceberg, and you can extend custom hooks to fit any aspect and need of your project. So, the next time you find yourself repeating code across multiple components or writing complex logic, consider encapsulating your code into a custom hook using these steps!