Creación y provisión de un contexto
Cree un contexto de React con createContext, envuelva el árbol de componentes en su Provider y pase un valor inicial que todos los descendientes puedan leer.
Creación y provisión de un contexto es una lección gratuita de React Native Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de React Native Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de React Native Academy incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
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.
Preguntas frecuentes
¿La lección «Creación y provisión de un contexto» es gratis?
Sí — el texto completo de «Creación y provisión de un contexto» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de React Native Academy, actualiza a CoddyKit PRO. El curso de React Native Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Creación y provisión de un contexto»?
Cree un contexto de React con createContext, envuelva el árbol de componentes en su Provider y pase un valor inicial que todos los descendientes puedan leer. Practicas React Native Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar React Native Academy?
No se requiere experiencia previa. React Native Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Creación y provisión de un contexto»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de React Native Academy?
Sí. Cada lección de React Native Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Creación y provisión de un contexto
- Consumo de contexto con useContext
- Un contexto de tema con alternancia del modo oscuro
- Cómo evitar problemas de rendimiento del contexto