Different ways to handle state in React applications

Author: neptune | 21st-Jun-2023

React is a popular JavaScript library for building user interfaces, and managing state is an essential aspect of any React application. State allows you to store and manage data that can change over time, such as user input or the result of an API call. In this article, we will explore different ways to manage states in React, including local component state, context API, and state management libraries.


1. Local Component State:

One of the simplest ways to manage state in React is by using local component state. Each component can have its own state, which is accessible only within that component. The state can be initialized in the constructor and updated using the `setState` method provided by React. Here's an example:



import React, { Component } from 'react';


class Counter extends Component {

  constructor(props) {

    super(props);

    this.state = {

      count: 0

    };

  }


  incrementCount() {

    this.setState({ count: this.state.count + 1 });

  }


  render() {

    return (

      <div>

        <p>Count: {this.state.count}</p>

        <button onClick={() => this.incrementCount()}>Increment</button>

      </div>

    );

  }

}




In the above example, the `Counter` component has its own state called `count`, which is initially set to 0. Clicking the "Increment" button triggers the `incrementCount` method, which updates the state using `setState`.


2. Context API:

The Context API is a built-in feature in React that allows you to share state across multiple components without passing props explicitly. It is useful when you have data that needs to be accessed by many components at different levels in the component tree. Here's an example:



import React, { createContext, useState } from 'react';


const CountContext = createContext();


const App = () => {

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


  return (

    <CountContext.Provider value={{ count, setCount }}>

      <div>

        <Counter />

      </div>

    </CountContext.Provider>

  );

};


const Counter = () => {

  const { count, setCount } = useContext(CountContext);


  const incrementCount = () => {

    setCount(count + 1);

  };


  return (

    <div>

      <p>Count: {count}</p>

      <button onClick={incrementCount}>Increment</button>

    </div>

  );

};


In this example, the `CountContext` is created using `createContext`, and the `count` state and `setCount` function are provided to the `Counter` component through the `CountContext.Provider` in the `App` component. The `Counter` component can access and update the state using the `useContext` hook.


3. State Management Libraries:

For larger and more complex applications, managing state with just local component state or the Context API might become challenging. In such cases, using state management libraries like Redux or MobX can be beneficial. These libraries provide a centralised state management approach and enable predictable state updates. Here's an example using Redux:



import React from 'react';

import { createStore } from 'redux';

import { Provider, connect } from 'react-redux';


const initialState = {

  count: 0

};


const reducer = (state = initialState, action) => {

  switch (action.type) {

    case 'INCREMENT':

      return { count: state.count + 1 };

    default:

      return state;

  }

};


const store = createStore(reducer);


const Counter = ({ count, incrementCount }) => (

  <div>

    <p>Count:


 {count}</p>

    <button onClick={incrementCount}>Increment</button>

  </div>

);


const mapStateToProps = state => ({

  count: state.count

});


const mapDispatchToProps = dispatch => ({

  incrementCount: () => dispatch({ type: 'INCREMENT' })

});


const ConnectedCounter = connect(mapStateToProps, mapDispatchToProps)(Counter);


const App = () => (

  <Provider store={store}>

    <ConnectedCounter />

  </Provider>

);



In this example, we create a Redux store with an initial state and a reducer function that handles state updates. The `Counter` component is connected to the store using the `connect` function from the `react-redux` library. The `mapStateToProps` function maps the state to the component props, and the `mapDispatchToProps` function maps the dispatch actions to props. The `Provider` component wraps the `ConnectedCounter` component to provide access to the store.


Conclusion

These are just a few ways to manage states in React. The choice of state management technique depends on the complexity and specific requirements of your application. By understanding and utilising the different options available, you can effectively manage state in your React projects. 


For simple and small-scale applications, local component state is often sufficient. However, as applications grow in size and complexity, using a state management library like Redux or MobX can offer benefits.Context API, another built-in feature of React, is a viable option when you need to share state across components at different levels in the component tree without prop drilling.

Ultimately, the best way to manage state in React depends on the specific needs of your project. It is essential to evaluate the complexity, scalability, and maintainability of your application to determine the most appropriate state management approach. Consider the trade-offs and benefits of each method and choose the one that aligns best with your project requirements.




👉 Read More
React: Slideshow App | Fresco Play Hackerrank
Generate Fibonacci Sequence - JavaScript | Hackerank
Managing Virtual Environments in React JavaScript Projects
To Be Or Not To Be | #2704 | LeetCode Solution
Apply Transform Over Each Element in Array | #2635 | LeetCode Solution
Create Your First App in React with Redux | Counter app
Function Composition | #2629 | LeetCode Solution
Essential Topics to Master React JS
Counter | #2620 | LeetCode Solution
React.js vs React Native – What's the Difference?
Chunk Array | #2677 | LeetCode Solution
Counter 2 | #2665 | LeetCode Solution
Array Reduce Transformation | #2626 | LeetCode Solution
Add Two Promises | #2723 | LeetCode Solution
Filter Elements from Array | #2634 | LeetCode Solution
Why React Refuses to Die ?
Opportunities - React Django Developer
😱 How React Kicks Off OOPs ? 😱
Arrow Functions in JavaScript | ES6
From REST to GraphQL: The Future of API Design
Is Object Empty | #2727 | LeetCode | JavaScript Solution
Celebrating 10 Years of React: A Decade of Innovation
How I Built My Blogging Website Using React, Node.js, and Jamstack Architecture?
How to Perform Unit Testing in React Components with Examples?
Do you know ! How to manage State in Functional & Class Components in React ?
A Guide to Writing Clean, Readable, and Maintainable Code in JavaScript
How to Get Started with Jamstack: A Comprehensive Guide?
Why, What, and When: Understanding Jamstack?
Explore more Blogs...