Redux 莞式教程 之 进阶篇

时间  2019-11-05
标签 redux 教程 进阶 繁體版
原文   原文链接

Redux 进阶教程

原文（保持更新）：https://github.com/kenberkele...css

写在前面

相信您已经看过 Redux 简明教程，本教程是简明教程的实战化版本，伴随源码分析
Redux 用的是 ES6 编写，看到有疑惑的地方的，能够复制粘贴到这里在线编译 ES5html

§ Redux API 总览

在 Redux 的源码目录 src/，咱们能够看到以下文件结构：react

├── utils/
│     ├── warning.js # 打酱油的，负责在控制台显示警告信息
├── applyMiddleware.js
├── bindActionCreators.js
├── combineReducers.js
├── compose.js
├── createStore.js
├── index.js # 入口文件

除去打酱油的 utils/warning.js 以及入口文件 index.js，剩下那 5 个就是 Redux 的 APIgit

§ compose(...functions)

先说这个 API 的缘由是它没有依赖，是一个纯函数github

⊙ 源码分析

/**
 * 看起来逼格很高，实际运用实际上是这样子的：
 * compose(f, g, h)(...arg) => f(g(h(...args)))
 *
 * 值得注意的是，它用到了 reduceRight，所以执行顺序是从右到左
 *
 * @param  {多个函数，用逗号隔开}
 * @return {函数}
 */

export default function compose(...funcs) {
  if (funcs.length === 0) {
    return arg => arg
  }

  if (funcs.length === 1) {
    return funcs[0]
  }

  const last = funcs[funcs.length - 1]
  const rest = funcs.slice(0, -1)
  return (...args) => rest.reduceRight((composed, f) => f(composed), last(...args))
}

这里的关键点在于，reduceRight 可传入初始值：编程

// 因为 reduce / reduceRight 仅仅是方向的不一样，所以下面用 reduce 说明便可
var arr = [1, 2, 3, 4, 5]

var re1 = arr.reduce(function(total, i) {
  return total + i
})
console.log(re1) // 15

var re2 = arr.reduce(function(total, i) {
  return total + i
}, 100) // <---------------传入一个初始值
console.log(re2) // 115

下面是 compose 的实例（在线演示）：redux

<!DOCTYPE html>
<html>
<head>
  <script src="//cdn.bootcss.com/redux/3.5.2/redux.min.js"></script>
</head>
<body>
<script>
function func1(num) {
  console.log('func1 得到参数 ' + num);
  return num + 1;
}

function func2(num) {
  console.log('func2 得到参数 ' + num);
  return num + 2;
}
  
function func3(num) {
  console.log('func3 得到参数 ' + num);
  return num + 3;
}

// 有点难看（若是函数名再长一点，那屏幕就不够宽了）
var re1 = func3(func2(func1(0)));
console.log('re1：' + re1);

console.log('===============');

// 很优雅
var re2 = Redux.compose(func3, func2, func1)(0);
console.log('re2：' + re2);
</script>
</body>
</html>

控制台输出：后端

func1 得到参数 0
func2 得到参数 1
func3 得到参数 3
re1：6
===============
func1 得到参数 0
func2 得到参数 1
func3 得到参数 3
re2：6

§ createStore(reducer, initialState, enhancer)

⊙ 源码分析

import isPlainObject from 'lodash/isPlainObject'
import $$observable from 'symbol-observable'

/**
 * 这是 Redux 的私有 action 常量
 * 长得太丑了，你不要鸟就好了
 */
export var ActionTypes = {
  INIT: '@@redux/INIT'
}

/**
 * @param  {函数}  reducer 很少解释了
 * @param  {对象}  preloadedState 主要用于先后端同构时的数据同步
 * @param  {函数}  enhancer 很牛逼，能够实现中间件、时间旅行，持久化等
 * ※ Redux 仅提供 appleMiddleware 这个 Store Enhancer ※
 * @return {Store}
 */
export default function createStore(reducer, preloadedState, enhancer) {
  // 这里省略的代码，到本文的最后再讲述（用于压轴你懂的）
  
  var currentReducer = reducer
  var currentState = preloadedState //     这就是整个应用的 state
  var currentListeners = [] //             用于存储订阅的回调函数，dispatch 后逐个执行
  var nextListeners = currentListeners // 【悬念1：为何须要两个 存放回调函数 的变量？】
  var isDispatching = false

  /**
   * 【悬念1·解疑】
   * 试想，dispatch 后，回调函数正在乖乖地被逐个执行（for 循环进行时）
   * 假设回调函数队列本来是这样的 [a, b, c, d]
   *
   * 如今 for 循环执行到第 3 步，亦即 a、b 已经被执行，准备执行 c
   * 但在这电光火石的瞬间，a 被取消订阅！！！
   *
   * 那么此时回调函数队列就变成了 [b, c, d]
   * 那么第 3 步就对应换成了 d！！！
   * c 被跳过了！！！这就是躺枪。。。
   * 
   * 做为一个回调函数，最大的耻辱就是得不到执行
   * 所以为了不这个问题，本函数会在上述场景中把
   * currentListeners 复制给 nextListeners
   *
   * 这样的话，dispatch 后，在逐个执行回调函数的过程当中
   * 若是有新增订阅或取消订阅，都在 nextListeners 中操做
   * 让 currentListeners 中的回调函数得以完整地执行
   *
   * 既然新增是在 nextListeners 中 push，所以毫无疑问
   * 新的回调函数不会在本次 currentListeners 的循环体中被触发
   *
   * （上述事件发生的概率虽然很低，但仍是严谨点比较好）
   */
  function ensureCanMutateNextListeners() { // <-------这货就叫作【ensure 哥】吧
    if (nextListeners === currentListeners) {
      nextListeners = currentListeners.slice()
    }
  }

  /**
   * 返回 state
   */
  function getState() {
    return currentState
  }

  /**
   * 负责注册回调函数的老司机
   * 
   * 这里须要注意的就是，回调函数中若是须要获取 state
   * 那每次获取都请使用 getState()，而不是开头用一个变量缓存住它
   * 由于回调函数执行期间，有可能有连续几个 dispatch 让 state 改得物是人非
   * 并且别忘了，dispatch 以后，整个 state 是被彻底替换掉的
   * 你缓存的 state 指向的可能已是老掉牙的 state 了！！！
   *
   * @param  {函数} 想要订阅的回调函数
   * @return {函数} 取消订阅的函数
   */
  function subscribe(listener) {
    if (typeof listener !== 'function') {
      throw new Error('Expected listener to be a function.')
    }

    var isSubscribed = true

    ensureCanMutateNextListeners() // 调用 ensure 哥保平安
    nextListeners.push(listener)   // 新增订阅在 nextListeners 中操做

    // 返回一个取消订阅的函数
    return function unsubscribe() {
      if (!isSubscribed) {
        return
      }

      isSubscribed = false

      ensureCanMutateNextListeners() // 调用 ensure 哥保平安
      var index = nextListeners.indexOf(listener)
      nextListeners.splice(index, 1) // 取消订阅仍是在 nextListeners 中操做
    }
  }

  /**
   * 改变应用状态 state 的不二法门：dispatch 一个 action
   * 内部的实现是：往 reducer 中传入 currentState 以及 action
   * 用其返回值替换 currentState，最后逐个触发回调函数
   *
   * 若是 dispatch 的不是一个对象类型的 action（同步的），而是 Promise / thunk（异步的）
   * 则需引入 redux-thunk 等中间件来反转控制权【悬念2：什么是反转控制权？】
   * 
   * @param & @return {对象} action
   */
  function dispatch(action) {
    if (!isPlainObject(action)) {
      throw new Error(
        'Actions must be plain objects. ' +
        'Use custom middleware for async actions.'
      )
    }

    if (typeof action.type === 'undefined') {
      throw new Error(
        'Actions may not have an undefined "type" property. ' +
        'Have you misspelled a constant?'
      )
    }

    if (isDispatching) {
      throw new Error('Reducers may not dispatch actions.')
    }

    try {
      isDispatching = true
      // 关键点：currentState 与 action 会流通到全部的 reducer
      // 全部 reducer 的返回值整合后，替换掉当前的 currentState
      currentState = currentReducer(currentState, action)
    } finally {
      isDispatching = false
    }

    // 令 currentListeners 等于 nextListeners，表示正在逐个执行回调函数（这就是上面 ensure 哥的断定条件）
    var listeners = currentListeners = nextListeners

    // 逐个触发回调函数。这里不缓存数组长度是明智的，缘由见【悬念1·解疑】
    for (var i = 0; i < listeners.length; i++) {
      listeners[i]()
    }

    return action // 为了方便链式调用，dispatch 执行完毕后，返回 action（下文会提到的，稍微记住就行了）
  }

  /**
   * 替换当前 reducer 的老司机
   * 主要用于代码分离按需加载、热替换等状况
   *
   * @param {函数} nextReducer
   */
  function replaceReducer(nextReducer) {
    if (typeof nextReducer !== 'function') {
      throw new Error('Expected the nextReducer to be a function.')
    }

    currentReducer = nextReducer //         就是这么简单粗暴！
    dispatch({ type: ActionTypes.INIT }) // 触发生成新的 state 树
  }

  /**
   * 这是留给 可观察/响应式库 的接口（详情 https://github.com/zenparsing/es-observable）
   * 若是您了解 RxJS 等响应式编程库，那可能会用到这个接口，不然请略过
   * @return {observable}
   */
  function observable() {略}

  // 这里 dispatch 只是为了生成 应用初始状态
  dispatch({ type: ActionTypes.INIT })

  return {
    dispatch,
    subscribe,
    getState,
    replaceReducer,
    [$$observable]: observable
  }
}

【悬念2：什么是反转控制权？ · 解疑】
在同步场景下，dispatch(action) 的这个 action 中的数据是同步获取的，并无控制权的切换问题
但异步场景下，则须要将 dispatch 传入到回调函数。待异步操做完成后，回调函数自行调用 dispatch(action) api

说白了：在异步 Action Creator 中自行调用 dispatch 就至关于反转控制权
您彻底能够本身实现，也能够借助 redux-thunk / redux-promise 等中间件统一实现
（它们的做用也仅仅就是把 dispatch 等传入异步 Action Creator 罢了）数组

拓展阅读：阮老师的 Thunk 函数的含义与用法
题外话：您不以为 JavaScript 的回调函数，就是反转控制权最广泛的体现吗？

§ combineReducers(reducers)

⊙ 应用场景

简明教程中的 code-7 以下：

/** 本代码块记为 code-7 **/
var initState = {
  counter: 0,
  todos: []
}

function reducer(state, action) {
  if (!state) state = initState
  
  switch (action.type) {
    case 'ADD_TODO':
      var nextState = _.deepClone(state) // 用到了 lodash 的深克隆
      nextState.todos.push(action.payload) 
      return nextState

    default:
      return state
  }
}

上面的 reducer 仅仅是实现了 “新增待办事项” 的 state 的处理
咱们还有计数器的功能，下面咱们继续增长计数器 “增长 1” 的功能：

/** 本代码块记为 code-8 **/
var initState = { counter: 0, todos: [] }

function reducer(state, action) {
  if (!state) return initState // 如果初始化可当即返回应用初始状态
  var nextState = _.deepClone(state) // 不然二话不说先克隆
  
  switch (action.type) {
    case 'ADD_TODO': // 新增待办事项
      nextState.todos.push(action.payload) 
      break   
    case 'INCREMENT': // 计数器加 1
      nextState.counter = nextState.counter + 1
      break
  }
  return nextState
}

若是说还有其余的动做，都须要在 code-8 这个 reducer 中继续堆砌处理逻辑
但咱们知道，计数器 与 待办事项 属于两个不一样的模块，不该该都堆在一块儿写
若是以后又要引入新的模块（例如留言板），该 reducer 会愈来愈臃肿
此时就是 combineReducers 大显身手的时刻：

目录结构以下
reducers/
   ├── index.js
   ├── counterReducer.js
   ├── todosReducer.js
/** 本代码块记为 code-9 **/
/* reducers/index.js */
import { combineReducers } from 'redux'
import counterReducer from './counterReducer'
import todosReducer from './todosReducer'

const rootReducer = combineReducers({
  counter: counterReducer, // <-------- 键名就是该 reducer 对应管理的 state
  todos: todosReducer
})

export default rootReducer

-------------------------------------------------

/* reducers/counterReducer.js */
export default function counterReducer(counter = 0, action) { // 传入的 state 实际上是 state.counter
  switch (action.type) {
    case 'INCREMENT':
      return counter + 1 // counter 是值传递，所以能够直接返回一个值
    default:
      return counter
  }
}

-------------------------------------------------

/* reducers/todosReducers */
export default function todosReducer(todos = [], action) { // 传入的 state 实际上是 state.todos
  switch (action.type) {
    case 'ADD_TODO':
      return [ ...todos, action.payload ]
    default:
      return todos
  }
}

code-8 reducer 与 code-9 rootReducer 的功能是同样的，但后者的各个子 reducer 仅维护对应的那部分 state
其可操做性、可维护性、可扩展性大大加强

Flux 中是根据不一样的功能拆分出多个 store 分而治之
而 Redux 只容许应用中有惟一的 store，经过拆分出多个 reducer 分别管理对应的 state

下面继续来深刻使用 combineReducers。一直以来咱们的应用状态都是只有两层，以下所示：

state
  ├── counter: 0
  ├── todos: []

若是说如今又有一个需求：在待办事项模块中，存储用户每次操做（增删改）的时间，那么此时应用初始状态树应为：

state
  ├── counter: 0
  ├── todo
        ├── optTime: []
        ├── todoList: [] # 这其实就是原来的 todos！

那么对应的 reducer 就是：

目录结构以下
reducers/
   ├── index.js <-------------- combineReducers (生成 rootReducer)
   ├── counterReducer.js
   ├── todoReducers/ <--------- combineReducers
           ├── index.js
           ├── optTimeReducer.js
           ├── todoListReducer.js
/* reducers/index.js */
import { combineReducers } from 'redux'
import counterReducer from './counterReducer'
import todoReducers from './todoReducers/'

const rootReducer = combineReducers({
  counter: counterReducer,
  todo: todoReducers
})

export default rootReducer

=================================================

/* reducers/todoReducers/index.js */
import { combineReducers } from 'redux'
import optTimeReducer from './optTimeReducer'
import todoListReducer from './todoListReducer'

const todoReducers = combineReducers({
  optTime: optTimeReducer,
  todoList: todoListReducer
})

export default todoReducers

-------------------------------------------------

/* reducers/todosReducers/optTimeReducer.js */
export default function optTimeReducer(optTime = [], action) {
  // 咦？这里怎么没有 switch-case 分支？谁说 reducer 就必定包含 switch-case 分支的？
  return action.type.includes('TODO') ? [ ...optTime, new Date() ] : optTime
}

-------------------------------------------------

/* reducers/todosReducers/todoListReducer.js */
export default function todoListReducer(todoList = [], action) {
  switch (action.type) {
    case 'ADD_TODO':
      return [ ...todoList, action.payload ]
    default:
      return todoList
  }
}

不管您的应用状态树有多么的复杂，均可以经过逐层下分管理对应部分的 state：

counterReducer(counter, action) -------------------- counter
                              ↗                                                              ↘
rootReducer(state, action) —→∑     ↗ optTimeReducer(optTime, action) ------ optTime ↘         nextState
                              ↘—→∑                                                    todo  ↗
                                   ↘ todoListReducer(todoList,action) ----- todoList ↗


注：左侧表示 dispatch 分发流，∑ 表示 combineReducers；右侧表示各实体 reducer 的返回值，最后汇总整合成 nextState

看了上图，您应该能直观感觉到为什么取名为 reducer 了吧？把 state 分而治之，极大减轻开发与维护的难度

不管是 dispatch 哪一个 action，都会流通全部的 reducer
表面上看来，这样子很浪费性能，但 JavaScript 对于这种纯函数的调用是很高效率的，所以请尽管放心
这也是为什么 reducer 必须返回其对应的 state 的缘由。不然整合状态树时，该 reducer 对应的键名就是 undefined

⊙ 源码分析

仅截取关键部分，毕竟有很大一部分都是类型检测警告

function combineReducers(reducers) {
  var reducerKeys = Object.keys(reducers)
  var finalReducers = {}
  
  for (var i = 0; i < reducerKeys.length; i++) {
    var key = reducerKeys[i]
    if (typeof reducers[key] === 'function') {
      finalReducers[key] = reducers[key]
    }
  }

  var finalReducerKeys = Object.keys(finalReducers)

  // 返回合成后的 reducer
  return function combination(state = {}, action) {
    var hasChanged = false
    var nextState = {}
    for (var i = 0; i < finalReducerKeys.length; i++) {
      var key = finalReducerKeys[i]
      var reducer = finalReducers[key]
      var previousStateForKey = state[key]                       // 获取当前子 state
      var nextStateForKey = reducer(previousStateForKey, action) // 执行各子 reducer 中获取子 nextState
      nextState[key] = nextStateForKey                           // 将子 nextState 挂载到对应的键名
      hasChanged = hasChanged || nextStateForKey !== previousStateForKey
    }
    return hasChanged ? nextState : state
  }
}

在此个人注释不多，由于代码写得实在是太过明了了，注释反而影响阅读
做者 Dan 用了大量的 for 循环，的确有点不够优雅

§ bindActionCreators(actionCreators, dispatch)

这个 API 有点鸡肋，它无非就是作了这件事情：dispatch(ActionCreator(XXX))

⊙ 源码分析

/* 为 Action Creator 加装上自动 dispatch 技能 */
function bindActionCreator(actionCreator, dispatch) {
  return (...args) => dispatch(actionCreator(...args))
}

export default function bindActionCreators(actionCreators, dispatch) {
  // 省去一大坨类型判断
  var keys = Object.keys(actionCreators)
  var boundActionCreators = {}
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i]
    var actionCreator = actionCreators[key]
    if (typeof actionCreator === 'function') {
      // 逐个装上自动 dispatch 技能
      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch)
    }
  }
  return boundActionCreators
}

⊙ 应用场景

简明教程中的 code-5 以下：

<--! 本代码块记为 code-5 -->
<input id="todoInput" type="text" />
<button id="btn">提交</button>

<script>
$('#btn').on('click', function() {
  var content = $('#todoInput').val() // 获取输入框的值
  var action = addTodo(content) // 执行 Action Creator 得到 action
  store.dispatch(action) // 手动显式 dispatch 一个 action
})
</script>

咱们看到，调用 addTodo 这个 Action Creator 后获得一个 action，以后又要手动 dispatch(action)
若是是只有一个两个 Action Creator 仍是能够接受，但若是有不少个那就显得有点重复了（其实我以为不重复哈哈哈）
这个时候咱们就能够利用 bindActionCreators 实现自动 dispatch：

<input id="todoInput" type="text" />
<button id="btn">提交</button>

<script>
// 全局引入 Redux、jQuery，同时 store 是全局变量
var actionsCreators = Redux.bindActionCreators(
  { addTodo: addTodo },
  store.dispatch // 传入 dispatch 函数
)

$('#btn').on('click', function() {
  var content = $('#todoInput').val()
  actionCreators.addTodo(content) // 它会自动 dispatch
})
</script>

综上，这个 API 没啥卵用，尤为是异步场景下，基本用不上

§ applyMiddleware(...middlewares)

Redux 中文文档 高级 · Middleware 有提到中间件的演化由来

首先要理解何谓 Middleware，何谓 Enhancer

⊙ Middleware

说白了，Redux 引入中间件机制，其实就是为了在 dispatch 先后，统一“作爱作的事”。。。
诸如统一的日志记录、引入 thunk 统一处理异步 Action Creator 等都属于中间件
下面是一个简单的打印动做先后 state 的中间件：

/* 装逼写法 */
const printStateMiddleware = ({ getState }) => next => action => {
  console.log('state before dispatch', getState())
  
  let returnValue = next(action)

  console.log('state after dispatch', getState())

  return returnValue
}

-------------------------------------------------

/* 下降逼格写法 */
function printStateMiddleware(middlewareAPI) { // 记为【锚点-1】，中间件内可用的 API
  return function (dispatch) {                 // 记为【锚点-2】，传入原 dispatch 的引用
    return function (action) {
      console.log('state before dispatch', middlewareAPI.getState())
  
      var returnValue = dispatch(action) // 还记得吗，dispatch 的返回值其实仍是 action
  
      console.log('state after dispatch', middlewareAPI.getState())

      return returnValue // 继续传给下一个中间件做为参数 action
    }
  }
}

⊙ Store Enhancer

说白了，Store 加强器就是对生成的 store API 进行改造，这是它与中间件最大的区别（中间件不修改 store 的 API）
而改造 store 的 API 就要从它的缔造者 createStore 入手。例如，Redux 的 API applyMiddleware 就是一个 Store 加强器：

import compose from './compose' // 这货的做用其实就是 compose(f, g, h)(action) => f(g(h(action)))

/* 传入一坨中间件 */
export default function applyMiddleware(...middlewares) {

  /* 传入 createStore */
  return function(createStore) {
  
    /* 返回一个函数签名跟 createStore 如出一辙的函数，亦即返回的是一个加强版的 createStore */
    return function(reducer, preloadedState, enhancer) {
    
      // 用原 createStore 先生成一个 store，其包含 getState / dispatch / subscribe / replaceReducer 四个 API
      var store = createStore(reducer, preloadedState, enhancer)
      
      var dispatch = store.dispatch // 指向原 dispatch
      var chain = [] // 存储中间件的数组
  
      // 提供给中间件的 API（其实都是 store 的 API）
      var middlewareAPI = {
        getState: store.getState,
        dispatch: (action) => dispatch(action)
      }
      
      // 给中间件“装上” API，见上面 ⊙Middleware【下降逼格写法】的【锚点-1】 
      chain = middlewares.map(middleware => middleware(middlewareAPI))
      
      // 串联各个中间件，为各个中间件传入原 store.dispatch，见【下降逼格写法】的【锚点-2】
      dispatch = compose(...chain)(store.dispatch)
  
      return {
        ...store, // store 的 API 中保留 getState / subsribe / replaceReducer
        dispatch  // 新 dispatch 覆盖原 dispatch，日后调用 dispatch 就会触发 chain 内的中间件链式串联执行
      }
    }
  }
}

最终返回的虽然仍是 store 的那四个 API，但其中的 dispatch 函数的功能被加强了，这就是所谓的 Store Enhancer

⊙ 综合应用 ( 在线演示 )

<!DOCTYPE html>
<html>
<head>
  <script src="//cdn.bootcss.com/redux/3.5.2/redux.min.js"></script>
</head>
<body>
<script>
/** Action Creators */
function inc() {
  return { type: 'INCREMENT' };
}
function dec() {
  return { type: 'DECREMENT' };
}

function reducer(state, action) {
  state = state || { counter: 0 };

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

function printStateMiddleware(middlewareAPI) {
  return function (dispatch) {
    return function (action) {
      console.log('dispatch 前：', middlewareAPI.getState());
      var returnValue = dispatch(action);
      console.log('dispatch 后：', middlewareAPI.getState(), '\n');
      return returnValue;
    };
  };
}

var enhancedCreateStore = Redux.applyMiddleware(printStateMiddleware)(Redux.createStore);
var store = enhancedCreateStore(reducer);

store.dispatch(inc());
store.dispatch(inc());
store.dispatch(dec());
</script>
</body>
</html>

控制台输出：

dispatch 前：{ counter: 0 }
dispatch 后：{ counter: 1 }

dispatch 前：{ counter: 1 }
dispatch 后：{ counter: 2 }

dispatch 前：{ counter: 2 }
dispatch 后：{ counter: 1 }

实际上，上面生成 store 的代码能够更加优雅：

/** 本代码块记为 code-10 **/
var store = Redux.createStore(
  reducer,
  Redux.applyMiddleware(printStateMiddleware)
)

若是有多个中间件以及多个加强器，还能够这样写（请留意序号顺序）：

重温一下 createStore 完整的函数签名：function createStore(reducer, preloadedState, enhancer)

/** 本代码块记为 code-11 **/
import { createStore, applyMiddleware, compose } from 'redux'

const store = createStore(
  reducer,
  preloadedState, // <----- 可选，先后端同构的数据同步
  compose( // <------------ 还记得吗？compose 是从右到左的哦！
    applyMiddleware( // <-- 这货也是 Store Enhancer 哦！但这是关乎中间件的加强器，必须置于 compose 执行链的最后
      middleware1,
      middleware2,
      middleware3
    ),
    enhancer3,
    enhancer2,
    enhancer1
  )
)

为何会支持那么多种写法呢？在 createStore 的源码分析的开头部分，我省略了一些代码，如今奉上该压轴部分：

/** 本代码块记为 code-12 **/
if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
  // 这里就是上面 code-10 的状况，只传入 reducer 和 Store Enhancer 这两个参数
  enhancer = preloadedState
  preloadedState = undefined
}

if (typeof enhancer !== 'undefined') {
  if (typeof enhancer !== 'function') {
    throw new Error('Expected the enhancer to be a function.')
  }
  // 存在 enhancer 就当即执行，返回加强版的 createStore <--------- 记为【锚点 12-1】
  return enhancer(createStore)(reducer, preloadedState)
}

if (typeof reducer !== 'function') {
  throw new Error('Expected the reducer to be a function.')
}

// 除 compose 外，createStore 居然也在此为咱们提供了书写的便利与自由度，实在是太体贴了

若是像 code-11 那样有多个 enhancer，则 code-12 【锚点 12-1】 中的代码会执行屡次
生成最终的超级加强版 store。最后，奉上 code-11 中 compose 内部的执行顺序示意图：

原 createStore ————
                  │
                  ↓
return enhancer1(createStore)(reducer, preloadedState, enhancer2)
   |
   ├———————→ createStore 加强版 1
                    │
                    ↓
return enhancer2(createStore1)(reducer, preloadedState, enhancer3)
   |
   ├———————————→ createStore 加强版 1+2
                        │
                        ↓
return enhancer3(createStore1+2)(reducer, preloadedState, applyMiddleware(m1,m2,m3))
   |
   ├————————————————————→ createStore 加强版 1+2+3
                                     │
                                     ↓
return appleMiddleware(m1,m2,m3)(createStore1+2+3)(reducer, preloadedState)
   |
   ├——————————————————————————————————→ 生成最终加强版 store

§ 总结

Redux 有五个 API，分别是：

  • createStore(reducer, [initialState])

  • combineReducers(reducers)

  • applyMiddleware(...middlewares)

  • bindActionCreators(actionCreators, dispatch)

  • compose(...functions)

createStore 生成的 store 有四个 API，分别是：

  • getState()

  • dispatch(action)

  • subscribe(listener)

  • replaceReducer(nextReducer)

至此，若您已经理解上述 API 的做用机理，以及中间件与加强器的概念/区别
本人将不胜荣幸，不妨点个 star 算是对个人赞扬
如您对本教程有任何意见或改进的建议，欢迎 issue，我会尽快予您答复

最后奉上 React + Redux + React Router 的简易留言板实例：react-demo

拓展阅读：中间件的洋葱模型

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程