Why do you need to use setState instead of directly modifying the state?

Why do you need to use setState instead of directly modifying the state?

State management is an indispensable aspect of any modern web application, especially when it comes to the popular JavaScript library, React.js. By efficiently managing state, React ensures that user interfaces remain responsive and consistent. This article delves into the intricacies of state management in React, elucidating why direct modification is discouraged and setState is the way to go.


React has been the go-to choice for many developers primarily because of its component-driven architecture. In this model, web pages are broken down into reusable, self-contained pieces called components. Each component has its own job, and most importantly, its own data layer: the state.

Basic Understanding of State

In React, the state is a component’s private data. Just as props might be considered the public interface of a component—receiving data from outside—state is its internal data, only controlled and modified by the component itself. This state determines how a component renders and behaves.

Why is state so pivotal in React? Well, every time the state changes, React re-renders the component. The ability to re-render only when necessary ensures that the UI is always up-to-date with the underlying data, making for dynamic and responsive user interfaces.

Direct Mutation vs. Using setState

To drive the point home, let’s look at a simple example:

// Direct mutation
this.state.counter = this.state.counter + 1;

// Using setState
this.setState({ counter: this.state.counter + 1 });

While the direct mutation might seem harmless, and even shorter, there’s a significant problem: React will not recognize direct mutations of state. As a result, it won’t trigger a re-render, leaving your UI out of sync with the data.

The Immutable Nature of State

Immutability, in programming, means that once an object is created, it cannot be changed. If you want to make a “change”, you create a new version of it. This principle is vital in React, particularly with state.

But why is immutability so favored?

  1. Predictability: Since data is not changed directly, there’s less room for unexpected side effects.
  2. Debugging: With every state change producing a new state object, it becomes easier to track changes, use time-travel debugging, and more.
  3. Performance Optimizations: React can easily detect changes by simply checking if the old and the new state references are different.

By directly mutating the state, we defy this principle of immutability, leading to unpredictability and potential bugs.

Understanding setState’s Asynchronous Nature

Many newcomers to React are surprised when they find out that setState doesn’t immediately update the state. Instead, React batches these calls and handles them in a way that optimizes performance and ensures consistency.

Here’s a practical example to demonstrate this:

this.setState({ counter: this.state.counter + 1 });
console.log(this.state.counter); // Might not reflect the updated value

The above code might not log the incremented counter, because the state update is asynchronous. A common workaround is to use the callback form of setState:

this.setState(prevState => ({ counter: prevState.counter + 1 }), () => {
console.log(this.state.counter); // Will reflect the updated value

Re-rendering and the Virtual DOM

The beauty of React lies in its efficiency, and a significant part of that efficiency stems from its use of the Virtual DOM. For those unfamiliar, the Virtual DOM is a lightweight representation of the actual DOM. When state or props of a component change, React creates a new Virtual DOM to represent those changes. This newly generated Virtual DOM is then compared (diffed) with the previous version to find the minimum number of changes required to update the real DOM.

React utilizes the Virtual DOM to optimize re-renders. Instead of updating the entire application on every change, it intelligently updates only the necessary parts. This selective updating is a performance boon, especially in large-scale applications.

When developers directly modify the state, React remains unaware of these changes. As a result, it doesn’t trigger a re-render, and the UI remains unchanged. This can cause inconsistencies between the displayed UI and the underlying data.

On the other hand, setState serves as a signal to React, informing it that the state has changed and that it should consider re-rendering the component. By using setState, you’re ensuring that React handles the change appropriately and updates the UI.

Working with Functional Updates

There are times when the next state depends on the previous state. For instance, when incrementing a counter, the new value is derived from the previous count. Directly mutating the state in such scenarios can lead to inconsistent results, especially in asynchronous operations.

To counter this, setState provides a way to use functional updates. Instead of passing an object to setState, you pass a function. This function receives the previous state as its argument and returns the updated state.

this.setState(prevState => ({
count: prevState.count + 1

By using functional updates, you ensure that the state is updated consistently, irrespective of when and how setState is called.

Common Pitfalls & Misconceptions

A common misconception is believing that setState is synchronous. Many developers expect the state and the DOM to update immediately after calling setState. This isn’t always the case. React batches these updates for performance reasons, leading to asynchronous state updates.

Direct mutation of the state doesn’t just prevent re-renders; it can also introduce subtle bugs that are hard to trace. Since React relies on the difference between the previous and current state to determine what to re-render, direct mutations, which bypass this check, can lead to unpredictable UI behavior.

Performance Implications

React’s use of setState goes beyond just signaling updates; it has performance benefits as well. By batching multiple setState calls together, React can optimize the number of renders, resulting in smoother UI updates.

Forcing synchronous state updates or sidestepping React’s update mechanism can cause performance hitches and unoptimized renders. It’s crucial to trust and utilize React’s built-in mechanisms for handling state.

Best Practices

  1. Always use setState for state mutations: This ensures React is informed of state changes and can handle re-renders optimally.
  2. Avoid direct state mutation for derived values: Use functional updates when the next state is dependent on the previous state.
  3. Utilize functional components and the useState hook for clearer state management: Introduced in React 16.8, the useState hook simplifies state management in functional components. For instance:
const [count, setCount] = useState(0);


Using setState is foundational to React’s philosophy. It ensures predictable behavior, optimizes performance, and makes your application robust. As developers, respecting and understanding these principles will only lead to better and more efficient applications.

Additional Resources

Happy coding, codedamn community! Keep building and refining your React skills.

Sharing is caring

Did you like what Rishabh Rao wrote? Thank them for their work by sharing it on social media.


No comments so far