Tworzenie i udostępnianie Context
Utwórz kontekst React za pomocą createContext, opakuj drzewo komponentów w jego Provider i przekaż wartość początkową, którą mogą odczytywać wszyscy potomkowie.
Tworzenie i udostępnianie Context to bezpłatna lekcja React Native Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej React Native Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs React Native Academy zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
The Prop Drilling Problem
Prop drilling occurs when data needs to pass through many layers of components that do not use it themselves — they only pass it down to their children. For example, a user's authentication status might need to reach a deeply nested profile icon component, requiring it to be threaded through five intermediate components. The Context API solves this.
What is the Context API?
React's Context API lets you create a data channel that any component in the tree can subscribe to, regardless of how deeply nested it is. A Provider component supplies the value, and any descendant can read it with the useContext hook — no props required. It is built into React with no extra library needed.
Creating a Context with createContext
Call React.createContext(defaultValue) to create a context object. The defaultValue is only used when a component reads the context but has no matching Provider above it in the tree. In practice you almost always provide a value via the Provider, so the default is mainly used in tests.
import { createContext } from 'react';
// Create the context with a default value
export const ThemeContext = createContext({
theme: 'light',
toggleTheme: () => {},
});The Context Provider Component
Every context object comes with a .Provider component. Wrap the part of your component tree that needs access to the context with ThemeContext.Provider. Pass the current value via the value prop. All descendants of the Provider can now read this value.
import { ThemeContext } from './ThemeContext';
function App() {
const [theme, setTheme] = useState('light');
const value = {
theme,
toggleTheme: () => setTheme(t => t === 'light' ? 'dark' : 'light'),
};
return (
<ThemeContext.Provider value={value}>
<NavigationContainer>
<MainStack />
</NavigationContainer>
</ThemeContext.Provider>
);
}The Context Value Can Be Anything
The value you pass to the Provider can be any JavaScript value: a string, number, object, array, or function. In practice it is almost always an object that bundles both the current state and the functions to update it, keeping related data and behavior together.
// Simple string context
export const LanguageContext = createContext('en');
// Complex object context (more common)
export const UserContext = createContext({
user: null,
isAuthenticated: false,
login: () => {},
logout: () => {},
});Building a Reusable Context Provider
A common pattern is creating a separate Provider component that encapsulates the state and updater functions. Export both the context and the provider from the same file. This keeps all the context logic in one place and makes the provider easy to compose with other providers in the app root.
import { createContext, useState } from 'react';
export const AuthContext = createContext(null);
export function AuthProvider({ children }) {
const [user, setUser] = useState(null);
const login = (userData) => setUser(userData);
const logout = () => setUser(null);
return (
<AuthContext.Provider value={{ user, login, logout }}>
{children}
</AuthContext.Provider>
);
}Using the Provider in App.js
Wrap your app (or the subtree that needs the context) with the Provider component. Place global providers near the top of the tree — usually wrapping the navigation container. You can stack multiple providers and they will all be available to their descendants.
import { AuthProvider } from './context/AuthContext';
import { ThemeProvider } from './context/ThemeContext';
export default function App() {
return (
<ThemeProvider>
<AuthProvider>
<NavigationContainer>
<MainStack />
</NavigationContainer>
</AuthProvider>
</ThemeProvider>
);
}Multiple Contexts in the Same App
You can have as many contexts as needed. Common real-world contexts include: AuthContext for the logged-in user, ThemeContext for color scheme, CartContext for e-commerce, NotificationContext for push notification state. Keep each context focused on one concern to avoid re-render cascades when unrelated values change.
When Context Re-renders Consumers
Every time the Provider's value prop changes reference, all consumers re-render. If the value is an object literal created inline, it is a new reference on every parent render — even if the content is the same. You will learn to fix this with memoization in a later lesson, but understanding the trigger is the first step.
// Bad: new object on every render — all consumers re-render unnecessarily
<ThemeContext.Provider value={{ theme, toggleTheme }}>
// Better: memoize the value object
const value = useMemo(() => ({ theme, toggleTheme }), [theme]);Nested Providers Override Values
If you nest two Providers of the same context, the inner Provider's value overrides the outer one for all descendants inside it. This lets you override context values for specific subtrees — useful for themes in a modal, or a different user scope in a section of the app.
// Outer provider: theme='light'
<ThemeContext.Provider value={{ theme: 'light' }}>
<View>
{/* Inner override for a modal: theme='dark' */}
<ThemeContext.Provider value={{ theme: 'dark' }}>
<Modal />
</ThemeContext.Provider>
</View>
</ThemeContext.Provider>A Custom useAuth Hook
Encapsulate context access in a custom hook for a cleaner API. Export a useAuth hook that calls useContext(AuthContext). Add a guard to throw a helpful error if the hook is used outside of the AuthProvider, catching configuration mistakes early during development.
export function useAuth() {
const context = useContext(AuthContext);
if (!context) {
throw new Error('useAuth must be used within an AuthProvider');
}
return context;
}
// Usage in any component
const { user, logout } = useAuth();Quick Check
Test your understanding of creating and providing context from this lesson.
Lesson Recap
In this lesson you learned: createContext creates a context object with an optional default value, the Provider component supplies a value to all descendants, and encapsulate provider logic and updater functions in a dedicated Provider component. Next up we explore consuming context with the useContext hook.
Często zadawane pytania
Czy lekcja „Tworzenie i udostępnianie Context” jest bezpłatna?
Tak — pełny tekst „Tworzenie i udostępnianie Context” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu React Native Academy, przejdź na CoddyKit PRO. Kurs React Native Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Tworzenie i udostępnianie Context”?
Utwórz kontekst React za pomocą createContext, opakuj drzewo komponentów w jego Provider i przekaż wartość początkową, którą mogą odczytywać wszyscy potomkowie. Ćwiczysz React Native Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć React Native Academy?
Nie wymagamy żadnego doświadczenia. React Native Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Tworzenie i udostępnianie Context”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji React Native Academy?
Tak. Każda lekcja React Native Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Tworzenie i udostępnianie Context
- Korzystanie z Context za pomocą useContext
- Kontekst motywu z przełącznikiem trybu ciemnego
- Unikanie problemów z wydajnością Context