javascript - attribute - title css
Redux: gestión del estado de precarga (2)
Primero, déjame corregir tu ejemplo.
En lugar de
export function initApp () {
return (dispatch) => {
loadPeople()(dispatch);
loadPlanets()(dispatch);
};
}
puedes (y deberías) escribir
export function initApp () {
return (dispatch) => {
dispatch(loadPeople());
dispatch(loadPlanets());
};
}
No es necesario pasar el dispatch
como argumento: el middleware de thunk se ocupa de esto.
Por supuesto, técnicamente su código es válido, pero creo que mi sugerencia es más fácil.
- ¿Cuáles son las mejores prácticas para administrar el estado global de precarga de la aplicación en Redux?
Lo que estás haciendo parece correcto. No hay mejores prácticas específicas.
- ¿Es necesario tener un estado de carga global en la tienda?
No. Como David señala en su respuesta , es mejor que guardes solo el estado necesario.
- ¿Cuál sería una forma escalable de verificar el estado de la aplicación cargada en múltiples componentes de React? No parece correcto incluir el estado Personas y Planeta para contenedores que solo necesitan conocer el estado global de la aplicación y no manejan la renderización de Personas o Planetas. También sería doloroso administrarlo cuando el estado global cargado fuera necesario en múltiples contenedores.
Si le preocupa la duplicación, cree una función de "selector" y colóquela junto a sus reductores:
// Reducer is the default export
export default combineReducers({
planets,
people
});
// Selectors are named exports
export function isAllLoaded(state) {
return state.people.loaded && state.planets.loaded;
}
Ahora puede importar selectores de sus componentes y usarlos en la función mapStateToProps
dentro de cualquier componente:
import { isAllLoaded } from ''../reducers'';
function mapStateToProps(state) {
return {
loaded: isAllLoaded(state),
people: state.people.items,
planets: state.planet.items
};
}
- ¿Dan llamando a otros reductores significa llamar a los reductores anidados?
Sí, la composición del reductor generalmente significa llamar a los reductores anidados.
Por favor, consulte mis videos tutoriales Egghead gratuitos sobre este tema:
Estoy construyendo una aplicación, donde debo precargar datos de people
y planet
( es probable que en el futuro se puedan agregar más requisitos de precarga ) en el lanzamiento de la aplicación. Quiero tener valor en la tienda que represente el estado global de la aplicación como loaded: <boolean>
. El valor solo sería verdadero cuando los requisitos de precarga people.loaded: true
y planet.loaded: true
sean verdaderos. La tienda se vería así:
Store
├── loaded: <Boolean>
├── people:
│ ├── loaded: <Boolean>
│ └── items: []
├── planets:
│ ├── loaded: <Boolean>
│ └── items: []
Los creadores de acciones independientes realizan las solicitudes asincrónicas necesarias y las acciones de despacho que manejan los reductores People
y Planets
. Como se muestra a continuación (usa redux-thunk ):
actions/index.js
import * as types from ''../constants/action-types'';
import {getPeople, getPlanets} from ''../util/swapi'';
export function loadPeople () {
return (dispatch) => {
return getPeople()
.then((people) => dispatch(addPeople(people)));
};
}
export function loadPlanets () {
return (dispatch) => {
return getPlanets()
.then((planets) => dispatch(addPeople(planets)));
};
}
export function addPeople (people) {
return {type: types.ADD_PEOPLE, people};
}
export function addPlanets (planets) {
return {type: types.ADD_PLANETS, planets};
}
export function initApp () {
return (dispatch) => {
loadPeople()(dispatch);
loadPlanets()(dispatch);
};
}
../util/swapi
maneja la búsqueda de datos de personas y planetas desde LocalStorage o realizando una solicitud.
initApp()
creador de acciones initApp()
llama a otros creadores de acciones dentro de site.js
justo antes de renderizar a DOM como se muestra a continuación:
site.js
import React from ''react'';
import {render} from ''react-dom'';
import Root from ''./containers/root'';
import configureStore from ''./store/configure-store'';
import {initApp} from ''./actions'';
const store = configureStore();
// preload data
store.dispatch(initApp());
render(
<Root store={store} />,
document.querySelector(''#root'')
);
1. ¿Cuáles son las mejores prácticas para administrar el estado global de precarga de la aplicación en Redux?
2. ¿Es necesario tener un estado de loaded
global en la tienda?
3. ¿Cuál sería una forma escalable de verificar el estado de la aplicación loaded
en múltiples componentes de React? No parece correcto incluir el estado People
y Planet
para contenedores que solo necesitan conocer el estado global de la aplicación y no manejan la renderización de People
o Planets
. También sería doloroso administrarlo cuando el estado global loaded
fuera necesario en múltiples contenedores.
Citando parte de la respuesta de Dan de Redux: múltiples tiendas, ¿por qué no? pregunta.
El uso de la composición reductora facilita la implementación de "actualizaciones dependientes" a la waitFor en Flux al escribir manualmente un reductor llamando a otros reductores con información adicional y en un orden específico.
4. ¿Dan llamando a otros reductores significa llamar a los reductores anidados?
Una bandera cargada en el estado de tu tienda tiene perfecto sentido.
Sin embargo, tienes demasiados de ellos. Tienes state.people.loaded
, state.planets.loaded
así como state.loaded
. Este último se deriva de los dos primeros. Su tienda realmente no debería contener estado derivado. O tienen solo los dos primeros o solo el último.
Mi recomendación sería mantener los dos primeros, es decir, state.people.loaded
y state.planets.loaded
. Entonces su componente conectado puede derivar un estado cargado final. p.ej
function mapStateToProps(state) {
return {
loaded: state.people.loaded && state.planets.loaded,
people: state.people.items,
planets: state.planet.items
};
}