# 1.20 React Local vs Global State - Context API vs Redux Explained

In React, choosing between **Local State** and **Global State** isn't just about code organization—it’s about performance. Storing data in the wrong place can cause unnecessary re-renders, slowing down your application.

* * *

### 1\. Local State

Local state is data that belongs to a single component and doesn't need to be accessed by others.

*   **When to use:** Input field values, toggles, form validation, or component-specific UI states (like opening a modal).
    
*   **Tools:** `useState` or `useReducer`.
    
*   **Pro Tip:** `useReducer` is often cleaner and more performant than `useState` when you have complex state logic within a single component.
    

* * *

### 2\. Global State

Global state is data that needs to be shared across multiple components (e.g., user authentication, shopping cart items, or theme preferences).

#### Context API

*   **Best for:** Low-frequency updates.
    
*   **Use Cases:** Themes (Dark/Light mode), Language settings, or User Auth status.
    
*   **The Catch:** When the Context value changes, **all consuming components re-render**. If the data changes very frequently (like a live chat or high-frequency counters), Context API can cause major performance issues.
    

#### Redux (and similar libraries)

*   **Best for:** High-frequency updates and complex state logic.
    
*   **Use Cases:** Shopping carts in e-commerce apps, real-time dashboards, or chat applications.
    
*   **Key Advantage:** Redux is "predictable." It uses middleware to handle complex asynchronous tasks (like API calls) and allows you to use **DevTools** to inspect exactly how your state changes over time. It is also more performant for large-scale apps because only the specific components connected to the state update, not every consumer.
    

* * *

### Summary Table

| Feature | Context API | Redux |
| --- | --- | --- |
| **Complexity** | Low (easy setup) | High (requires more boilerplate) |
| **Update Frequency** | Low (Rare changes) | High (Frequent changes) |
| **Re-renders** | Renders all consumers | Renders only connected components |
| **Best For** | Theme, Auth, Language | Shopping Cart, Chat, Data Caching |

* * *

### Interview Q&A

**Q: Why does it matter where I store my state?** A: It matters because of **re-renders**. In React, whenever a state updates, the component re-renders. If you put global data in a local state, you lose access to it elsewhere. If you put data that changes every second into Context API, your whole app might lag because every component using that context will re-render constantly.

**Q: When should I choose Context API over Redux?** A: Choose Context API when you need to share data with just a few components and that data doesn't change often. It's built into React, so it’s great for simple things like "Is the user logged in?" or "What is the current theme?"

**Q: When is Redux a better choice?** A: Go for Redux when your app is large, your state logic is complicated, or you have data that updates very quickly. Redux is highly optimized for performance and provides great tools to debug your application's state as it changes.

**Q: Can I use both in the same project?** A: Absolutely. It is a common pattern to use Redux for your "Global App Data" (like products and user profiles) while using Local State (`useState`) for simple things like form inputs within individual components.

* * *

*Is there a specific feature in your current project where you are unsure whether to use Context or Redux?*