En rootReducer.js, recuerden importar lo siguiente:
import { combineReducers } from "redux-immutable", desde redux-immutable.
Si importan combineReducers from "redux", les va a arrojar error y perderán 15 minutos de sus vidas.
Separar responsabilidades en Redux mejora la mantenibilidad cuando tu estado crece. Con combineReducers divides tu store en piezas pequeñas que manejan dominios distintos, como datos y UI, evitando un reducer gigante e inmanejable.
¿Por qué conviene dividir el estado en varios reducers?
Cuando tu aplicación crece, mezclar datos del dominio con flags de interfaz en un solo reducer genera archivos imposibles de mantener. Piensa en la vista de una clase de Platzi: ahí conviven tu perfil, el temario del curso, la información de la clase y los aportes de la comunidad. Meter todo eso en un único reducer rompe el principio de separación de responsabilidades.
En el proyecto de pokémons pasa algo similar. El estado tenía dos propiedades muy distintas: pokemons, que es la data que le importa al usuario, y loading, que es un control de UI para mostrar un indicador mientras una acción se ejecuta. Son cosas diferentes y merecen vivir separadas.
¿Qué hace combineReducers en Redux? Es un helper que une varios reducers pequeños en un rootReducer. Cada reducer maneja una porción del estado y combineReducers los expone como propiedades de un mismo objeto.
¿Cómo separar el reducer de data y el reducer de UI?
El primer paso es dividir el archivo original en dos. En el reducer de pokémons te quedas solo con el initialState de la lista y los casos setPokemon y setFavorite. En el reducer de UI conservas únicamente el initialState del loading y el caso setLoading, y lo renombras a uiReducer [02:30].
Luego creas un archivo nuevo llamado rootReducer donde vas a combinar ambos.
¿Por qué usar Redux Immutable en vez de Redux?
Normalmente importarías combineReducers desde redux, pero como el proyecto trabaja con Immutable JS, necesitas una librería específica que entienda esas estructuras. Por eso instalas redux-immutable y desde ahí importas el método [03:45].
El rootReducer queda así:
javascript import { combineReducers } from 'redux-immutable'; import pokemonsReducer from './pokemons'; import uiReducer from './ui';
const rootReducer = combineReducers({ data: pokemonsReducer, ui: uiReducer, });
export default rootReducer;
Cada propiedad del objeto que recibe combineReducers se convierte en una rama de tu estado. Si mañana necesitas un reducer de usuario, solo agregas otra propiedad y listo.
¿Cómo conectar el rootReducer al store?
En tu index.js le pasas el rootReducer a createStore en lugar del reducer suelto de pokémons. Al recargar el navegador y abrir Redux DevTools verás dos propiedades principales: data con la lista de pokémons y ui con el booleano loading [05:30].
¿Cómo acceder al estado cuando hay varios niveles?
Al combinar reducers, el estado gana un nivel extra de profundidad. Antes leías pokemons directo, ahora vive dentro de data. En App.js tienes que actualizar las lecturas con getIn de Immutable, indicando la ruta completa.
getIn(['data', 'pokemons']).getIn(['ui', 'loading'])..get().get() si lo prefieres.Con ese ajuste el loader vuelve a aparecer y la lista de pokémons carga correctamente.
¿Por qué necesitas shallowEqual con useSelector?
Aquí viene lo interesante. useSelector decide si re-renderiza tu componente usando una comparación estricta, ese === que revisa si dos valores son exactamente iguales. Para strings o booleanos compara el valor directo, pero para objetos y arreglos compara referencias, no contenido.
Como trabajas con inmutabilidad, cada cambio crea una referencia nueva aunque los valores internos sean idénticos. Resultado: re-renders innecesarios todo el tiempo.
¿Qué es shallowEqual en React Redux? Es una función que importas desde react-redux y le pasas como segundo argumento a useSelector. Compara los valores de primer nivel del objeto en lugar de la referencia, evitando renders falsos.
Lo aplicas así:
javascript import { useSelector, shallowEqual } from 'react-redux';
const pokemons = useSelector( (state) => state.getIn(['data', 'pokemons']), shallowEqual );
Para el loading no hace falta shallowEqual porque es un booleano y la comparación estricta basta. Solo lo necesitas cuando seleccionas objetos o arreglos [08:45].
¿Es obligatorio usar combineReducers?
No, es totalmente opcional. Puedes manejar todo en un solo reducer si quieres, aunque no se recomienda. combineReducers existe para mejorar la experiencia de desarrollo y aplicar el principio de dividir y vencerás sobre tu estado global.
Con esta separación entre data y UI ya tienes un reducer compuesto limpio, y en la siguiente clase verás cómo Redux Toolkit simplifica todo este flujo mediante slices. ¿Cómo organizas tú los reducers en tus proyectos? Cuéntalo en los comentarios.
Separar responsabilidades en Redux mejora la mantenibilidad cuando tu estado crece. Con combineReducers divides tu store en piezas pequeñas que manejan dominios distintos, como datos y UI, evitando un reducer gigante e inmanejable.
Cuando tu aplicación crece, mezclar datos del dominio con flags de interfaz en un solo reducer genera archivos imposibles de mantener. Piensa en la vista de una clase de Platzi: ahí conviven tu perfil, el temario del curso, la información de la clase y los aportes de la comunidad. Meter todo eso en un único reducer rompe el principio de separación de responsabilidades.
En el proyecto de pokémons pasa algo similar. El estado tenía dos propiedades muy distintas: pokemons, que es la data que le importa al usuario, y loading, que es un control de UI para mostrar un indicador mientras una acción se ejecuta. Son cosas diferentes y merecen vivir separadas.
¿Qué hace combineReducers en Redux? Es un helper que une varios reducers pequeños en un rootReducer. Cada reducer maneja una porción del estado y combineReducers los expone como propiedades de un mismo objeto.
El primer paso es dividir el archivo original en dos. En el reducer de pokémons te quedas solo con el initialState de la lista y los casos setPokemon y setFavorite. En el reducer de UI conservas únicamente el initialState del loading y el caso setLoading, y lo renombras a uiReducer [02:30].
Luego creas un archivo nuevo llamado rootReducer donde vas a combinar ambos.
Normalmente importarías combineReducers desde redux, pero como el proyecto trabaja con Immutable JS, necesitas una librería específica que entienda esas estructuras. Por eso instalas redux-immutable y desde ahí importas el método [03:45].
El rootReducer queda así:
javascript import { combineReducers } from 'redux-immutable'; import pokemonsReducer from './pokemons'; import uiReducer from './ui';
const rootReducer = combineReducers({ data: pokemonsReducer, ui: uiReducer, });
export default rootReducer;
Cada propiedad del objeto que recibe combineReducers se convierte en una rama de tu estado. Si mañana necesitas un reducer de usuario, solo agregas otra propiedad y listo.
En tu index.js le pasas el rootReducer a createStore en lugar del reducer suelto de pokémons. Al recargar el navegador y abrir Redux DevTools verás dos propiedades principales: data con la lista de pokémons y ui con el booleano loading [05:30].
Al combinar reducers, el estado gana un nivel extra de profundidad. Antes leías pokemons directo, ahora vive dentro de data. En App.js tienes que actualizar las lecturas con getIn de Immutable, indicando la ruta completa.
getIn(['data', 'pokemons']).getIn(['ui', 'loading'])..get().get() si lo prefieres.Con ese ajuste el loader vuelve a aparecer y la lista de pokémons carga correctamente.
Aquí viene lo interesante. useSelector decide si re-renderiza tu componente usando una comparación estricta, ese === que revisa si dos valores son exactamente iguales. Para strings o booleanos compara el valor directo, pero para objetos y arreglos compara referencias, no contenido.
Como trabajas con inmutabilidad, cada cambio crea una referencia nueva aunque los valores internos sean idénticos. Resultado: re-renders innecesarios todo el tiempo.
¿Qué es shallowEqual en React Redux? Es una función que importas desde react-redux y le pasas como segundo argumento a useSelector. Compara los valores de primer nivel del objeto en lugar de la referencia, evitando renders falsos.
Lo aplicas así:
javascript import { useSelector, shallowEqual } from 'react-redux';
const pokemons = useSelector( (state) => state.getIn(['data', 'pokemons']), shallowEqual );
Para el loading no hace falta shallowEqual porque es un booleano y la comparación estricta basta. Solo lo necesitas cuando seleccionas objetos o arreglos [08:45].
No, es totalmente opcional. Puedes manejar todo en un solo reducer si quieres, aunque no se recomienda. combineReducers existe para mejorar la experiencia de desarrollo y aplicar el principio de dividir y vencerás sobre tu estado global.
Con esta separación entre data y UI ya tienes un reducer compuesto limpio, y en la siguiente clase verás cómo Redux Toolkit simplifica todo este flujo mediante slices. ¿Cómo organizas tú los reducers en tus proyectos? Cuéntalo en los comentarios.
En rootReducer.js, recuerden importar lo siguiente:
import { combineReducers } from "redux-immutable", desde redux-immutable.
Si importan combineReducers from "redux", les va a arrojar error y perderán 15 minutos de sus vidas.
Se supone que JS fuera mas fácil pero veo que cada vez se vuelve mas y mas difícil de entender que triste
npm install redux-immutable
shallowEqual vs. Comparación a Profundidad en JavaScriptSupongamos que tenemos dos objetos de Pokémon:
const pokemon1 = { nombre: "Pikachu", tipo: "Eléctrico" };
const pokemon2 = { nombre: "Pikachu", tipo: "Eléctrico" };
Ahora, si utilizamos shallowEqual para compararlos:
import { shallowEqual } from 'react-redux';
console.log(shallowEqual(pokemon1, pokemon2)); // true
En este caso, shallowEqual compara las propiedades de nivel superior de los objetos pokemon1 y pokemon2, que son nombre y tipo. Como ambas propiedades tienen los mismos valores, la comparación devuelve true.
Sin embargo, si comparamos los mismos objetos directamente con una comparación a profundidad utilizando el operador :
===console.log(pokemon1 === pokemon2); // false
La comparación a profundidad verifica si los objetos son idénticos en estructura y valor, incluyendo todas las propiedades anidadas. A pesar de que las propiedades nombre y tipo tienen los mismos valores en ambos objetos, la comparación a profundidad devuelve false porque los objetos en sí no son idénticos en estructura. son dos objetos diferentes
.
shallowEqual es útil cuando solo necesitas comparar las propiedades de nivel superior de objetos, evitando renders innecesarios en componentes de React al utilizar Redux. Si necesitas comparar objetos en su totalidad, incluyendo propiedades anidadas, una comparación a profundidad es necesaria.
No entendí lo de shallowEqual. Cuando hay que usarlo?
Combinar reducers es opcional y puede mejorar la experiencia de desarrollo. Sin embargo, eres libre de manejar todo con 1 solo reducer (aunque no es recomendable).
Usaremos redux-immutable
primero se crea una carpeta de reducer, en esa creamos el archivo index o la raiz de todos los reducer combinados
reducer independientes
//pokemons.jsx
import { SET_ERROR, SET_POKEMONS, SET_FAVORITE } from "../actions/types";
import { fromJS, get, setIn } from "immutable";
const initialState = fromJS({
pokemons: [],
loading: true,
});
export const pokemonsReducer = (state = initialState, action) => {
switch (action.type) {
case SET_POKEMONS:
const pokemonsUpdated = setIn(
state,
["pokemons"],
fromJS(action.payload)
);
return pokemonsUpdated.set(["loading"], false);
case SET_FAVORITE:
const pokemonFoundIndex = get(state, "pokemons").findIndex((pkm) => {
const pkmon = pkm.toJS().id;
return pkmon == action.payload.id;
});
console.log(pokemonFoundIndex, action.payload.id);
if (pokemonFoundIndex < 0) return state;
const isFavorite = get(state, [
"pokemons",
pokemonFoundIndex,
"isFavorite",
]);
return setIn(
state,
["pokemons", pokemonFoundIndex, "isFavorite"],
!isFavorite
);
default:
return state;
}
};
//iu.jsx
import { SET_ERROR, SET_POKEMONS,SET_FAVORITE } from "../actions/types";
import {fromJS, get, set, setIn} from 'immutable'
const initialState = fromJS({
error:false
});
export const uiReducer = (state = initialState, action) => {
switch (action.type) {
case SET_ERROR:
return state.set(['error'],action.payload);
default:
return state;
}
};
// const
IndexReducers o el rootReducer
import {combineReducers} from 'redux-immutable';
import { uiReducer } from './iu';
import { pokemonsReducer } from './pokemons';
//como estamos utilicemmos la libreria de immutable, para
// usar reducer combinados, necesitamos instalar redux-immutable
const rootReducer= combineReducers({
data:pokemonsReducer,
ui: uiReducer
})
export default rootReducer;
ahora pasamos al index de nuestra app y mandamos el reducer que combina el resto
import React from "react";
import ReactDOM from "react-dom/client";
import App from "./App";
import { Provider } from "react-redux";
import thunk from 'redux-thunk'
import { applyMiddleware, compose, legacy_createStore as createStore } from "redux";
import { loger } from "./middlewares";
import rootReducer from "./reducers/rootReducer";
const composeAlt = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;
const componoseEnjencer = composeAlt(applyMiddleware(thunk,loger));
const store = createStore(rootReducer,componoseEnjencer);
ReactDOM.createRoot(document.getElementById("root")).render(
<Provider store={store}>
<React.StrictMode>
<App />
</React.StrictMode>
</Provider>
);
como estamos usando immutable js necesitamos reacomodar en donde utilizamos nuestro estado
import { Searched } from "./components/Searched";
import { shallowEqual, useDispatch, useSelector } from "react-redux";
import { Col, Row } from "antd";
import "./App.css";
import { getPokemonWithDetails, setPokemons } from "./actions";
import { PokemonList } from "./components/PokemonList";
// import { usePokeApi } from './hooks/usePokeApi';
import { PokeSkeleton } from "./components/PokeSkeleton";
import { useEffect } from "react";
import { getPokemonDetails, getPokemons } from "./services/PokeApi";
import { get } from "immutable";
function App() {
const state = useSelector((state) => state.get('data',shallowEqual).toJS());
//la funcion shadow equal ayuda a verificar si el estado ha cambiado
// y si no cambio no hara render innecesarios, es decir, no hara rerender
const dispatch = useDispatch();
const { pokemons,loading} = state
useEffect(() => {
getPokemons()
.then(pkmos=>dispatch(getPokemonWithDetails(pkmos.results)))
.catch(err=>console.log(err));
}, []);
return (
<div className="app">
<Col span={4} offset={10} style={{ marginBottom: 30 }}>
<img
src="https://static.platzi.com/media/tmp/class-files/github/curso-redux/curso-redux-01-pokeapi/src/statics/logo.svg"
alt="pokedux"
/>
</Col>
<Col span={8} offset={8}>
<Searched />
</Col>
<Row style={{ marginTop: 50 }} justify={"center"} gutter={20}>
{loading ? <PokeSkeleton /> : <PokemonList pokemons={pokemons} />}
</Row>
</div>
);
}
export default App;
La inmutabilidad asegura que el estado de tu aplicación sea predecible y eficiente. Al no modificar los datos originales, facilitas el rastreo de cambios y optimizas el renderizado en frameworks como React.
npm install immutableMap: Para objetos {}.List: Para arreglos [].fromJS(): Conversión profunda de JS plano a inmutable.toJS(): Conversión de inmutable a JS plano (usar con moderación por su costo).getIn(['path', 'to', 'key']): Acceso seguro a datos anidados. Si la ruta no existe, devuelve undefined en lugar de romper la app.setIn(['path'], value): Crea una nueva versión con el dato actualizado.findIndex(): Localiza la posición de un elemento en una List.Immutable.is()A diferencia de ===, que compara si dos objetos están en la misma dirección de memoria, is() compara si el contenido es idéntico.
import { Map, is } from 'immutable';
const mapA = Map({ a: 1, b: 2 });
const mapB = Map({ a: 1, b: 2 });
console.log(mapA === mapB); // false (instancias diferentes)
console.log(is(mapA, mapB)); // true (contenido idéntico)
// Caso de uso: Evita re-renders innecesarios en React.
withMutations()Si aplicas muchos cambios seguidos, hacer copias intermedias es lento. withMutations crea un estado "temporalmente mutable" para agrupar todo en una sola operación final.
import { List } from 'immutable';
const listaOriginal = List([1, 2, 3]);
const listaOptimizada = listaOriginal.withMutations(mutable => {
for (let i = 4; i <= 100; i++) {
mutable.push(i); // No crea copias intermedias aquí
}
});
A medida que la app crece, un solo "monolito" de estado es inmanejable. Aplicamos "Divide y Vencerás".
data para pokémones, ui para loaders).redux-immutable: Cuando usas ImmutableJS, debes usar el combineReducers de esta librería para que el estado global sea un Mapa Inmutable y no un objeto JS plano.import { combineReducers } from 'redux-immutable';
const rootReducer = combineReducers({
data: pokemonsReducer,
ui: uiReducer,
});
useSelectorEl hook useSelector lanza un re-render si el valor retornado cambia (por referencia).
===): Es la que viene por defecto. Si el selector devuelve una nueva estructura (como un .toJS()), el componente siempre se volverá a renderizar.shallowEqual: Realiza una comparación superficial de las propiedades.import { useSelector, shallowEqual } from 'react-redux';
// Uso correcto con shallowEqual para evitar renders infinitos
const pokemons = useSelector(state => state.getIn(['data', 'pokemons']), shallowEqual);
Immutable.is y shallowEqual, tus componentes solo se pintan cuando la información realmente cambia.Es más una reflexión según lo que entendí de esta clase...
Antes en la clase 18 cuando usamos por primera vez la librería immutable, también debimos usar el shallowEqual debido a que estamos regresando una referencia distinta cada vez que consultamos el estado con useSelector ya que si el estado cambiaba o no cambiaba, la referencia es siempre distinta. Sin immutable no había problema porque a pesar de regresar referencias distintas Redux aquí compara valores, no referencias. Por supuesto, sin immutable habría que desestructurar los niveles de profundidad que pudieran existir en alguna de las propiedades de nuestro estado.
Así queda con TS:
// app/types/reducerTypes.ts
import { Map } from 'immutable';
import type { SET_LOADING, SET_POKEMONS, SET_FAVOURITE } from './actionTypes';
import type { PokeDetail } from './pokeTypes';
export interface PokemonSchema {
pokemons: PokeDetail[];
}
export type PokemonState = Map<keyof PokemonSchema, any>;
export interface LoadingSchema {
loading: boolean;
}
export type LoadingState = Map<keyof LoadingSchema, any>;
export interface SetPokemonAction {
type: typeof SET_POKEMONS;
payload: PokeDetail[];
}
export interface SetLoadingAction {
type: typeof SET_LOADING;
payload: boolean;
}
export interface SetFavouriteAction {
type: typeof SET_FAVOURITE;
payload: number;
}
export type PokemonAction = SetPokemonAction | SetFavouriteAction;
// app/reducers/pokemonsReducer.ts
import { fromJS } from 'immutable';
import { SET_LOADING, SET_POKEMONS, SET_FAVOURITE } from '~/types/actionTypes';
import type { PokemonAction, PokemonState } from '~/types/reducerTypes';
const initialState: PokemonState = fromJS({
pokemons: [],
});
export const pokemonsReducer = (
state: PokemonState = initialState,
action: PokemonAction,
) => {
switch (action.type) {
case SET_POKEMONS:
return state.setIn(['pokemons'], fromJS(action.payload));
case SET_FAVOURITE:
const currenPokeIndex = state
.get('pokemons')
.findIndex((pokemon: any) => pokemon.get('id') === action.payload);
if (currenPokeIndex === -1) return state;
const isFavourite = state.getIn([
'pokemons',
currenPokeIndex,
'favourite',
]);
return state.setIn(
['pokemons', currenPokeIndex, 'favourite'],
!isFavourite,
);
default:
return state;
}
};
// app/reducers/uiReducer.ts
import { fromJS } from 'immutable';
import { SET_LOADING } from '~/types/actionTypes';
import type { LoadingState, SetLoadingAction } from '~/types/reducerTypes';
const initialState: LoadingState = fromJS({
loading: false,
});
export const uiReducer = (
state: LoadingState = initialState,
action: SetLoadingAction,
) => {
switch (action.type) {
case SET_LOADING:
return state.update('loading', (value) => !value);
default:
return state;
}
};
// app/reducers/rootReducer.ts
import { combineReducers } from '@reduxjs/toolkit';
import { pokemonsReducer } from './pokemonsReducer';
import { uiReducer } from './uiReducer';
export const rootReducer = combineReducers({
data: pokemonsReducer,
ui: uiReducer,
});
export type RootState = ReturnType<typeof rootReducer>;
// app/welcome/welcome.tsx
import { useEffect } from 'react';
import { Col, Spin } from 'antd';
import { shallowEqual, useDispatch, useSelector } from 'react-redux';
import logo from '../statics/logo.svg';
import { PokeList } from '~/components/PokeList';
import { Searcher } from '~/components/Searcher';
import { getPokemon } from '~/api/getPokemon';
import { getPokemonDetails } from '~/api/getPokemonDetails';
import { type AppDispatch } from '~/store/store';
import { getPokemonsWithDetails, setLoading } from '~/actions';
import { type RootState } from '~/reducers/rootReducer';
export function Welcome() {
const pokemons = useSelector(
(state: RootState) => state.data.get('pokemons'),
shallowEqual,
).toJS();
const loading = useSelector((state: RootState) => state.ui.get('loading'));
const dispatch = useDispatch<AppDispatch>();
useEffect(() => {
const fetchPokemons = async () => {
dispatch(setLoading(true));
const pokeRes = await getPokemon();
if (pokeRes) {
dispatch(getPokemonsWithDetails(pokeRes));
}
dispatch(setLoading(false));
};
fetchPokemons();
}, [getPokemon, getPokemonsWithDetails, getPokemonDetails]);
return (
<main>
<h1>Pokedux</h1>
<Col span={4} offset={10} className='my-3'>
<img src={logo} alt='Pokedux' />
</Col>
<Col span={8} offset={8} className='mt-3'>
<Searcher />
</Col>
{loading ? (
<Col offset={12}>
<Spin spinning size='large' className='mt-3' />
</Col>
) : (
pokemons && <PokeList pokemons={pokemons} />
)}
</main>
);
}