Hooks are functions that allow the user to “hook into” React state and development features from function f (x) components. It is the new feature introduced in version 16.8. It allows users to use state and other features without forming a new class. They are backward-compatible; thus it does not encompass any breaking changes. Also, Hook does not compromise the knowledge of React concepts.

Table of Contents:

  1. Hooks
  2. States of Hook
  3. Hooks Effect
  4. Side Effects
  5. Timing of Effect
  6. Rules to use Hooks

How to Work with React Hook API

When Should a Programmer use Hook?

If the user is writing a new function component and then wants to add a state to it, the earlier user used to change it to a class. However, now it could be performed using a Hook inside the already existing function module.

Hooks encompasses many similarities to JavaScript functions, but there are some limitations when using them. Hook’s rule confirms that all the stateful logic in a module or a component is evident in the source code.

States of Hook


When the user needs to add a local state to a function component, it may use useState. The benefit is that the state would be maintained during the re-rendering process.

useState returns a pair of values: the current state and a function to update your part. Similarly, calling role functions. setState changes the state’s values, but it does not combine the old and new states.


useEffect is an Effect Hook that enables a feature variable to perform side effects. useEffect serves the same function as Lifecycle methods in the component class, such as componentDidMount (), componentDidUpdate (), and componentWillUnMount ().

Users may also decide when to re-render. Below is an example where users have passed a count array after the useEffect.

useEffect(() => {
  document.title = `You clicked ${count} times`;
}, [count]); // Only re-run the effect if count changes`

Consider the case where the count value is 60 and the component re-renders with the same count value, i.e., 60. React can compare the previous render value and determine whether or not to call impact. Only the effect is called if the values are different. That’s a great way to boost productivity while avoiding unwanted phone calls.

React can re-run the effect if there are several items in the list, even if only one of them is different.

UseLayoutEffect vs useEffect

After layout and paint, after the render has been committed to the computer — the feature passed to useEffect flames. Most side effects do not prevent the browser from updating the screen, so this is good. However, there are certain situations where the action provided by useEffect is undesirable; for example, if the user has to make a visual adjustment to the DOM as a side effect, useEffect is not the best option.

Users may use the useLayoutEffect to prevent the user from seeing flickers of changes before the browser updates the screen. Now, the passed function changes to useLayoutEffect.

Hooks Effect

Users may use the Impact Hook to perform side effects (actions) in the function components. It does not allow the use of the component lifecycle methods available in the component class. To put it another way, Effects Hooks are the lifecycle methods componentDidMount(), componentDidUpdate(), and componentWillUnmount().

Side effects are standard features that most web applications must have, such as:

  • DOM Updating.
  • Data Fetching and Consuming from a Server API.
  • Subscription Setup.

Below is an example of the Hook Effect.

import React, { useState, useEffect } from 'react';  
function CounterExample() {  
  const [count, setCount] = useState(0);  
  // Similar to componentDidMount and componentDidUpdate:  
  useEffect(() => {  
    // Update the document title using the browser API  
    document.title = `You clicked ${count} times`;  

  return (  

Side Effects

There are 2 Types of Side Effects.

Effects with Cleanup.

Effects without Cleanup.

Effects with Cleanup

It helps the browser to refresh the screen without blocking it. It improves the app’s responsiveness. Manual DOM mutations, Network requests, Logging, and other results that don’t need cleanup are the most common examples.

Effects without Cleanup

Following DOM changes, specific results need cleanup. When a user wants to purchase a subscription to an external data source, it’s essential to clean up memory so that the user doesn’t cause a memory leak.

When the part is unmounted, React cleans up the memory. Effects, on the other hand, run for each render form, not just once. Consequently, before re-running the effects, React cleans up the effects from the previous render.

Timing of Effect

During a deferred occurrence, the feature passed to useEffect fires after layout and paint. Since most work types shouldn’t prevent the browser from updating the screen, it’s ideal for several widespread side effects, including setting up subscriptions and event handlers.

Not all consequences, however, can be delayed. A noticeable DOM mutation must fire synchronously before the next paint for the user to not detect a visual inconsistency.

React includes an extra Hook called useLayoutEffect for these types of effects. It has the same signature as useEffect but fires at a different time.

Although useEffect does not respond until after the browser has painted, it fires before any new renders.

Rules to use Hooks

Conditions, loops, and nested functions are not allowed to use hooks. Hooks must be used at the top of a React feature. Every time a component renders, this rule ensures that Hooks calls are in the same order.

Hooks cannot be generated from regular JavaScript functions. Instead, the user may call Hooks from React function components. It can also be called custom Hooks.

Make no effort to convert old code written in class components to Hooks. However, in the current implementation, it is suggested that users should consider using Hooks.

The two new terms you should be familiar with to master Hooks are useState and useEffect.

As a result, React Hooks may help make API calls. Users may need to convert a functional component to a class component because they cannot handle the state within the functional component.