What are Hooks in React?

React is a popular JavaScript library used for building user interfaces. It provides a way to create reusable UI components that can be composed together to build complex applications. In React 16.8, a new feature called Hooks was introduced. Hooks allow developers to use state and other React features without writing a class. In this article, we will explore what Hooks are, how they work, and how they can be used in React applications.

Understanding Hooks

Hooks are functions that let you "hook into" React state and lifecycle features from functional components. Previously, in order to use state or lifecycle methods in a component, you had to write a class-based component. With Hooks, you can now use these features directly in functional components, making them more powerful and easier to understand.

Why use Hooks?

Hooks provide several benefits over class-based components. Firstly, they allow you to reuse stateful logic between components without the need for higher-order components or render props. This makes code more modular and easier to maintain. Secondly, Hooks make it easier to understand and test individual components, as they separate concerns and reduce the complexity of class-based components. Lastly, Hooks encourage the use of functional programming principles, which can lead to cleaner and more concise code.

Basic Hooks

React provides several built-in Hooks that cover common use cases. Let's take a look at some of the basic Hooks:


The useState Hook allows you to add state to functional components. It takes an initial value as a parameter and returns an array with two elements: the current state value and a function to update the state. Here's an example:

import React, { useState } from "react";

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

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

In this example, we initialize the state count to 0 using the useState Hook. We then render the current value of count and a button that increments it when clicked.


The useEffect Hook allows you to perform side effects in functional components. It takes a function as a parameter, which will be executed after every render. This can be useful for fetching data, subscribing to events, or updating the DOM. Here's an example:

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

function Timer() {
  const [time, setTime] = useState(0);

  useEffect(() => {
    const interval = setInterval(() => {
      setTime(time + 1);
    }, 1000);

    return () => {
  }, [time]);

  return <p>Time: {time}</p>;

In this example, we use the useEffect Hook to start a timer that updates the time state every second. We also clean up the timer by returning a function from the effect, which is called when the component is unmounted or when the time state changes.

Custom Hooks

Apart from the basic Hooks provided by React, you can also create your own custom Hooks. Custom Hooks are functions that use other Hooks internally and allow you to reuse logic across different components. Here's an example of a custom Hook:

import { useState, useEffect } from "react";

function useFetch(url) {
  const [data, setData] = useState(null);

  useEffect(() => {
    const fetchData = async () => {
      const response = await fetch(url);
      const result = await response.json();

  }, [url]);

  return data;

In this example, we create a custom Hook called useFetch that fetches data from a given URL. It uses the useState and useEffect Hooks internally to manage the state and perform the fetch operation. This custom Hook can now be used in any component to fetch data from a URL.


Hooks are a powerful addition to React that allow you to use state and other React features in functional components. They provide a more intuitive and concise way to write components, making them easier to understand and maintain. By using Hooks, you can create reusable logic and separate concerns, leading to cleaner and more modular code. So, if you're starting with React or looking to improve your existing codebase, give Hooks a try and experience the benefits they bring to your development workflow.