Javascript 读取存储'；Redux减速器中的s初始状态

Redux应用程序中的初始状态可以通过两种方式设置：

• 将其作为第二个参数传递给

  createStore

  （）
• 将其作为第一个参数传递给您的（子）还原器（）

---

如果将初始状态传递给存储，如何从存储中读取该状态并使其成为还原程序中的第一个参数？

简而言之：将初始状态传递给还原程序的是Redux，您不需要做任何事情

当您调用

createStore（reducer，[initialState]）

时，您让Redux知道当第一个操作进入时要传递给reducer的初始状态是什么

您提到的第二个选项仅适用于创建存储时未传递初始状态的情况。i、 e

函数todoApp（state=initialState，action）

---

只有在Redux未传递状态时，才会初始化状态。我希望这能回答您的请求（我理解为在传递intialState并返回该状态时初始化还原程序）

我们就是这样做的（警告：复制自Typescript代码）

其要点是主减速器（工厂）功能中的

if（！state）

测试

如何从存储中读取该状态，并使其成为减缩器中的第一个参数

combineReducers（）为您完成这项工作。 第一种写它的方法并没有真正的帮助：

const rootReducer = combineReducers({ todos, users })

但另一个，也就是等价物，更清楚：

function rootReducer(state, action) {
   todos: todos(state.todos, action),
   users: users(state.users, action)
}

TL；博士 如果没有

combineReducers（）

或类似的手动代码，

initialState

总是在reducer中胜过

state=…

，因为传递给reducer的

state

是

initialState

而不是

undefined

，因此在这种情况下不会应用ES6参数语法

使用

combineReducers（）

时，行为更加微妙。在

initialState

中指定其状态的减速器将接收该

状态

。其他还原程序将接收

未定义的

，因此将返回到它们指定的

状态=…

默认参数

通常，

initialState

会赢得减速器指定的状态。这允许还原程序将对其有意义的初始数据指定为默认参数，但也允许在从某个持久性存储或服务器对存储进行水合处理时加载现有数据（全部或部分）。

首先，让我们考虑一个单一减速器的情况。 假设您不使用

combineReducers（）

那么您的减速器可能如下所示：

function counter(state = 0, action) {
  switch (action.type) {
  case 'INCREMENT': return state + 1;
  case 'DECREMENT': return state - 1;
  default: return state;
  }
}

// const combined = combineReducers({ a, b })
function combined(state = {}, action) {
  return {
    a: a(state.a, action),
    b: b(state.b, action)
  };
}

现在假设您使用它创建了一个商店

import { createStore } from 'redux';
let store = createStore(counter);
console.log(store.getState()); // 0

初始状态为零。为什么？因为

createStore

的第二个参数是

undefined

。这是第一次传递给减速器的

状态。当Redux初始化时，它会发送一个“虚拟”操作来填充状态。因此，您的
计数器
减速机被调用为
状态
等于
未定义
这正是“激活”默认参数的情况。因此，
state
现在是
0
，与默认的
state
值一致（
state=0
）。将返回此状态（
0
）

让我们考虑一个不同的场景：
import { createStore } from 'redux';
let store = createStore(counter, 42);
console.log(store.getState()); // 42

import { createStore } from 'redux';
let store = createStore(combined, { a: 'horse' });
console.log(store.getState()); // { a: 'horse', b: 'wat' }

为什么这次是
42
，而不是
0
？因为调用
createStore
时使用
42
作为第二个参数。此参数将成为与伪操作一起传递给减速器的
状态这一次，
状态
不是未定义的（它是
42
！），因此ES6默认参数语法无效。状态
是
42
，并且从减速器返回
42


现在让我们考虑一个用例：<代码> CuleReuleReServer（）/<代码>
您有两个减速器：
function a(state = 'lol', action) {
  return state;
}

function b(state = 'wat', action) {
  return state;
}

组合减速机（{a，b}）
生成的减速机如下所示：

function counter(state = 0, action) {
  switch (action.type) {
  case 'INCREMENT': return state + 1;
  case 'DECREMENT': return state - 1;
  default: return state;
  }
}

// const combined = combineReducers({ a, b })
function combined(state = {}, action) {
  return {
    a: a(state.a, action),
    b: b(state.b, action)
  };
}

如果我们调用
createStore
而不调用
initialState
，它将把
状态
初始化为
{}
。因此，
state.a
和
state.b
在调用
a
和
b
减缩器时将
未定义两个
a
和
b
缩减器都将
未定义
作为其
状态
参数，如果它们指定默认
状态
值，则将返回这些值。这就是组合缩减器在第一次调用时返回
{a:'lol'，b:'wat'}
状态对象的方式

import { createStore } from 'redux';
let store = createStore(combined);
console.log(store.getState()); // { a: 'lol', b: 'wat' }

让我们考虑一个不同的场景：
import { createStore } from 'redux';
let store = createStore(counter, 42);
console.log(store.getState()); // 42

import { createStore } from 'redux';
let store = createStore(combined, { a: 'horse' });
console.log(store.getState()); // { a: 'horse', b: 'wat' }

现在我指定
initialState
作为
createStore（）
的参数。从组合减速器返回的状态将为
a
减速器指定的初始状态I与指定
b
减速器自行选择的
'wat'
默认参数组合在一起

让我们回忆一下组合减速器的作用：

// const combined = combineReducers({ a, b })
function combined(state = {}, action) {
  return {
    a: a(state.a, action),
    b: b(state.b, action)
  };
}

在本例中，指定了
状态
，因此它不会返回到
{}
。它是一个对象，其
a
字段等于
'horse'
，但没有
b
字段。这就是为什么
a
减速机将
'horse'
作为其
状态
接收并愉快地返回它，而
b
减速机将
未定义
作为其
状态
接收并因此返回其默认
状态的想法（在我们的示例中，
'wat'
）。这就是我们如何得到
{a:'horse'，b:'wat'}
的回报


综上所述，如果您坚持Redux约定，并在使用
undefined
作为
state
参数调用减缩器时从减缩器返回初始状态（实现这一点的最简单方法是指定
state
ES6默认参数