Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Minhas anotações estou um pouco bagunçadas. Apenas organize elas para mim por favor. "•…

  1. 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. "

  2. 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 props pode 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 dispatch globalmente, permitindo que qualquer componente na árvore acesse esses valores diretamente.

    Passos para Combinar Reducer com Context

    1. Criar o Context
    2. Fornecer Estado e Dispatch no Context
    3. Consumir o Context em Qualquer Lugar da Árvore
    4. (Opcional) Organizar Reducer e Context em um Único Arquivo

    Passo 1: Criar o Context

    1. Inicializar o Reducer:

      const [tasks, dispatch] = useReducer(tasksReducer, initialTasks);
      
    2. Criar Dois Contexts Separados:

      • TasksContext: Fornece a lista atual de tarefas.
      • TasksDispatchContext: Fornece a função dispatch para enviar ações.
    3. 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 componente TaskApp.


    Passo 2: Fornecer Estado e Dispatch no Context

    1. Importar os Contexts em TaskApp:

      import { TasksContext, TasksDispatchContext } from './TasksContext.js';
      
    2. 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

    1. 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
      }
      
    2. 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

    1. 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>
        );
      }
      
    2. Atualizar TaskApp para Usar TasksProvider:

      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!