Minhas anotações estou um pouco bagunçadas. Apenas organize elas para mim por favor. "•…
- User
Minhas anotações estou um pouco bagunçadas. Apenas organize elas para mim por favor.
"• Aumentando a Escala com Reducer e Context
• Por exemplo, TaskApp passa uma lista de tarefas e os manipuladores de eventos para TaskList:
E TaskList passa os manipuladores de eventos para Task:
Em um exemplo pequeno como este, isso funciona bem, mas se você tiver dezenas ou centenas de componentes no meio, passar todo o estado e funções pode ser bem frustrante!
É por isso que, como alternativa a passá-los através de props, você pode querer colocar tanto o estado das tarefas quanto a função dispatch no context. Dessa forma, qualquer componente abaixo de TaskApp na árvore pode ler as tarefas e enviar ações sem a repetitiva "perfuração de props". • Aqui está como você pode combinar um reducer com context:
Crie o context. Coloque estado e dispatch no context. Use o context em qualquer lugar da árvore. Passo 1: Crie o context O Hook useReducer retorna as tarefas atuais e a função dispatch que permite atualizá-las:
const [tasks, dispatch] = useReducer(tasksReducer, initialTasks); Para passá-las pela árvore, você criará dois contexts separados:
TasksContext fornece a lista atual de tarefas. TasksDispatchContext fornece a função que permite aos componentes enviar ações. • Exporte-os de um arquivo separado para que você possa importá-los de outros arquivos mais tarde • import { createContext } from 'react';
export const TasksContext = createContext(null); export const TasksDispatchContext = createContext(null); • Aqui, você está passando null como o valor padrão para ambos os contexts. Os valores reais serão fornecidos pelo componente TaskApp. • Passo 2: Coloque estado e dispatch no context • Passo 2: Coloque estado e dispatch no context Agora você pode importar ambos os contexts no seu componente TaskApp. Pegue as tarefas e dispatch retornados por useReducer() e forneça-os para toda a árvore abaixo:
import { TasksContext, TasksDispatchContext } from './TasksContext.js';
export default function TaskApp() { const [tasks, dispatch] = useReducer(tasksReducer, initialTasks); // ... return ( <TasksContext.Provider value={tasks}> <TasksDispatchContext.Provider value={dispatch}> ... </TasksDispatchContext.Provider> </TasksContext.Provider> ); } • Passo 3: Use o context em qualquer lugar da árvore Agora você não precisa passar a lista de tarefas ou os manipuladores de eventos pela árvore:
<TasksContext.Provider value={tasks}> <TasksDispatchContext.Provider value={dispatch}> Day off in Kyoto </TasksDispatchContext.Provider > </TasksContext.Provider > Em vez disso, qualquer componente que precise da lista de tarefas pode lê-la do TaskContext:
export default function TaskList() { const tasks = useContext(TasksContext); // ... • O componente TaskApp não passa nenhum manipulador de eventos, e o TaskList também não passa nenhum manipulador de eventos para o componente Task. Cada componente lê o context que precisa • Movendo toda a ligação para um único arquivo
• Você não precisa fazer isso, mas poderia despoluir ainda mais os componentes movendo tanto o reducer quanto o context para um único arquivo. • import { createContext } from 'react';
export const TasksContext = createContext(null); export const TasksDispatchContext = createContext(null); • Este arquivo está prestes a ficar cheio! Você moverá o reducer para o mesmo arquivo. Então, você declarará um novo componente TasksProvider no mesmo arquivo. Este componente juntará todas as peças:
Ele gerenciará o estado com um reducer. Ele fornecerá ambos os contexts para os componentes abaixo. Ele pegará filhos como um prop para que você possa passar JSX para ele.
export function TasksProvider({ children }) { const [tasks, dispatch] = useReducer(tasksReducer, initialTasks);
return ( <TasksContext.Provider value={tasks}> <TasksDispatchContext.Provider value={dispatch}> {children} </TasksDispatchContext.Provider> </TasksContext.Provider> ); } • Isso remove toda a complexidade e ligação do seu componente TaskApp • import AddTask from './AddTask.js'; import TaskList from './TaskList.js'; import { TasksProvider } from './TasksContext.js';
export default function TaskApp() { return ( Day off in Kyoto ); } • Você também pode exportar funções que usam o context de TasksContext.js:
export function useTasks() { return useContext(TasksContext); }
export function useTasksDispatch() { return useContext(TasksDispatchContext); } Quando um componente precisa ler o context, ele pode fazer isso através dessas funções:
const tasks = useTasks(); const dispatch = useTasksDispatch(); • Isso não muda o comportamento de forma alguma, mas permite que você divida esses contexts ainda mais ou adicione alguma lógica a essas funções • Isso mantém os componentes limpos e despoluídos, focados no que eles exibem em vez de onde obtêm os dados • Funções como useTasks e useTasksDispatch são chamadas de Custom Hooks. Sua função é considerada um custom hook se seu nome começar com use. Isso permite que você use outros Hooks, como useContext, dentro dela. • À medida que seu app cresce, você pode ter muitos pares context-reducer como este. Esta é uma maneira poderosa de aumentar a escala do seu app e elevar o estado sem muito trabalho sempre que você quiser acessar os dados profundamente na árvore. "
- Assistant
Claro! Vou organizar suas anotações sobre Aumentando a Escala com Reducer e Context de forma estruturada para facilitar o entendimento e a consulta futura.
Aumentando a Escala com Reducer e Context
Problema: Prop Drilling
Quando você tem múltiplos níveis de componentes, passar estado e funções através de
propspode se tornar frustrante e difícil de manter. Por exemplo:Exemplo Inicial
-
TaskApp passa uma lista de tarefas e os manipuladores de eventos para TaskList:
<TaskList tasks={tasks} onChangeTask={handleChangeTask} onDeleteTask={handleDeleteTask} /> -
TaskList passa os manipuladores de eventos para Task:
<Task task={task} onChange={onChangeTask} onDelete={onDeleteTask} />
Este padrão funciona bem em aplicações pequenas, mas não escala bem com dezenas ou centenas de componentes.
Solução: Usar Reducer e Context
Para evitar o prop drilling, você pode utilizar o Context para fornecer o estado e a função
dispatchglobalmente, permitindo que qualquer componente na árvore acesse esses valores diretamente.Passos para Combinar Reducer com Context
- Criar o Context
- Fornecer Estado e Dispatch no Context
- Consumir o Context em Qualquer Lugar da Árvore
- (Opcional) Organizar Reducer e Context em um Único Arquivo
Passo 1: Criar o Context
-
Inicializar o Reducer:
const [tasks, dispatch] = useReducer(tasksReducer, initialTasks); -
Criar Dois Contexts Separados:
- TasksContext: Fornece a lista atual de tarefas.
- TasksDispatchContext: Fornece a função
dispatchpara enviar ações.
-
Exportar os Contexts:
// TasksContext.js import { createContext } from 'react'; export const TasksContext = createContext(null); export const TasksDispatchContext = createContext(null);Nota:
nullé passado como valor padrão. Os valores reais serão fornecidos pelo componenteTaskApp.
Passo 2: Fornecer Estado e Dispatch no Context
-
Importar os Contexts em
TaskApp:import { TasksContext, TasksDispatchContext } from './TasksContext.js'; -
Envolver a Árvore de Componentes com os Providers:
export default function TaskApp() { const [tasks, dispatch] = useReducer(tasksReducer, initialTasks); return ( <TasksContext.Provider value={tasks}> <TasksDispatchContext.Provider value={dispatch}> {/* Componentes filhos */} </TasksDispatchContext.Provider> </TasksContext.Provider> ); }
Passo 3: Consumir o Context em Qualquer Lugar da Árvore
-
Exemplo de Uso no
TaskList:import { useContext } from 'react'; import { TasksContext } from './TasksContext.js'; export default function TaskList() { const tasks = useContext(TasksContext); // Renderizar as tarefas } -
Atualizando o Componente
TaskApp:import AddTask from './AddTask.js'; import TaskList from './TaskList.js'; import { TasksContext, TasksDispatchContext } from './TasksContext.js'; export default function TaskApp() { const [tasks, dispatch] = useReducer(tasksReducer, initialTasks); return ( <TasksContext.Provider value={tasks}> <TasksDispatchContext.Provider value={dispatch}> <h1>Day off in Kyoto</h1> <AddTask /> <TaskList /> </TasksDispatchContext.Provider> </TasksContext.Provider> ); }
Passo 4: Organizar Reducer e Context em um Único Arquivo (Opcional)
Para otimizar a estrutura do projeto, você pode consolidar o reducer e os contexts em um único arquivo e criar um componente
TasksProvider.Implementação de
TasksProvider-
Consolidar Contexts e Reducer:
// TasksProvider.js import { createContext, useReducer } from 'react'; export const TasksContext = createContext(null); export const TasksDispatchContext = createContext(null); export function TasksProvider({ children }) { const [tasks, dispatch] = useReducer(tasksReducer, initialTasks); return ( <TasksContext.Provider value={tasks}> <TasksDispatchContext.Provider value={dispatch}> {children} </TasksDispatchContext.Provider> </TasksContext.Provider> ); } -
Atualizar
TaskApppara UsarTasksProvider:import AddTask from './AddTask.js'; import TaskList from './TaskList.js'; import { TasksProvider } from './TasksProvider.js'; export default function TaskApp() { return ( <TasksProvider> <h1>Day off in Kyoto</h1> <AddTask /> <TaskList /> </TasksProvider> ); }
Criar Custom Hooks para Acesso Mais Simplificado
Para simplificar o consumo dos contexts, você pode criar Custom Hooks:
// TasksContext.js import { useContext, createContext } from 'react'; export const TasksContext = createContext(null); export const TasksDispatchContext = createContext(null); export function useTasks() { return useContext(TasksContext); } export function useTasksDispatch() { return useContext(TasksDispatchContext); }Uso dos Custom Hooks:
import { useTasks, useTasksDispatch } from './TasksContext.js'; export default function TaskList() { const tasks = useTasks(); const dispatch = useTasksDispatch(); // Utilizar tasks e dispatch conforme necessário }Benefícios:
- Componentes mais limpos: Focam no que exibem, não em como obtêm os dados.
- Reutilização de lógica: Facilita a manutenção e escalabilidade do código.
- Abstração: Pode adicionar lógica adicional nos hooks sem afetar os componentes.
Vantagens da Abordagem com Reducer e Context
- Escalabilidade: Fácil de escalar sem complicações de prop drilling.
- Organização: Centraliza o gerenciamento de estado.
- Reutilização: Components podem acessar o estado global de forma direta.
- Flexibilidade: Permite múltiplos pairs de context-reducer conforme necessário.
Resumo
Ao integrar useReducer com Context, você cria uma arquitetura escalável para seu aplicativo React, evitando a passagem excessiva de props e mantendo os componentes organizados e focados em suas responsabilidades. Além disso, a criação de Custom Hooks simplifica o acesso aos contexts, melhorando a legibilidade e manutenção do código.
Referências
Espero que esta organização ajude a esclarecer e facilitar o uso dos conceitos de Reducer e Context em suas aplicações React!
-