What is State in React?

State in React refers to an object that holds data that influences the behavior of a component. The state object can be altered over time, primarily in response to user actions, and triggers a re-render of the component. In essence, state allows components to create and manage their own data, making it one of the key concepts to grasp when developing with React.

Rendering Data in the UI using ReactDOM

React manipulates the Document Object Model (DOM) to render data on the screen. The ReactDOM.render method is used to achieve this. It accepts an HTML element, JSX, or a component that returns JSX as its first argument, and a container element in which to render the output as its second argument.

import React from "react";
import ReactDOM from "react-dom";

const rootElement = document.getElementById("root");

ReactDOM.render(<h1>Welcome to React!</h1>, rootElement);

Multiple elements can be rendered by wrapping them inside a parent element like a <div> or <React.Fragment>.

Introduction to State in Class Components

In class-based components, state is initialized in the constructor method and is then manipulated using the setState method. The state object is private and fully controlled by the component, making it ideal for storing data that may change over time and affect the component’s output.

class Counter extends React.Component {
  constructor(props) {
    this.state = { counter: 0 };
    this.handleClick = this.handleClick.bind(this);

  handleClick() {
    this.setState((prevState) => {
      return { counter: prevState.counter + 1 };

  render() {
    return (
        <button onClick={this.handleClick}>Increment counter</button>
        <p>Counter value is {this.state.counter}</p>

The state object is updated using the setState() method, which accepts an object or a function as its argument and schedules an update to the component’s state. The setState() call is asynchronous, meaning that the state update does not happen immediately.

State in Functional Components

Functional components in React are also capable of maintaining their own state using the useState hook. The useState hook is a function that accepts the initial state as its argument and returns an array with two elements: the current state and a function to update it.

import React, { useState } from "react";

function Counter() {
  const [counter, setCounter] = useState(0);

  const handleClick = () => {
    setCounter(counter + 1);

  return (
      <button onClick={handleClick}>Increment counter</button>
      <p>Counter value is {counter}</p>

The useState hook simplifies the process of managing state in functional components, making them a popular choice over class components.

State Updates May Be Asynchronous

Given that the setState function is asynchronous, direct state modifications are discouraged in React. Instead, the setState function or the useState hook should be used for state updates. When the state depends on the previous state, the updater function form of setState should be used. This guarantees that the state update will be applied correctly even if multiple setState calls are batched together.

Using State Correctly

While the ability to change state is powerful, it should be used correctly to prevent bugs and inconsistencies. Here are some key points to remember:

  • Do Not Modify State Directly: React’s state is meant to be immutable. Modifying it directly can lead to unpredictable results.
  • State Updates May Be Asynchronous: React may batch multiple setState() calls into a single update for performance.
  • State Updates are Merged: When setState() is called, React merges the object provided into the current state.

The Data Flows Down

In React, data flows down from parent components to child components through props. This means that a parent component can pass its state down to its child components as props. However, these child components cannot modify the props they receive.

function FormattedDate(props) {
  return <h2>It is {props.date.toLocaleTimeString()}.</h2>;

In this example, the FormattedDate component receives the date as a prop and doesn’t know whether it came from the parent’s state, props, or was typed by hand.

State and Lifecycle in React Components

In React, state and lifecycle methods work hand in hand. Lifecycle methods are special methods provided by React that allow us to run code at specific points in a component’s lifecycle. They are primarily used for initializing state, making API calls, and cleaning up before the component is unmounted from the DOM.

The most commonly used lifecycle methods in class-based components are componentDidMount, componentDidUpdate, and componentWillUnmount.

Converting a Function to a Class

To use state or lifecycle methods in a component, it must be a class component. However, if you have a function component and you want to add state to it, you can convert it to a class component. The process is straightforward and involves creating an ES6 class that extends React.Component and adding a render method to it.


State is a fundamental concept in React, allowing components to maintain and update their own data. It provides the ability to create dynamic and interactive user interfaces. Understanding how state works, how to use it correctly, and the difference between state in class-based and functional components is key to becoming a proficient React developer. To see our other blog posts, visit our website’s blog section.

Call Now Button