Redux es un contenedor de estado predecible construido sobre tres principios fundamentales: un almacén único, estado de solo lectura que se cambia solo mediante acciones y reductores puros que calculan el siguiente estado. Los datos fluyen en una sola dirección, lo que hace que los cambios sean rastreables.
1. Single source of truth — the whole app's state lives in ONE store object
2. State is read-only — you never mutate it; you DISPATCH actions to change it
3. Changes via pure reducers — (state, action) => newState, no side effects
// STORE — holds the single state tree
const store = configureStore({ reducer: rootReducer });
// ACTION — a plain object describing what happened
const action = { type: "counter/incremented", payload: 1 };
// REDUCER — pure function: given state + action, returns NEW state
function counterReducer(state = { value: 0 }, action) {
switch (action.type) {
case "counter/incremented":
return { ...state, value: state.value + action.payload }; // new object
default:
return state;
}
}
// DISPATCH — the only way to trigger a change
store.dispatch(action);
// SELECT — read state
store.getState().counter.value;
UI dispatches an ACTION → REDUCER computes new STATE → STORE updates →
subscribed components re-render → user interacts → dispatches the next action
Este flujo estricto unidireccional significa que cada cambio de estado es el resultado de una acción enviada procesada por una función pura: completamente rastreable.
import { useSelector, useDispatch } from "react-redux";
function Counter() {
const count = useSelector(state => state.counter.value); // read
const dispatch = useDispatch();
return <button onClick={() => dispatch(increment())}>{count}</button>; // write
}
Predictability — every change is an explicit, logged action
Debuggability — time-travel debugging, action replay (Redux DevTools)
Testability — pure reducers are trivial to unit test
(Nota: Redux moderno usa Redux Toolkit, que reduce drásticamente el boilerplate mientras conserva estos conceptos.)
Los conceptos principales de Redux —almacén único, acciones, reductores puros, flujo unidireccional— hacen que el estado de la aplicación sea predecible y rastreable, que es su valor principal para aplicaciones grandes.
La comprensión de store/action/reducer/dispatch/select es esencial para las muchas bases de código que usan Redux, y los principios (actualizaciones inmutables, reductores puros, flujo unidireccional) se repiten en casi todas las bibliotecas de estado.
El compromiso es boilerplate, que Redux Toolkit aborda mientras preserva estos fundamentos.