Redux é uma ferramenta de gerenciamento de estado, construída especificamente para aplicativos JavaScript do lado do cliente que dependem muito de dados complexos e APIs externas, e fornece ótimas ferramentas de desenvolvedor que facilitam o trabalho com seus dados.

O que Redux faz?

Simplificando, Redux é um armazenamento de dados centralizado. Todos os dados do seu aplicativo são armazenados em um grande objeto. Os Redux Devtools facilitam a visualização:

Um armazenamento de dados Redux visualizado

Esse estado é imutável, o que é um conceito estranho no início, mas faz sentido por alguns motivos. Se você quiser modificar o estado, deve enviar um açao, que basicamente leva alguns argumentos, forma uma carga útil e a envia para o Redux. Redux passa o estado atual para um redutor função, que modifica o estado existente e retorna um novo estado que substitui o atual e dispara uma recarga dos componentes afetados. Por exemplo, você pode ter um redutor para adicionar um novo item a uma lista, ou remover ou editar um que já existe.

Fazer dessa forma significa que você nunca obterá qualquer comportamento indefinido com o estado de modificação do aplicativo à vontade. Além disso, como há um registro de cada ação e o que ela mudou, ele permite a depuração de viagem no tempo, onde você pode rolar o estado do seu aplicativo de volta para depurar o que acontece com cada ação (bem como um histórico do git).

Um registro de cada ação

Redux pode ser usado com qualquer framework de front-end, mas é comumente usado com React, e é nisso que nos concentraremos aqui. Nos bastidores, o Redux usa a API de contexto do React, que funciona de maneira semelhante ao Redux e é boa para aplicativos simples, se você quiser renunciar ao Redux por completo. No entanto, os Devtools do Redux são fantásticos ao trabalhar com dados complexos e, na verdade, são mais otimizados para evitar rerenders desnecessários.

Se você estiver usando TypeScript, as coisas são muito mais complicadas para que o Redux seja rigidamente tipado. Você vai querer seguir este guia, que usa typesafe-actions para lidar com as ações e redutores de uma maneira amigável.

Estruturando Seu Projeto

Primeiro, você vai querer definir a estrutura de sua pasta. Isso depende de você e das preferências de estilo de sua equipe, mas existem basicamente dois padrões principais que a maioria dos projetos Redux usa. O primeiro é simplesmente dividir cada tipo de arquivo (ação, redutor, middleware, efeito colateral) em sua própria pasta, assim:

store/
 actions/
 reducers/
 sagas/
 middleware/
 index.js

Porém, este não é o melhor, já que você frequentemente precisará de um arquivo de ação e de um redutor para cada recurso adicionado. É melhor mesclar as pastas de ações e redutores e dividi-los por recurso. Desta forma, cada ação e redutor correspondente ficam no mesmo arquivo. Vocês

store/
 features/
 todo/
 etc/
 sagas/
 middleware/
 root-reducer.js
 root-action.js
 index.js

Isso limpa as importações, pois agora você pode importar as ações e os redutores na mesma instrução usando:

import { todosActions, todosReducer } from 'store/features/todos'

Depende de você se deseja manter o código Redux em sua própria pasta (/store nos exemplos acima) ou integrá-lo à pasta raiz src do seu aplicativo. Se você já está separando o código por componente e está escrevendo muitas ações personalizadas e redutores para cada componente, pode querer mesclar o /features/ e /components/ pastas e armazenar componentes JSX junto com o código do redutor.

Se estiver usando Redux com TypeScript, você pode adicionar um arquivo adicional em cada pasta de recursos para definir seus tipos.

Instalando e Configurando Redux

Instale Redux e React-Redux do NPM:

npm install redux react-redux

Você provavelmente também vai querer redux-devtools:

npm install --save-dev redux-devtools

A primeira coisa que você deseja criar é sua loja. Salvar como /store/index.js

import { createStore } from 'redux'
 import rootReducer from './root-reducer'
 
 const store = createStore(rootReducer)
 
 export default store;

Claro, sua loja ficará mais complicada do que isso à medida que você adiciona coisas como addons de efeitos colaterais, middleware e outros utilitários como connected-react-router, mas isso é tudo o que é necessário por enquanto. Este arquivo pega o redutor de raiz e chama createStore() usando-o, que é exportado para o aplicativo usar.

A seguir, criaremos um recurso simples de lista de tarefas. Você provavelmente vai querer começar definindo as ações que esse recurso requer e os argumentos que são passados ​​a eles. Criar uma /features/todos/ pasta e salve o seguinte como types.js:

export const ADD = 'ADD_TODO'
 export const DELETE = 'DELETE_TODO'
 export const EDIT = 'EDIT_TODO'

Isso define algumas constantes de string para os nomes das ações. Independentemente dos dados que você está transmitindo, cada ação terá um type propriedade, que é uma string única que identifica a ação.

Não é necessário ter um arquivo de tipo como este, já que você pode simplesmente digitar o nome da string da ação, mas é melhor para a interoperabilidade fazer isso dessa maneira. Por exemplo, você poderia ter todos.ADD e reminders.ADD no mesmo aplicativo, o que evita o incômodo de digitar _TODO ou _REMINDER toda vez que você faz referência a uma ação para aquele recurso.

Em seguida, salve o seguinte como /store/features/todos/actions.js:

import * as types from './types.js'
 
 export const addTodo = text => ({ type: types.ADD, text })
 export const deleteTodo = id => ({ type: types.DELETE, id })
 export const editTodo = (id, text) => ({ type: types.EDIT, id, text })

Isso define algumas ações usando os tipos das constantes de string, exibindo os argumentos e a criação de carga útil para cada um. Eles não precisam ser totalmente estáticos, pois são funções - um exemplo que você pode usar é definir um CUID de tempo de execução para certas ações.

O código mais complicado, e onde você implementará a maior parte de sua lógica de negócios, são os redutores. Eles podem assumir muitas formas, mas a configuração mais comumente usada é com uma instrução switch que trata cada caso com base no tipo de ação. Salvar como reducer.js:

import * as types from './types.js'
 
 const initialState = [
 {
 text: 'Hello World',
 id: 0
 }
 ]
 
 export default function todos(state = initialState, action) {
 switch (action.type) {
 case types.ADD:
 return [
 ...state,
 {
 id: state.reduce((maxId, todo) => Math.max(todo.id, maxId), -1) + 1,
 text: action.text
 }
 ] 
 
 case types.DELETE:
 return state.filter(todo =>
 todo.id !== action.id
 )
 
 case types.EDIT:
 return state.map(todo =>
 todo.id === action.id ? { ...todo, text: action.text } : todo
 )
 
 default:
 return state
 }
 }

O estado é passado como um argumento e cada caso retorna uma versão modificada do estado. Neste exemplo, ADD_TODO acrescenta um novo item ao estado (com um novo ID a cada vez), DELETE_TODO remove todos os itens com o ID fornecido e EDIT_TODO mapeia e substitui o texto do item pelo ID fornecido.

O estado inicial também deve ser definido e passado para a função redutor como o valor padrão para a variável de estado. Claro, isso não define toda a sua estrutura de estado Redux, apenas o state.todos seção.

Esses três arquivos geralmente são separados em aplicativos mais complexos, mas se você quiser, também pode defini-los todos em um arquivo, apenas certifique-se de importar e exportar corretamente.

Com esse recurso completo, vamos conectá-lo ao Redux (e ao nosso aplicativo). No /store/root-reducer.js, importe o todosReducer (e qualquer outro redutor de recurso do /features/ pasta) e, em seguida, passe-o para combineReducers(), formando um redutor de raiz de nível superior que é passado para a loja. É aqui que você configurará o estado raiz, certificando-se de manter cada recurso em seu próprio branch.

import { combineReducers } from 'redux';
 
 import todosReducer from './features/todos/reducer';
 
 const rootReducer = combineReducers({
 todos: todosReducer
 })
 
 export default rootReducer

Usando Redux In React

Claro, nada disso é útil se não estiver conectado ao React. Para fazer isso, você terá que envolver todo o seu aplicativo em um componente Provider. Isso garante que o estado e os ganchos necessários sejam transmitidos a todos os componentes do seu aplicativo.

No App.js ou index.js, onde quer que você tenha sua função de renderização raiz, envolva seu aplicativo em um <Provider>e passá-lo à loja (importado de /store/index.js) como adereço:

import React from 'react';
 import ReactDOM from 'react-dom';
 
 // Redux Setup
 import { Provider } from 'react-redux';
 import store, { history } from './store';
 
 ReactDOM.render(
     <Provider store={store}>
 <App/>
     </Provider>
     , document.getElementById('root'));

Agora você está livre para usar o Redux em seus componentes. O método mais fácil é com componentes de função e ganchos. Por exemplo, para despachar uma ação, você usará o useDispatch() gancho, que permite chamar ações diretamente, por exemplo dispatch(todosActions.addTodo(text)).

O contêiner a seguir tem uma entrada conectada ao estado React local, que é usado para adicionar uma nova tarefa ao estado sempre que um botão é clicado:

import React, { useState } from 'react';
 
 import './Home.css';
 
 import { TodoList } from 'components'
 import { todosActions } from 'store/features/todos'
 import { useDispatch } from 'react-redux'
 
 function Home() {
   const dispatch = useDispatch();
   const [text, setText] = useState("");
 
   function handleClick() {
     dispatch(todosActions.addTodo(text));
     setText("");
   }
 
   function handleChange(e: React.ChangeEvent<HTMLInputElement>) {
     setText(e.target.value);
   }
 
   return (
     <div className="App">
       <header className="App-header">
 
         <input type="text" value={text} onChange={handleChange} />
 
         <button onClick={handleClick}>
           Add New Todo
         </button>
 
         <TodoList />
       </header>
     </div>
   );
 }
 
 export default Home;

Então, quando você quiser fazer uso dos dados armazenados no estado, use o useSelector gancho. Isso leva uma função que seleciona parte do estado para uso no aplicativo. Neste caso, ele define o post variável para a lista atual de todos. Isso é então usado para renderizar um novo item de tarefas para cada entrada em state.todos.

import React from 'react';
 import { useSelector } from 'store'
 
 import { Container, List, ListItem, Title } from './styles'
 
 function TodoList() {
   const posts = useSelector(state => state.todos)
 
   return (
     <Container>
       <List>
         {posts.map(({ id, title }) => (
           <ListItem key={title}>
             <Title>{title} : {id}</Title>
           </ListItem>
         ))}
       </List>
     </Container>
   );
 }
 
 export default TodoList;

Na verdade, você pode criar funções de seletor personalizadas para lidar com isso para você, salvas no /features/ pasta muito parecido com ações e redutores.

Depois de ter tudo configurado e descoberto, você pode querer configurar Redux Devtools, configurar middleware como Redux Logger ou connected-react-routerou instalando um modelo de efeito colateral, como Redux Sagas.

Adicione ao Google Notícias
Neste artigo
  1. O que Redux faz?
  2. Estruturando Seu Projeto
  3. Instalando e Configurando Redux