Passing Data Deeply with Context·续
```js src/Heading.js import { useContext } from 'react'; import { LevelContext } from './LevelContext.js';
export default function Heading({ children }) { const level = useContext(LevelContext); switch (level) { case 0: throw Error('Heading must be inside a Section!'); case 1: return
{children}
; case 2: return{children}
; case 3: return{children}
; case 4: return{children}
; case 5: return{children}
; case 6: return{children}
; default: throw Error('Unknown level: ' + level); } }
```js src/LevelContext.js
import { createContext } from 'react';
export const LevelContext = createContext(0);
.section {
padding: 10px;
margin: 5px;
border-radius: 5px;
border: 1px solid #aaa;
}
Now both Heading and Section read the LevelContext to figure out how "deep" they are. And the Section wraps its children into the LevelContext to specify that anything inside of it is at a "deeper" level.
[!NOTE]
This example uses heading levels because they show visually how nested components can override context. But context is useful for many other use cases too. You can pass down any information needed by the entire subtree: the current color theme, the currently logged in user, and so on.
Context passes through intermediate components
You can insert as many components as you like between the component that provides context and the one that uses it. This includes both built-in components like <div> and components you might build yourself.
In this example, the same Post component (with a dashed border) is rendered at two different nesting levels. Notice that the <Heading> inside of it gets its level automatically from the closest <Section>:
import Heading from './Heading.js';
import Section from './Section.js';
export default function ProfilePage() {
return (
<Section>
<Heading>My Profile</Heading>
<Post
title="Hello traveller!"
body="Read about my adventures."
/>
<AllPosts />
</Section>
);
}
function AllPosts() {
return (
<Section>
<Heading>Posts</Heading>
<RecentPosts />
</Section>
);
}
function RecentPosts() {
return (
<Section>
<Heading>Recent Posts</Heading>
<Post
title="Flavors of Lisbon"
body="...those pastéis de nata!"
/>
<Post
title="Buenos Aires in the rhythm of tango"
body="I loved it!"
/>
</Section>
);
}
function Post({ title, body }) {
return (
<Section isFancy={true}>
<Heading>
{title}
</Heading>
<p><i>{body}</i></p>
</Section>
);
}
```js src/Section.js import { useContext } from 'react'; import { LevelContext } from './LevelContext.js';
export default function Section({ children, isFancy }) { const level = useContext(LevelContext); return (
```js src/Heading.js
import { useContext } from 'react';
import { LevelContext } from './LevelContext.js';
export default function Heading({ children }) {
const level = useContext(LevelContext);
switch (level) {
case 0:
throw Error('Heading must be inside a Section!');
case 1:
return <h1>{children}</h1>;
case 2:
return <h2>{children}</h2>;
case 3:
return <h3>{children}</h3>;
case 4:
return <h4>{children}</h4>;
case 5:
return <h5>{children}</h5>;
case 6:
return <h6>{children}</h6>;
default:
throw Error('Unknown level: ' + level);
}
}
```js src/LevelContext.js import { createContext } from 'react';
export const LevelContext = createContext(0);
```css
.section {
padding: 10px;
margin: 5px;
border-radius: 5px;
border: 1px solid #aaa;
}
.fancy {
border: 4px dashed pink;
}
You didn't do anything special for this to work. A Section specifies the context for the tree inside it, so you can insert a <Heading> anywhere, and it will have the correct size. Try it in the sandbox above!
Context lets you write components that "adapt to their surroundings" and display themselves differently depending on where (or, in other words, in which context) they are being rendered.
How context works might remind you of CSS property inheritance. In CSS, you can specify color: blue for a <div>, and any DOM node inside of it, no matter how deep, will inherit that color unless some other DOM node in the middle overrides it with color: green. Similarly, in React, the only way to override some context coming from above is to wrap children into a context provider with a different value.
In CSS, different properties like color and background-color don't override each other. You can set all <div>'s color to red without impacting background-color. Similarly, different React contexts don't override each other. Each context that you make with createContext() is completely separate from other ones, and ties together components using and providing that particular context. One component may use or provide many different contexts without a problem.
Before you use context
Context is very tempting to use! However, this also means it's too easy to overuse it. Just because you need to pass some props several levels deep doesn't mean you should put that information into context.
Here's a few alternatives you should consider before using context:
- Start by passing props. If your components are not trivial, it's not unusual to pass a dozen props down through a dozen components. It may feel like a slog, but it makes it very clear which components use which data! The person maintaining your code will be glad you've made the data flow explicit with props.
- Extract components and pass JSX as
childrento them. If you pass some data through many layers of intermediate components that don't use that data (and only pass it further down), this often means that you forgot to extract some components along the way. For example, maybe you pass data props likepoststo visual components that don't use them directly, like<Layout posts={posts} />. Instead, makeLayouttakechildrenas a prop, and render<Layout><Posts posts={posts} /></Layout>. This reduces the number of layers between the component specifying the data and the one that needs it.
If neither of these approaches works well for you, consider context.
Use cases for context
- Theming: If your app lets the user change its appearance (e.g. dark mode), you can put a context provider at the top of your app, and use that context in components that need to adjust their visual look.
- Current account: Many components might need to know the currently logged in user. Putting it in context makes it convenient to read it anywhere in the tree. Some apps also let you operate multiple accounts at the same time (e.g. to leave a comment as a different user). In those cases, it can be convenient to wrap a part of the UI into a nested provider with a different current account value.
- Routing: Most routing solutions use context internally to hold the current route. This is how every link "knows" whether it's active or not. If you build your own router, you might want to do it too.
- Managing state: As your app grows, you might end up with a lot of state closer to the top of your app. Many distant components below may want to change it. It is common to use a reducer together with context to manage complex state and pass it down to distant components without too much hassle.
Context is not limited to static values. If you pass a different value on the next render, React will update all the components reading it below! This is why context is often used in combination with state.
In general, if some information is needed by distant components in different parts of the tree, it's a good indication that context will help you.
- Context lets a component provide some information to the entire tree below it.
- To pass context:
- Create and export it with
export const MyContext = createContext(defaultValue). - Pass it to the
useContext(MyContext)Hook to read it in any child component, no matter how deep. - Wrap children into
<MyContext value={...}>to provide it from a parent. - Context passes through any components in the middle.
- Context lets you write components that "adapt to their surroundings".
- Before you use context, try passing props or passing JSX as
children.
Replace prop drilling with context
In this example, toggling the checkbox changes the imageSize prop passed to each <PlaceImage>. The checkbox state is held in the top-level App component, but each <PlaceImage> needs to be aware of it.
Currently, App passes imageSize to List, which passes it to each Place, which passes it to the PlaceImage. Remove the imageSize prop, and instead pass it from the App component directly to PlaceImage.
You can declare context in Context.js.
```js src/App.js import { useState } from 'react'; import { places } from './data.js'; import { getImageUrl } from './utils.js';
export default function App() { const [isLarge, setIsLarge] = useState(false); const imageSize = isLarge ? 150 : 100; return ( <>
-
</>
)
}
function List({ imageSize }) { const listItems = places.map(place =>
- {listItems}
function Place({ place, imageSize }) {
return (
<>
{place.name} {': ' + place.description}
</> ); }function PlaceImage({ place, imageSize }) {
return (
);
}
```js src/Context.js
```js src/data.js export const places = [{ id: 0, name: 'Bo-Kaap in Cape Town, South Africa', description: 'The tradition of choosing bright colors for houses began in the late 20th century.', imageId: 'K9HVAGH' }, { id: 1, name: 'Rainbow Village in Taichung, Taiwan', description: 'To save the houses from demolition, Huang Yung-Fu, a local resident, painted all 1,200 of them in 1924.', imageId: '9EAYZrt' }, { id: 2, name: 'Macromural de Pachuca, Mexico', description: 'One of the largest murals in the world covering homes in a hillside neighborhood.', imageId: 'DgXHVwu' }, { id: 3, name: 'Selarón Staircase in Rio de Janeiro, Brazil', description: 'This landmark was created by Jorge Selarón, a Chilean-born artist, as a "tribute to the Brazilian people."', imageId: 'aeO3rpI' }, { id: 4, name: 'Burano, Italy', description: 'The houses are painted following a specific color system dating back to 16th century.', imageId: 'kxsph5C' }, { id: 5, name: 'Chefchaouen, Marocco', description: 'There are a few theories on why the houses are painted blue, including that the color repels mosquitos or that it symbolizes sky and heaven.', imageId: 'rTqKo46' }, { id: 6, name: 'Gamcheon Culture Village in Busan, South Korea', description: 'In 2009, the village was converted into a cultural hub by painting the houses and featuring exhibitions and art installations.', imageId: 'ZfQOOzf' }];
```js src/utils.js
export function getImageUrl(place) {
return (
'https://react.dev/images/docs/scientists/' +
place.imageId +
'l.jpg'
);
}
ul { list-style-type: none; padding: 0px 10px; }
li {
margin-bottom: 10px;
display: grid;
grid-template-columns: auto 1fr;
gap: 20px;
align-items: center;
}
Remove imageSize prop from all the components.
Create and export ImageSizeContext from Context.js. Then wrap the List into <ImageSizeContext value={imageSize}> to pass the value down, and useContext(ImageSizeContext) to read it in the PlaceImage:
```js src/App.js import { useState, useContext } from 'react'; import { places } from './data.js'; import { getImageUrl } from './utils.js'; import { ImageSizeContext } from './Context.js';
export default function App() {
const [isLarge, setIsLarge] = useState(false);
const imageSize = isLarge ? 150 : 100;
return (
-
)
}
function List() { const listItems = places.map(place =>
- {listItems}
function Place({ place }) {
return (
<>
{place.name} {': ' + place.description}
</> ); }function PlaceImage({ place }) {
const imageSize = useContext(ImageSizeContext);
return (
);
}
```js src/Context.js
import { createContext } from 'react';
export const ImageSizeContext = createContext(500);
```js src/data.js export const places = [{ id: 0, name: 'Bo-Kaap in Cape Town, South Africa', description: 'The tradition of choosing bright colors for houses began in the late 20th century.', imageId: 'K9HVAGH' }, { id: 1, name: 'Rainbow Village in Taichung, Taiwan', description: 'To save the houses from demolition, Huang Yung-Fu, a local resident, painted all 1,200 of them in 1924.', imageId: '9EAYZrt' }, { id: 2, name: 'Macromural de Pachuca, Mexico', description: 'One of the largest murals in the world covering homes in a hillside neighborhood.', imageId: 'DgXHVwu' }, { id: 3, name: 'Selarón Staircase in Rio de Janeiro, Brazil', description: 'This landmark was created by Jorge Selarón, a Chilean-born artist, as a "tribute to the Brazilian people".', imageId: 'aeO3rpI' }, { id: 4, name: 'Burano, Italy', description: 'The houses are painted following a specific color system dating back to 16th century.', imageId: 'kxsph5C' }, { id: 5, name: 'Chefchaouen, Marocco', description: 'There are a few theories on why the houses are painted blue, including that the color repels mosquitos or that it symbolizes sky and heaven.', imageId: 'rTqKo46' }, { id: 6, name: 'Gamcheon Culture Village in Busan, South Korea', description: 'In 2009, the village was converted into a cultural hub by painting the houses and featuring exhibitions and art installations.', imageId: 'ZfQOOzf' }];
```js src/utils.js
export function getImageUrl(place) {
return (
'https://react.dev/images/docs/scientists/' +
place.imageId +
'l.jpg'
);
}
ul { list-style-type: none; padding: 0px 10px; }
li {
margin-bottom: 10px;
display: grid;
grid-template-columns: auto 1fr;
gap: 20px;
align-items: center;
}
Note how components in the middle don't need to pass imageSize anymore.
