一、状态机

redux用来帮助我们管理应用的状态，它本身和React并无关系，但是非常多的React应用都选择是用redux管理应用的状态。在实际的React项目中，使用redux和react-redux这两个工具。react-redux这个工具提供了一系列的简洁api，让我们更好地在React中使用redux。

redux的设计理念基于状态机的概念。当一个应用的状态较多，状态变化逻辑比较复杂时候，使用状态机来梳理逻辑会有助于开发者理解和实现。

状态机提出“状态”（state）和“操作”（action）的概念，

一个应用或者一个功能可能会处于不同的状态。

一个状态在进行操作后，可能会变到其他的状态，也可能维持当前状态不变。

按照状态机去理解和分析一个应用，会更清晰，有条理，而不会有无从下手的感觉。开发者只需要找出应用都有哪些状态和哪些操作，在进行某个操作时候，状态是如何变化的，就能实现这个应用了。

下面通过一个小例子理解什么是状态机。

Redux - 图1

这个状态机描述的是一个开关的逻辑，初始是“off”状态，经过“open”操作，状态变为“on”，而处于“on”状态时候，经过“close”操作，状态会变为“off”。

可以看到，状态机通过“状态”和“操作”两个概念，就可以将一个功能逻辑有条理地描述清楚。

二、Flux和Redux

Flux是Facebook用户建立客户端Web应用的前端架构， 它通过利用一个单向的数据流补充了React的组合视图组件，这更是一种模式而非正式框架。

Flux使用状态机的思想描述应用的状态变化，Flux架构图示如下：

Redux - 图2

Flux架构中，可能有多个store，每个组件可以拥有自己的store。

dispatcher是一个集中的分发器，当收到action时候将action分发到所有的store，关心这个action的store就会根据用户注册的处理方法对action处理，得到最新的状态，然后store会把最新的状态通知到view，view监听到状态更新后，用最新的状态重新渲染视图。

Flux的一个核心就是单向数据流，视图只能通过触发action改变状态，不能直接修改store。

Flux中的store用来存储状态并根据action计算新的状态。

Redux是实现了Flux思想的最著名的一个库。

Redux架构核心也是单向数据流，Redux架构中包含3大核心：actions、store和reducers。

视图触发Action，store接收到action之后调用reducer计算新的状态，然后更新状态并通知视图。

Redux - 图3

前端Flux架构简介

React实战：Redux应用架构

二、Redux的使用

什么时候需要Redux

如果页面很简单，或者虽然有多个页面，但是页面之间彼此独立，页面之间、组件之间不需要共享状态，那么引入Redux没有意义。

如果页面的组件之间跨层级通信或者页面的不同部分共享状态的情况很多，那么仅仅用状态提升来实现组件间通信就会非常杂乱，这时候就需要Redux来帮助管理应用的状态。

Redux的API介绍

本文的示例是写在基于create-react-app创建的项目中，如果希望自己把代码跑起来，可以先创建一个create-react-app项目，然后将代码复制到App.js中即可运行。其他复杂一些的例子，可以根据例子中说明的目录结构将代码复制到项目中即可。

使用redux管理应用的状态，redux会维护应用的状态，开发者需要将进行某种操作后，状态变化的逻辑（这个逻辑就是开发者需要实现的reducer方法）告诉redux，这样后面只需要触发操作，redux就会根据reducer来生成新的状态了。

概括地说，使用redux的步骤是：

  1. 编写reducer并传入createStore

  2. 监听store的数据，更新视图

  3. 触发action

createStore用来创建一个store，store是存储、监听和更新数据的一个js对象。

createStore接收一个函数（即reducer），reducer负责返回更新后的状态。

reducer接收当前的state和action，根据action计算新的状态，初始化时候，返回默认的状态。

创建好store后，通过store.getState()获取当前的状态；通过store.subscribe()来监听状态的改变，状态改变后，在回调中通过store.getState()来获取最新的数据；store.dispatch用来进行状态的更新。

dispatch方法接收一个action参数。action是一个对象，约定这个对象中包含一个key为”type”，value为字符串的属性，这个属性表示触发的action的类型，reducer函数根据这个action来计算新的state。

当开发者调用store.dispatch(action)之后，redux会调用reducer，将当前的state和action传入到reducer中，得到更新的状态后，redux将会用这个最新的状态替换掉当前的state，然后调用store.subscribe()注册的回调。

下面通过一个例子解释redux的主要api的使用。

这里例子实现了一个开关的功能，开关的状态维护在redux中，调用createStore并传入reducer生成store。开关组件通过store.dispatch触发action，改变开关状态，通过store.subscribe监听状态改变，更新界面，通过store.getState()获取状态。

  1. import React from 'react';
  2. import {createStore} from 'redux';
  4. const defaultState = {
  5.     // 开关默认关闭状态
  6.     isSwitchOn: false
  7. };
  9. function reducer(state = defaultState, action) {
  10.     switch(action.type) {
  11.         case 'open':
  12.             return {isSwitchOn: true};
  13.         case 'close':
  14.             return {isSwitchOn: false};
  15.         default:
  16.             return state;
  17.     }
  18. }
  20. const store = createStore(reducer);
  22. class App extends React.PureComponent {
  23.     state = {
  24.         isOpen: store.getState().isSwitchOn
  25.     };
  27.     componentDidMount() {
  28.         // 监听store数据变化的回调
  29.         store.subscribe(() => {
  30.             this.setState({isOpen: store.getState().isSwitchOn});
  31.         });
  32.     }
  34.     switchButton() {
  35.         const currentIsSwitchOn = store.getState().isSwitchOn;
  36.         const action = currentIsSwitchOn ? {type: 'close'} : {type: 'open'};
  37.         // 触发action，更新state
  38.         store.dispatch(action);
  39.     }
  41.     render() {
  42.         return (
  43.             <div>
  44.                 <button onClick={this.switchButton}>
  45.                     {this.state.isOpen ? '关闭' : '打开'}
  46.                 </button>
  47.             </div>
  48.         );
  49.     }
  50. }
  52. export default App;

通过代码可以简单总结redux基本用法：

  1. 实现reducer

  2. 创建store：const store = createStore(reducer)

  3. 通过store注册状态更新的回调：stroe.subscribe(callback)

  4. 通过store获取当前的状态：store.getState()

  5. 通过store触发action，从而改变状态：store.dispatch(action)

三、reducer合并

通常在一个React应用中只有一个store，负责所有的状态管理，如果项目复杂，所有的action->newState都通过一个reducer来处理，会让reducer代码臃肿混乱、不易维护。所以redux支持开发者对reducer进行拆分。

reducer拆分的步骤为：

  1. 首先实现多个reducer。
  2. 然后在createStore时候，用combineReducers将多个reducer包装。
  3. 获取数据时候，按照combineReducers传入的对象结构进行访问。

下面示例代码展示了reducer合并的用法，示例实现了一个可以改变颜色的按钮和一个开关。按钮和开关是不同的功能，因此我们用不同的reducer实现其逻辑。

  1. import React from 'react';
  2. import {createStore, combineReducers} from 'redux';
  4. const defaultSwitch = {
  5.     // 开关默认关闭状态
  6.     isSwitchOn: false,
  7. };
  9. const defaultButton = {
  10.     color: ''
  11. };
  13. function switchReducer(state = defaultSwitch, action) {
  14.     switch(action.type) {
  15.         case 'open':
  16.             return {isSwitchOn: true};
  17.         case 'close':
  18.             return {isSwitchOn: false};
  19.         default:
  20.             return state;
  21.     }
  22. }
  24. function buttonReducer(state = defaultButton, action) {
  25.     switch(action.type) {
  26.         case 'changeColor':
  27.             return {...state, color: action.color}
  28.         default:
  29.             return state;
  30.     }
  31. }
  33. const store = createStore(combineReducers({
  34.     switch: switchReducer,
  35.     button: buttonReducer
  36. }));
  38. class App extends React.PureComponent {
  39.     state = {
  40.         isOpen: store.getState().switch.isSwitchOn,
  41.         color: store.getState().button.color
  42.     };
  44.     componentDidMount() {
  45.         // 监听store数据变化的回调
  46.         store.subscribe(() => {
  47.             this.setState({
  48.                 isOpen: store.getState().switch.isSwitchOn,
  49.                 color: store.getState().button.color
  50.             });
  51.         });
  52.     }
  54.     switchButton = () => {
  55.         const {switch: {isSwitchOn}} = store.getState();
  56.         const action = isSwitchOn ? {type: 'close'} : {type: 'open'};
  57.         // 触发action，更新state
  58.         store.dispatch(action);
  59.     };
  61.     changeButtonColor = () => {
  62.         store.dispatch({type: 'changeColor', color: 'red'});
  63.     };
  65.     render() {
  66.         return (
  67.             <div>
  68.                 <button onClick={this.switchButton}>
  69.                     {this.state.isOpen ? '关闭' : '打开'}
  70.                 </button>
  71.                 <button style={{color: this.state.color}} onClick={this.changeButtonColor}>改变按钮颜色</button>
  72.             </div>
  73.         );
  74.     }
  75. }
  77. export default App;

需要注意的是，在调用dispatch时候，不同reducer都会处理这个action，因此，需要避免不同reducer的action的冲突。

四、中间件（middleware）

在使用redux管理状态时候，可能会对触发action的过程，即dispatch有一些扩展的需求，redux提供了中间件机制来让开发者可以扩展dispatch。

比如，我们希望每次更新状态时候可以把更新之前的状态、action和更新之后的状态打印出来，这样可以方便地对应用进行调试和排查。

再比如，我们希望支持异步action，即dispatch可以传一个函数，函数中可以进行异步操作，异步更新状态（这个需求在调用接口获取数据的业务场景很常见）。

中间件实际做的操作就是改造了dispatch方法。

通过调用applyMiddleware，并传入createStore作为第二个参数来使用中间件。

示例代码演示了如何使用redux-logger和redux-thunk两个中间件。

redux-logger在每次触发状态改变后，就会打印更新之前的状态、action和更新之后的状态。

redux-thunk改造store.dispatch，让store.dispatch可以接收对象或者函数，函数参数为原dispatch和store.getState，在函数中可以执行异步操作，并调用原dispatch来更新状态。

示例代码展示了一个简单的请求数据并展示的功能，注意这里dispatch的action并不是想之前示例中的一个对象，而是一个方法，这个方法接收dispatch和getState参数（这两个参数是redux原生的api），并且方法中进行了dispatch操作，这样就很方便地进行了异步的action。之所以store.dispatch能够接收一个方法作为参数是因为我们使用了redux-thunk中间件。

  1. import React from 'react';
  2. import {createStore, applyMiddleware} from 'redux';
  3. import {createLogger} from 'redux-logger';
  4. import thunkMiddleware from 'redux-thunk';
  6. const loggerMiddleware = createLogger();
  8. const defaultState = {
  9.     // init loading fetched
  10.     status: 'init',
  11.     length: 0
  12. };
  14. function reducer(state = defaultState, action) {
  15.     switch(action.type) {
  16.         case 'start':
  17.             return {...state, status: 'loading'};
  18.         case 'end':
  19.             return {status: 'fetched', length: action.length};
  20.         default:
  21.             return state;
  22.     }
  23. }
  25. // 经过redux-thunk中间件改造，dispatch可以传一个方法
  26. function start() {
  27.     return function (dispatch, getState) {
  28.         if (getState().status === 'init') {
  29.             dispatch({type: 'start'});
  30.             fetch('https://cnodejs.org/api/v1/topics')
  31.                 .then(response => {
  32.                     response.json().then(res => {
  33.                         dispatch({type: 'end', length: res.data.length});
  34.                     });
  35.                 });
  36.         }
  37.     }
  38. }
  40. const store = createStore(
  41.     reducer,
  42.     applyMiddleware(
  43.         thunkMiddleware,
  44.         loggerMiddleware
  45.     )
  46. );
  48. class App extends React.PureComponent {
  49.     state = {
  50.         status: store.getState().status,
  51.         length: store.getState().length
  52.     };
  54.     componentDidMount() {
  55.         // 监听store数据变化的回调
  56.         store.subscribe(() => {
  57.             this.setState({
  58.                 status: store.getState().status,
  59.                 length: store.getState().length
  60.             });
  61.         });
  62.     }
  64.     onStartButtonClick() {
  65.         store.dispatch(start());
  66.     }
  68.     render() {
  69.         return (
  70.             <div>
  71.                 <button onClick={this.onStartButtonClick}>
  72.                     {
  73.                         {
  74.                             init: '开始',
  75.                             loading: '请等待...',
  76.                             fetched: '请求结束'
  77.                         }[this.state.status]
  78.                     }
  79.                 </button>
  80.                 <div>数据长度：{this.state.length}</div>
  81.             </div>
  82.         );
  83.     }
  84. }
  86. export default App;

五、react-redux

通过前面示例，我们在React项目中使用redux时候，每次都需要监听store变化并绑定到组件自身的state，并且在获取store中的数据时候和触发action时候都需要写一些样板代码（store.subscribe、store.getState()）。为了让我们在React项目中更简洁地使用redux，我们可以引入react-redux这个工具。

react-redux相当于一个辅助的工具，让我们在React项目中使用redux时候可以写更简洁的代码。

下面我们来看如何使用react-redux来让我们的代码更加简洁。

react-redux中有两个主要的API：

Provider // 包裹根组件，并传入store属性，store属性值为redux的store，该组件用于给组件中增加store的context，这样组件树种的子组件就可以通过consumer来访问store，当然开发者不需要直接获取store，而是通过connect来方便地对store进行访问和监听。

connect(mapState, mapDispatch) // 用来包裹开发的UI组件，该组件可以根据传入的参数监听store中的属性，并注入到UI组件中。

react-redux中有两个概念：UI组件和容器组件。

使用connect返回的高阶组件包装的组件，即我们实现的组件是UI组件，connect返回的是一个包含容器组件的高阶组件，容器组件负责监听store变化，并将开发者关注的数据通过props注入到UI组件中。

connect是一个方法，它接收的前两个参数是mapStateToProps和mapDispatchToProps，它返回一个高阶组件，用高阶组件包裹UI组件后，UI组件中就能在props中访问store的数据，并通过dispatch触发action、修改数据了。

mapStateToProps用于将store中的数据映射到UI组件的props中。mapStateToProps的参数是store，返回的结果是一个对象，对象中的数据将会被传入到UI组件的props中。mapStateToProps返回的数据决定了组件需要监听的数据，虽然store中存储了很多数据，但是只要对某个组件（例如A）使用connect包装时候，mapStateToProps的返回值中不包括它不关心的数据，那么其他数据改变后，不会触发A的render。

mapDispatchToProps，如果该参数为空，那么将默认将dispatch传入到UI组件的props中。如果不为空，则props中不会被传入dispatch方法，而是会将mapDispatchToProps返回的结果处理后传入到props中。mapDispatchToProps返回的结果是一个对象，key是将会挂到props上的方法名，value是执行的方法，一般在执行方法中会调用store的dispatch方法触发action，store的dispatch方法会在mapDispatchToProps方法的参数中传入。

  1. connect方法所做的工作可以简单描述为，使用consumer获取了context中的store，并返回高阶组件，这个高阶组件包装UI组件后，返回一个容器组件，容器组件根据connect传入的参数监听感兴趣的数据，并在数据变化时候更新UI组件。

index.js代码：

  1. // index.js
  2. import React from 'react';
  3. import ReactDOM from 'react-dom';
  4. import App from './App';
  5. import {Provider} from 'react-redux';
  6. import { createStore } from 'redux';
  8. const defaultState = {
  9.   // 开关默认关闭状态
  10.   isSwitchOn: false
  11. };
  13. function reducer(state = defaultState, action) {
  14.   switch(action.type) {
  15.       case 'open':
  16.           return {isSwitchOn: true};
  17.       case 'close':
  18.           return {isSwitchOn: false};
  19.       default:
  20.           return state;
  21.   }
  22. }
  24. const store = createStore(reducer);
  26. ReactDOM.render(
  27.     <Provider store={store}>
  28.         <App />
  29.     </Provider>,
  30.     document.getElementById('root')
  31. );

App.js代码：

该示例没有传入mapDispatchToProps，关于mapDispatchToProps参数可以看后面的例子

  1. // App.js
  2. import React from 'react';
  3. import {connect} from 'react-redux';
  5. class App extends React.PureComponent {
  7.     switchButton = () => {
  8.         const action = this.props.isSwitchOn ? {type: 'close'} : {type: 'open'};
  9.         // 触发action，更新state
  10.         this.props.dispatch(action);
  11.     };
  13.     render() {
  14.         return (
  15.             <div>
  16.                 <button onClick={this.switchButton}>
  17.                     {this.props.isSwitchOn ? '关闭' : '打开'}
  18.                 </button>
  19.             </div>
  20.         );
  21.     }
  22. }
  24. const mapStateToProps = ({isSwitchOn}) => ({isSwitchOn});
  26. export default connect(mapStateToProps)(App);

六、redux实践

请确保在了解redux实践之前先理解上述的redux和react-redux的基本使用。

在React项目中使用redux时候通常都会用到redux和react-redux两个库，使用redux管理状态，使用react-redux来更方便地访问、监听和改变数据。

在使用了redux的项目中，reducer代码和action代码的组织因人而异，推荐尽量把项目中所有的reducer和action代码放在一起，便于维护。

一般actionType都会定义为常量，而非直接写字符串，这样在项目规模较大，状态较多时候更利于项目维护。

dispatch的action是一个对象，这个对象中除了必需的type字段外，很可能会有其他的字段，为了减少样板代码，通常都使用一个方法返回action对象，这个方法称为action creator。

下面是一个参考的目录结构

  1. src
  2. └── store // store目录用于存放redux状态管理相关代码
  3.     ├── actionCreators // 项目中所有的action creator
  4.     │   ├── article.js
  5.     │   └── user.js
  6.     ├── actionTypes.js // 项目中所有action type 定义的常量
  7.     ├── reducers // 项目中所有的reducer
  8.     │   ├── article.js
  9.     │   └── user.js
  10.     └── store.js // 导出store

在React中使用redux的一个实践步骤描述如下：

  1. 统一维护redux相关代码：

实现actionTypes

实现actionCreators

实现reducers

实现store，加载中间件

  1. 在入口使用Provider注入store
  2. 使用connect包裹组件，监听时间，并获取store的属性，进行数据访问和改变

按照这种实践实现的一个示例如下：

关键模块的目录结构：

  1. src
  2. ├── App.js
  3. ├── index.js
  4. └── store
  5.     ├── actionCreators
  6.     │   ├── article.js
  7.     │   └── user.js
  8.     ├── actionTypes.js
  9.     ├── reducers
  10.     │   ├── article.js
  11.     │   └── user.js
  12.     └── store.js

先看入口文件的代码，入口将store注入到了组件树中

  1. // index.js
  2. import React from 'react';
  3. import ReactDOM from 'react-dom';
  4. import App from './App';
  5. import {Provider} from 'react-redux';
  6. import store from './store/store';
  8. ReactDOM.render(
  9.     <Provider store={store}>
  10.         <App />
  11.     </Provider>,
  12.     document.getElementById('root')
  13. );

再看下store相关的代码

actionTypes.js就是定义了action type的常量字符串。

  1. // store/actionTypes.js
  2. export const CHANGE_TITLE = 'change_title';
  4. export const CHANGE_NAME = 'change_name';
  6. export const CHANGE_AGE = 'change_age';

actionCreators目录中的模块定义了项目中的action creator

  1. // store/actionCreators/
  3. // article.js
  4. import {
  5.     CHANGE_TITLE
  6. } from '../actionTypes'
  8. export const changeTitle = title => {
  9.     return {
  10.         type: CHANGE_TITLE,
  11.         title
  12.     };
  13. };
  15. // user.js
  16. import {
  17.     CHANGE_NAME, CHANGE_AGE
  18. } from '../actionTypes';
  20. export const changeName = name => {
  21.     return {
  22.         type: CHANGE_NAME,
  23.         name
  24.     };
  25. };
  27. export const changeAge = age => {
  28.     return {
  29.         type: CHANGE_AGE,
  30.         age
  31.     };
  32. };

reducers目录中的模块定义了reducer

  1. // store/reducers/
  3. // article.js
  4. import {
  5.     CHANGE_TITLE
  6. } from '../actionTypes';
  8. const defaultArticleState = {
  9.     title: '新年快乐！',
  10. };
  12. const articleReducer = (state = defaultArticleState, action) => {
  13.     switch (action.type) {
  14.         case CHANGE_TITLE:
  15.                 // reducer返回的结果会被作为新的状态，因此需要保留之前状态的字段
  16.             return {...state, title: action.title};
  17.         default:
  18.             return state;
  19.     }
  20. };
  22. export default articleReducer;
  24. // user.js
  25. import {
  26.     CHANGE_NAME, CHANGE_AGE
  27. } from '../actionTypes';
  29. const defaultUserState = {
  30.     name: 'Jam',
  31.     age: 18
  32. };
  34. const userReducer = (state = defaultUserState, action) => {
  35.     switch (action.type) {
  36.         case CHANGE_NAME:
  37.             return {...state, name: action.name};
  38.         case CHANGE_AGE:
  39.             return {...state, age: action.age};
  40.         default:
  41.             return state;
  42.     }
  43. };
  45. export default userReducer;

store.js中根据reducer，并引入一些常用中间件，然后创建并导出store。

  1. // store/store.js
  3. import {createStore, applyMiddleware, combineReducers} from 'redux';
  4. import {createLogger} from 'redux-logger';
  5. import thunkMiddleware from 'redux-thunk';
  7. import user from './reducers/user';
  8. import article from './reducers/article';
  10. const loggerMiddleware = createLogger()
  12. export default createStore(
  13.     combineReducers({user, article}),
  14.     applyMiddleware(
  15.         thunkMiddleware,
  16.         loggerMiddleware
  17.     )
  18. );

在App.js中使用状态管理，可以看到组件被connect包裹后可以访问到store中的状态，并可以通过mapDispatchToProps映射后的方法改变状态。

  1. // App.js
  2. import React from 'react';
  3. import {connect} from 'react-redux';
  4. import {changeName, changeAge} from './store/actionCreators/user';
  5. import {changeTitle} from './store/actionCreators/article';
  7. class User extends React.Component {
  8.     state = {
  9.         text: ''
  10.     };
  12.     onInputChange = e => {
  13.         this.setState({text: e.target.value})
  14.     };
  16.     changeUserName = () => {
  17.         this.props.changeName(this.state.text);
  18.     };
  20.     changeUserAge = () => {
  21.         this.props.changeAge(+this.state.text);
  22.     };
  24.     render() {
  25.         return (
  26.             <div>
  27.                 <input value={this.state.text} onChange={this.onInputChange} />
  28.                 <div>用户姓名：{this.props.name}</div>
  29.                 <div>用户年龄：{this.props.age}</div>
  30.                 <button onClick={this.changeUserName}>修改用户姓名</button>
  31.                 <button onClick={this.changeUserAge}>修改用户年龄</button>
  32.             </div>
  33.         );
  34.     }
  35. }
  37. class Article extends React.Component {
  39.     state = {
  40.         text: ''
  41.     };
  43.     onInputChange = e => {
  44.         this.setState({text: e.target.value})
  45.     };
  47.     changeArticleTitle = () => {
  48.         this.props.changeTitle(this.state.text);
  49.     };
  51.     render() {
  52.         return (
  53.             <div>
  54.                 <input value={this.state.text} onChange={this.onInputChange} />
  56.                 <div>文章标题：{this.props.title}</div>
  57.                 <button onClick={this.changeArticleTitle}>修改文章标题</button>
  58.             </div>
  59.         );
  60.     }
  61. }
  63. const WrappedUser = connect(
  64.     ({
  65.         user: {name, age}, article: {title}
  66.     }) => ({name, age, title}),
  67.     dispatch => ({
  68.         changeName: name => dispatch(changeName(name)),
  69.         changeAge: age => dispatch(changeAge(age))
  70.     })
  71. )(User);
  73. const WrappedArticle = connect(
  74.     ({
  75.         article: {title}
  76.     }) => ({title}),
  77.     dispatch => ({
  78.         changeTitle: title => dispatch(changeTitle(title))
  79.     })
  80. )(Article);
  82. class App extends React.PureComponent {
  83.     render() {
  84.         return (
  85.             <div>
  86.                 <WrappedUser />
  87.                 <WrappedArticle />
  88.             </div>
  89.         );
  90.     }
  91. }
  93. export default App;

七、redux生态

  • 中间件
  • reselect，减少redux state改变时候无关属性计算
  • redux-saga，异步actions管理
  • react-router-redux
  • devTools状态跟踪
  • redux热重载

八、redux的实现

Redux有3大核心，actions、store和reducer。Redux维护一个state，接受用户定义的reducer，用于根据action计算新的state，当用户触发action后，Redux调用reducer计算新的state，更新state，然后将新的state发布给订阅者。

这节讲一下redux的简单实现：createStore这个API的实现，先来看下createStore的使用。

  1. const defaultState = {
  2.     // 开关默认关闭状态
  3.     isSwitchOn: false
  4. };
  5. function reducer(state = defaultState, action) {
  6.     switch (action.type) {
  7.         case 'open':
  8.         return {isSwitchOn: true};
  9.         case 'close':
  10.         return {isSwitchOn: false};
  11.         default:
  12.         return state;
  13.     }
  14. }
  15. const store = createStore(reducer);
  16. const unsubscribe = store.subscribe(() => {
  17.     console.log('state', store.getState());
  18. });
  19. store.dispatch({type: 'open'});
  20. unsubscribe();

我们看到createStore接收一个方法reducer作为参数，返回一个对象store，store有3个方法

  • getState，获取当前状态。
  • subscribe，接收一个回调作为参数，订阅状态改变，它返回一个函数，用来解除订阅。
  • dispatch，接收一个action对象作为参数，触发action之后会依据reducer计算新的状态，并通知订阅者。

根据上面的列举，我们用TypeScript写一个简单的redux

  1. interface IStore {
  2.   subscribe: (cb: Function) => void,
  3.   getState: () => Object,
  4.   dispatch: (action: Object) => void
  5. }
  7. const createStore = (reducer: Function): IStore => {
  8.   let state = reducer();
  9.   const listeners = [];
  10.   const subscribe = cb => {
  11.     listeners.push(cb);
  12.     return () => {
  13.         const index = listeners.indexOf(cb);
  14.         listeners.splice(index, 1);
  15.     };
  16.   };
  17.   const getState = () => state;
  18.   const dispatch = action => {
  19.     state = reducer(action);
  20.     listeners.forEach(listener => listener());
  21.   };
  23.   return {
  24.     subscribe, getState, dispatch
  25.   };
  26. };

但是在这个简单的实现中有几个问题没有考虑到：

  1. reducer应该是一个纯函数，但是用户如果在reducer中调用getState、subscribe、dispatch怎么办？
  2. 如果用户连续调用解绑函数怎么办？
  3. 如果用户在dispatch过程中，即在订阅者中做绑定和解绑的操作怎么办？

对于上面的问题，redux的解决方案是这样的：

  1. 设置标志位：isDispatching，用reducer计算新state时候置为true，在计算完再置为false。然后在getState、subscribe、dispatch方法中判断，如果isDispatching为true，则抛出错误。
  2. 设置标志位：isSubscribed，它标识一个订阅者是否正在订阅中，订阅后置为true，解绑后置为false，如果用户连续调用解绑，redux判断isSubscribed为false，就直接return了。
  3. redux设置了currentListners和nextListners两个数组，这两个数组就是为了防止执行listners时候还添加和移除监听器。在添加和移除时候都新建一个区别于currentListeners的数组：nextListeners，在nextListners添加或删除listener，当dispatch时候再将currentListners和nextListners同步。

redux的createStore就是实现了上面提到的API并且完美解决了上面提到的问题。

阅读redux代码，可以理解的更深刻：redux-github、redux createStore源码。