HomeBlogWeb DevelopmentIntroduction to Hooks in React

Introduction to Hooks in React

05th Sep, 2023
view count loader
Read it in
12 Mins
In this article
    Introduction to Hooks in React

    Technological change is rapidly impacting our present and our prospects for the future, and so are frontend frameworks, which are emerging at a very fast pace these days. And in many ways, React, the most popular framework amongst the JavaScript community, is turning out to be unstoppable.   

    Many of us have already played around with Hooks or have at least heard about them. But there are still many who are probably yet to take the time or have had the chance to experiment with them.  No worries, sooner or later you will find yourself diving into Hooks.  

    In this article, you will learn about the term, Hooks, and the reasons why you should use them in your future projects. Furthermore, you will learn about how you can use React Hooks in the best possible manner to build some awesome features in your projects and write cleaner code.  

    Hooks in React

    What exactly is a Hook? 

    Hooks are just regular JavaScript functions. In layman terms, hooks provide a way to use functionalities such as context or state, which could earlier only be achieved through classes, and now can easily be done using function components. 

    React Hooks enable functional components to attach local state with it, and this state will be preserved by React when the component re-renders. Hence, this allows React to be used without classes. 

    While working with function components in React, we sometimes need to add state to it. In order to achieve that (to use setState() and states), we have to convert our function component into class one. With the help of Hooks, we can use the state in Function Components, without the use of classes. 

    A practical view 

    There are two approaches to create a React component. One is using functions and the other is using classes. There is always a question in mind that “When do I use one v/s the other?” 

    Let us assume we have a simple class component and then we will convert it to a functional one with hooks and see the difference. 

    Component without Hook: Class Component

    import React, { Component } from'react'; 
    classGreetingextendsComponent { 
       state = { 
           text: ''” 
    handleChange= (e) => { 
    this.setState({ text: e.target.value }) 
    render() { 
    return ( 

    Components with Hook:Functional Component: 

    import React, { useState } from'react'; 
    exportdefault () => { 
    const [text, setText] =useState(''); 
    return ( 
    onChange={(e) =>{ setText(e.target.value) }} 


    • Readable 
    • Lesser Code. 
    • Overall Optimized component 
    • Writing a Functional component with state 
    • Writing complex components became easier 
    • Handling events & logics in functional components. 
    • Performance boost up with Functional Components  

    If you disagree with any of the above, you can play with it in practice. I’m sure that would change your mind! 

    Types of Hooks 

    Now, let us understand the power of hooks with some cool examples that will describe some basic Hooks which are: 

    • useState() 
    • useEffect() 
    • Custom Hooks (Building Your Own Hooks) 

    State Hook 

    In React, we all are quite familiar with how the state is generally defined. If not, I’d recommend you to refresh your memory of State here. 

    this.state= { 
       name: Steve Marley 

    While state issimilar to props, we know that state is controlled by a component. Traditionally, state is generally defined by writing a class where “this.state” is used to initialize a class. 

    Let us take an example of class Component named (MyComponent): 

    classMyComponentextendsReact.component { 
    this.state= { 
           name: Steve Marley 

    In class components, it isreally hard to reuse stateful logic between components and complex class components become hard to read and even harder to understand!! 

    React hooks help us to get rid of all that old-fashioned class stuff by making use of useState().  

    Now, this is important to note that in a functional component there is no concept of objects and objects being set as context (like we do in classes), so we can’t assign anything or read this.state. Instead, we call the useState Hook directly inside our functional component: 

    This will become something like this: 

    import{ useState } from'react'; // line 1 
    functionMyComponent() { 
    const [name, setName] =useState(‘Steve Marley');   // line 2 

    Let us understand this code line by line: 

    In line1: there is a new method imported here called useState. 

    What is useState and how do we use it? 

    Well, useState is the React Hook that will allow us to access and manipulate state in our existing component. Therefore, in this approach, we do not have to extend our Component as we did in previous code. 

    And that’s it! It is worth noting that we are playing with states outside a class in the component directly as shown: 

    import{ useState } from'react';
    function MyComponent() { 
    const [name, setName] =useState("Steve Marley"); 
    return (<div> 
           <p>Heyyyyy!! {name}</p> 

    Deeper explanation 

    In class Component, we initialized the name state to 'Steve Marley' by setting this.state to { name: Steve Marley } in the constructor whereas in Functional componentthe only argument to the useState() Hook is the initial state.  

    Unlike with classes, the state does not have to be an object. We can keep a number or a string if that is all we need. 

    What does useState return?

    It returns two variables in the array [name, setName]  

    where “name” is the state variable and it could be anything, and setName is the function call (can be named anything), which updates the state by providing a new state. 

    If you are not familiar with the above syntax, please read array destructuring in JavaScript. 

    In our example we have declared a state variable called name and set it to Steve Marley. React will remember its current value between re-renders and provide the most recent one to our function. If we want to update the current name, we can call setName. 

    This is a way to “preserve” some values between the function calls so in other words useState is a new way to use the exact same capabilities that this.state provides in a class. Normally, variables “disappear” when the function exits but state variables are preserved by React. 

    It is worth noticing that now our component (functional component) looks pretty simple, crisp and it does not have the level of complexity that a class component normally has. 

    Effect Hook 

    So far, we have seen extracting stateful logic with the help of hooks and defining/setting states inside a component. But what about managing the DOM from one component to another? Or fetching the data through an API? Or handling Events? All these operations which are quite familiar to usare effects!  

    The Effect Hook adds the ability to perform side effects from a functional component. It is a lifecycle Hook that combinescomponentDidMount, componentDidUpdate, and componentWillUnmount in React classes but unified them into a single API. 

    useEffect(() => { 
    // Do some task here 

    By calling this hook, we are simply telling our component to perform some tasks after render like Data fetching, setting up a subscription, and manually changing the DOM in our React components. 

    Let us understand this with an example: 

    import React, { useState, useEffect } from"react";
    exportdefaultfunctionGetData() { 
    const [myData, setData] =useState([]); 
    useEffect(() => { 

    Bala Krishna Ragala

    Blog Author

    Bala Krishna Ragala, Head of Engineering at upGrad, is a seasoned writer and captivating storyteller. With a background in EdTech, E-commerce, and LXP, he excels in building B2C and B2B products at scale. With over 15 years of experience in the industry, Bala has held key roles as CTO/Co-Founder at O2Labs and Head of Business (Web Technologies) at Zeolearn LLC. His passion for learning, sharing, and teaching is evident through his extensive training and mentoring endeavors, where he has delivered over 80 online and 50+ onsite trainings. Bala's strengths as a trainer lie in his extensive knowledge of software applications, excellent communication skills, and engaging presentation style.

    Share This Article
    Ready to Master the Skills that Drive Your Career?

    Avail your free 1:1 mentorship session.

    Your Message (Optional)

    Upcoming Web Development Batches & Dates

    NameDateFeeKnow more
    Course advisor icon
    Course Advisor
    Whatsapp/Chat icon