Context API and Composition

The Context API in React allows sharing state and logic across components without manually passing props through each level of the component tree. It provides global access to data via a Context, enabling nested and child components to access required data easily. By composing components within a Context component created using createContext(), data can be accessed using useContext() without needing props. This approach simplifies component composition and is particularly useful for sharing common state and logic throughout a component tree hierarchy.

Example: This example demostrates the implementation of Context API.

Javascript




// App.js
  
import React, { createContext } from "react";
import ParentComponent from "./ParentComponent";
  
export const NewContext = createContext();
  
const text = {
    parent: "I'm from parent Component",
    child: "I'm from child Component"
};
  
function App() {
    return (
        <NewContext.Provider value={text}>
            <ParentComponent />
        </NewContext.Provider>
    );
}
export default App;


Javascript




// ParentComponent.js
  
import React, { useContext } from "react";
import { NewContext } from "./App";
import ChildComponent from "./ChildComponent";
  
function ParentComponent() {
    const data = useContext(NewContext);
    return (
        <div>
            <h1> {data.parent} </h1>
            <ChildComponent />
        </div>
    );
};
  
export default ParentComponent;


Javascript




// Childcomponent.js
  
import React, { useContext } from "react";
import { NewContext } from "./App";
  
function ChildComponent() {
    const data = useContext(NewContext);
    return (
        <h1> {data.child} </h1>
    );
}
export default ChildComponent;


Output :

React JS Component Composition

Component composition in React involves the inclusion of one or more components in a single component, where each sub-component can further consist of additional components. Components in React are building blocks that are used to create user interfaces (UIs).

Table of Content

  • What is a Component Composition in React?
  • How can composition help performance?
  • Composing Components with props
  • Higher order components
  • Render Props pattern
  • Using Hooks in Component Composition
  • Context API and Composition
  • Compound Components
  • Component Composition Patterns
  • Containment Pattern
  • Specialization Pattern
  • Why Composition Wins Over Inheritance?

Similar Reads

What is a Component Composition in React?

Component composition in React involves combining smaller, independent components to create complex UIs. Each sub-component can contain further components, enhancing code readability. This process breaks down the UI into manageable pieces, aiding traceability, scalability, and maintenance. Component composition facilitates easier debugging and isolated changes, making web development more efficient and maintainable....

How can composition help performance?

Composition can enhance performance in software development through several key mechanisms:...

Steps to Create the React Application :

Step 1: Create a new react application using the following command....

Composing Components with props:

...

Higher order components:

...

Render Props pattern:

...

Using Hooks in Component Composition:

Composing components with props involves passing props through attributes to the components, and these components are composed in another component. Passing props through attributes to a component is similar to passing arguments to a JavaScript function. Props are like data packets that are passed down to child components from parent component, which helps child components customize their information and appearnce accordingly....

Context API and Composition:

...

Compound Components:

...

Component Composition Patterns:

In React, a Higher Order Component (HOC) is a function that takes a component and returns a new one with added props or behavior. Similar to higher order functions in JavaScript, HOCs are used to reuse component logic throughout an application. They enable developers to enhance existing components with new props without altering the original component code, thus avoiding unnecessary rewriting....

Containment Pattern:

...

Specialization Pattern :

...

Why Composition Wins Over Inheritance?

The Render Prop pattern in React involves passing a function as a prop to a component, which returns a React element. Instead of implementing its own rendering logic, the component calls this function. This pattern enables sharing and reusing rendering logic across multiple components. It’s particularly useful when a component possesses data but lacks the JSX definition to render it. In such cases, a parent component passes a function with JSX structure as a prop to the child component, which utilizes this function to render JSX....

Contact Us