How can I share data between components in React.js?

How can I share data between components in React.js?

As the world of front-end development continues to evolve, React.js has firmly positioned itself as one of the leading libraries for building interactive user interfaces. At the heart of any dynamic application is data – the essential piece that drives the application’s behavior, presentation, and user interaction. In this article, we’re going to dive deep into understanding how data can be shared between React components.


React, developed and maintained by Facebook, allows developers to construct reusable UI components, and manage how data flows within the application. The right management of data is crucial as it determines the efficiency, readability, and scalability of the application. However, as the application grows in complexity, sharing data across multiple components can become a challenging task for developers. The question then arises: how can we efficiently share data between components?

React’s Component Hierarchy

In React, components are structured in a tree-like hierarchy, often referred to as the component tree. Components have parent-child relationships. The data in React flows unidirectionally, from parent to child. Understanding this hierarchy is fundamental because it dictates how data (or state) can be shared, passed down, or even lifted up among components.


What are props?
Props (short for properties) are a way of passing data from a parent to a child component. They are read-only and allow data to flow down the component tree.

Passing data from parent to child via props:
A parent component can pass data to its child component via props. For instance:

function ChildComponent(props) {
return <div>{props.data}</div>;

function ParentComponent() {
return <ChildComponent data="Hello from Parent!" />;

In this example, the ParentComponent is passing a string “Hello from Parent!” to ChildComponent.

Constraints of props (one-way data flow):
Props have a unidirectional flow, meaning data can only be passed from a parent component to a child component, not vice versa.

Static Data

Static data is constant and doesn’t change during the lifecycle of the component. Props are a perfect way to pass static data, as shown above.


Props aren’t limited to data alone. They can also be used to pass functions from a parent component to a child component. This allows child components to communicate back to their parents, albeit indirectly:

function ChildComponent(props) {
return <button onClick={props.clickHandler}>Click Me</button>;

function ParentComponent() {
const handleClick = () => alert('Button clicked!');

return <ChildComponent clickHandler={handleClick} />;


Introduction to state:
State represents data that might change over time and affects the component’s render output. It’s local and private to the component.

State in class-based components vs. functional components:
In class-based components, state is defined using the this.state object and is updated using this.setState(). In contrast, functional components use the useState hook introduced in React 16.8.

1// Class-based
2class MyComponent extends React.Component {
3 constructor() {
4 super();
5 this.state = { count: 0 };
6 }
8 render() {
9 return <div>{this.state.count}</div>;
10 }
13// Functional
14function MyComponent() {
15 const [count, setCount] = useState(0);
16 return <div>{count}</div>;

Sharing state by lifting it up:
Often, multiple components need to access and modify the same piece of state. In such cases, the state is lifted up to their closest common ancestor.

Scenario illustrating the need to lift state up

Consider two sibling components, InputComponent and DisplayComponent. The former allows users to input text, while the latter displays the text. To synchronize their data, the state (user’s input) should be housed in their parent component.

Steps to lift state up

  1. Move the state from the child component to the parent component.
  2. Pass the state down to the child components via props.
  3. If the child components need to modify the state, pass down callback functions via props.

Context API

What is the Context API?
React’s Context API provides a way to share values (data or functions) between components without having to explicitly pass props through every level of the component tree.

When to use Context:
Use Context when you want to share data that can be considered “global” for a tree of React components.

Creating a Context:
To create a context, you can use React.createContext().

const MyContext = React.createContext(defaultValue);

Providing and consuming context values:
To use the created context, wrap the component tree with a Provider that holds the value. Components within this tree can then consume the value using the Consumer component or the useContext hook.

<MyContext.Provider value={someValue}>
{/* child components can consume the value here */}


What is Redux?
Redux is a predictable state container for JavaScript applications. While it’s not exclusive to React, it’s commonly used with React to manage application state globally.

Core concepts: actions, reducers, and store:

  • Actions are payloads of information sent from the application to the store.
  • Reducers specify how the application’s state changes in response to actions.
  • Store holds the application state and provides methods to access and update it.

Connecting React components to Redux:
React components can be connected to the Redux store using the connect function from the ‘react-redux’ library. This allows components to dispatch actions to the store and retrieve state from it.

With these foundational techniques and tools, managing and sharing data across React components becomes more structured and efficient. Remember to always think about the data needs of your components and choose the right strategy based on the complexity of your application. For further reading, check out the official React documentation and the Redux documentation. Happy coding on codedamn!

Benefits of centralized state management with Redux

Centralized state management, particularly with Redux, is like having a single source of truth for your application’s data. With Redux:

  1. Predictability: Redux helps in creating applications where the state is predictable. Given the same input (i.e., actions), the state will always evolve in the same way.
  2. Debugging Ease: With tools like Redux DevTools, you can travel back and forth in your application’s state, making debugging easier.
  3. Consistency: All components access the same state, ensuring uniformity across your application.
  4. Middleware & Extensions: Redux allows the use of middleware to handle side-effects and extend its capabilities.
  5. Community Support: Redux, being one of the oldest state management libraries for React, has a vast community and plethora of resources available for learning and troubleshooting.

Alternatives to Redux

While Redux offers numerous advantages, it’s essential to know there are alternatives, each with its strengths:

  • MobX: Unlike Redux’s “single store” approach, MobX is more flexible with multiple stores and uses reactive data structures.
  • Recoil: Developed by Facebook, Recoil provides atoms and selectors, making state management more granular and scalable for larger applications.
  • Zustand: A smaller and simpler state management solution, focusing on a minimal API and full flexibility.

Local Component Storage

React introduced the useState and useReducer hooks in version 16.8. These hooks allow for localized component storage.

  • useState: Provides state to functional components. It returns the current state and a function to update it.
    const [count, setCount] = useState(0);
  • useReducer: Useful for more complex state logic, it returns the current state and a dispatch method.
    const [state, dispatch] = useReducer(reducer, initialArg, init);

Advantages of localized state:

  1. Encapsulation: Components manage their data, ensuring a clear boundary and avoiding unnecessary props.
  2. Optimization: Components re-render only when their local state changes.

Avoiding Prop Drilling

Prop drilling occurs when you pass data through several component layers. To prevent it:

  • Use Context API to share values across the component tree without explicitly passing a prop through every level.
  • Utilize Redux or its alternatives for global state, ensuring data access without drilling.

Higher Order Components (HOC) & Render Props

  • Higher Order Components (HOCs): A pattern where a function takes a component and returns a new component with added properties or behavior.
    function withData(WrappedComponent) {
    return class extends React.Component {
    render() {
    return <WrappedComponent data="someData" {...this.props} />;
  • Render Props: A technique where a component’s children are a function, allowing shared behavior between components.
    <DataProvider render={data => (<Component data={data} />)} />

Enhancing Components with HOCs

HOCs can be used to:

  • Inject props into components.
  • Abstract and reuse stateful logic across components.
  • Manipulate the rendering process.

Using Render Props to Share Data

Render Props help share code between React components using a prop whose value is a function.

<MouseTracker render={mouse => (
<Cat mouse={mouse} />

Advanced Techniques & Libraries

State management in React has evolved, leading to more advanced techniques and libraries:

  • Hooks: React’s feature to allow side effects and stateful logic in functional components. Libraries like Recoil and MobX now provide hooks for better data sharing.
  • Recoil, MobX, Zustand: These are advanced state management libraries, each with its uniqueness. Recoil offers atom-based management; MobX has observable states, while Zustand provides a minimalistic approach.

useContext and useMemo

  • useContext allows sharing values between components without prop drilling.
  • useMemo returns a memoized value, helping in performance optimization by ensuring computations aren’t run unnecessarily.

Custom Hooks

Custom hooks let you extract component logic into reusable functions.

Best Practices

  1. Immutable Data Structures: Avoid direct modifications; use libraries like Immer for immutability.
  2. Pure Components: Ensure components don’t produce side effects and always render the same output for the same state.
  3. Avoid Unnecessary Re-renders: Use memo, useMemo, and useCallback for optimization.
  4. Tools: Utilize tools like React DevTools for debugging and profiling.

Common Pitfalls & Solutions

  1. Prop Drilling: Avoid by using Context API or global state solutions.
  2. Over-reliance on Global State: Not all state needs to be global. Use local component state where possible.
  3. Not Optimizing Renders: Profile and optimize using React’s built-in tools.

Real-world Scenarios & Examples

Sharing User Authentication Status

Use Context API to create an AuthContext providing authentication status and methods to all components without prop drilling.

Theme Toggling

For theme toggling, maintain a theme state and provide a toggler function. Combine with styled-components or CSS variables for dynamic theming.

Managing a Shopping Cart

Consider using Redux for centralized cart management, ensuring synchronization across components.


Sharing data between components in React can be achieved in various ways, each with its pros and cons. It’s essential to evaluate your application’s needs and choose the right method. Whether it’s local state, context, Redux, or another library, the React ecosystem offers a solution tailored for every need.

References & Further Reading

Sharing is caring

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


No comments so far