Custom Hooks for Reusability and Code Organization in ReactJS

ReactJS is a powerful JavaScript library for building user interfaces. Its component-based architecture allows developers to create reusable and modular code. However, as projects grow in size and complexity, it becomes crucial to efficiently manage and organize the codebase. This is where custom hooks come into play.

What are Custom Hooks?

Custom hooks are JavaScript functions that extract and reuse stateful logic from components. They enhance reusability and enable developers to share common functionalities across multiple components. By encapsulating complex logic into custom hooks, code organization becomes much simpler, leading to cleaner and more maintainable code.

Benefits of Custom Hooks


One of the key advantages of custom hooks is reusability. With custom hooks, you can extract commonly used code and package it in a single function. This means that you can reuse the same logic across different components without duplicating code. This not only improves code maintainability but also makes it easier to manage changes and updates.

Code Organization

Custom hooks help in organizing the codebase. When the logic is extracted into a separate custom hook, the component code becomes cleaner and more focused. This improves code readability and makes it easier for other developers to understand and work with the code. By using custom hooks, developers can better separate concerns and keep their components more concise and manageable.


Another advantage of custom hooks is improved testability. By encapsulating stateful logic in custom hooks, it becomes easier to write unit tests for that logic. Since custom hooks are functions, they can be easily tested in isolation without the need to render or mount the entire component. This enables more effective testing and ensures the reliability of the codebase.

Examples of Custom Hooks

To better understand the concept of custom hooks, let's look at a couple of examples.


import { useState, useEffect } from 'react';

const useLocalStorage = (key, initialValue) => {
  const [value, setValue] = useState(() => {
    const storedValue = localStorage.getItem(key);
    return storedValue !== null ? JSON.parse(storedValue) : initialValue;

  useEffect(() => {
    localStorage.setItem(key, JSON.stringify(value));
  }, [key, value]);

  return [value, setValue];

export default useLocalStorage;

The useLocalStorage hook encapsulates the logic for storing and retrieving data from the browser's local storage. It initializes the state with the stored value (if any) or the provided initial value. Whenever the value changes, it updates the local storage accordingly. This custom hook can now be used across components that require local storage functionality.


import { useState, useEffect } from 'react';

const useDarkMode = () => {
  const [isDarkMode, setIsDarkMode] = useState(false);

  useEffect(() => {
    const body = document.body;
    isDarkMode ? body.classList.add('dark') : body.classList.remove('dark');
  }, [isDarkMode]);

  return [isDarkMode, setIsDarkMode];

export default useDarkMode;

The useDarkMode hook manages the state for enabling or disabling dark mode. Whenever the isDarkMode value changes, it updates the classList of the body element, adding or removing the 'dark' class accordingly. Components that need dark mode functionality can simply use this custom hook, making the codebase more modular.


Custom hooks are a powerful tool for enhancing reusability and code organization in ReactJS projects. By encapsulating complex logic into reusable functions, developers can create clean and maintainable code. Custom hooks promote reusability, code organization, and testability. By utilizing custom hooks efficiently, developers can significantly improve their development workflow and build more scalable applications.

noob to master © copyleft