dispatch 之后，Redux 是如何去处理的？
state 中的数据被修改之后，页面如何去收到更新后的数据？

createStore(reducer, preloadedState, enhancer) {// 转换参数if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {enhancer = preloadedStatepreloadedState = undefined}let currentReducer = reducer // 当前的reducer，支持通过 store.replaceReducer 方式动态替换 reducer，为代码热替换提供可能。（之后会写一篇 react-redux 的文章来解读）let currentState = preloadedState // 当前的statelet currentListeners = [] // 存储更新函数的数组let nextListeners = currentListeners // 下次dispatch将会触发的更新函数数组let isDispatching = false //类似一把锁，如果正在dispatch action，那么就做一些限制function getState() {// 返回当前的state， 可以调用store.getState()获取到store中的数据，...}function subscribe(listener) {// 订阅一个更新函数（listener），实际上的订阅操作就是把listener放入一个listeners数组// 该方法会返回一个 unSubscribe() 函数，以便从数组中删除该监听函数。// 但是注意，这两个操作都是在dispatch不执行时候进行的。因为dispatch执行时候会循环执行更新函数，要保证listeners数组在这时候不能被改变...}function dispatch(action) {// 接收action，调用reducer根据action和当前的state，返回一个新的state// 循环调用listeners数组，执行更新函数，函数内部会通过store.getState()获取state，此时的state为最新的state，完成页面的更新...}return {dispatch,subscribe,getState,}}

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?')}// 正在dispatch的话不能再次dispatch，也就是说不可以同时dispatch两个actionif (isDispatching) {throw new Error('Reducers may not dispatch actions.')}try {isDispatching = true// 获取到当前的statecurrentState = currentReducer(currentState, action)} finally {isDispatching = false}
// 此处的会将 subscribe() 里订阅的监听依次跑一遍，数组里面都是需要获取数据的函数。const listeners = (currentListeners = nextListeners)// 循环执行当前的linstenerfor (let i = 0; i < listeners.length; i++) {const listener = listeners[i]// 此处并没有将最新状态作为参数传递的原因是因为在监听器中，我们会直接调用 store.getState() 方法去拿到最新的状态，此处只是起到通知作用。这也是数据被更改之后，页面收到通知而去更新数据的方式。listener()}return action}

reducer 是如何处理的？// 获取到所有reducer的名字，组成数组
const reducerKeys = Object.keys(reducers)
// 最终合成的 reducers 集合
const finalReducers = {}// 遍历所有的 reducer 使 finalReducers 变成 key( reducer 名字) ： value( reducer 执行函数)的对象。
for (let i = 0; i < reducerKeys.length; i++) {const key = reducerKeys[i]if (typeof reducers[key] === 'function') {finalReducers[key] = reducers[key]}}const finalReducerKeys = Object.keys(finalReducers)// 该函数为 combineReducers.js 核心，主要思路是对传入的 reducer 进行对比，如果任何一个 reducer 返回的 state 与之前的 state 不同，则会返回全新的 state 。(其实这里有个疑问，该函数如果只改了一个 reducer 的 state 数据，都会返回一个全新的 state，为什么会这样处理？)
return function combination (state ={}, action){let hasChanged = falseconst nextState ={}for (let i =0; i < finalReducerKeys.length; i++) {const key = finalReducerKeys[i]const reducer = finalReducers[key]// 获取每个 reducer 的旧 stateconst previousStateForKey = state[key]// 根据旧 state 推出新的 state (纯函数的优势：相同的 state 和 action 返回的新 state 也会是不变的。)const nextStateForKey = reducer(previousStateForKey, action)if (typeof nextStateForKey ==='undefined') {const errorMessage = getUndefinedStateErrorMessage(key, action)throw newError(errorMessage)}// 最后一步 判断是否和之前的 state 是否一致。nextState[key]= nextStateForKeyhasChanged = hasChanged || nextStateForKey !== previousStateForKey}return hasChanged ? nextState : state
}

为什么一个临时变量 dispatch 被赋值了 2 次？
middlewareAPI 的 dispatch 为什么要用匿名函数包裹？

function applyMiddleware(...middlewares) {return (createStore) =>(reducer, preloadedState) => {const store = createStore(reducer, preloadedState)let dispatch = () => {throw new Error('Dispatching while constructing your middleware is not allowed. ' +'Other middleware would not be applied to this dispatch.')}const middlewareAPI = {getState: store.getState,dispatch: (action, ...args) => dispatch(action, ...args)}const chain = middlewares.map(middleware => middleware(middlewareAPI))dispatch = compose(...chain)(store.dispatch)return {...store,dispatch}}
}

    next => action => {return next(action)}

const composedFunc = (next3) => {return((next2) => {return func1(func2(next2))})(func3(next3))
}

func1(func2(func3(dispatch)));console.log("coreFun1 run");((action) => {console.log("coreFunc2 run");((action) => {console.log("coreFunc3 run");dispatch(action);})(action);})(action);
}

const store = createStore(reducer, preloadedState)let dispatch = () => {throw new Error('Dispatching while constructing your middleware is not allowed. ' +'Other middleware would not be applied to this dispatch.')} // 第一次赋值const middlewareAPI = {getState: store.getState,dispatch: (action, ...args) => dispatch(action, ...args)}
const chain = middlewares.map(middleware => middleware(middlewareAPI))
dispatch = compose(...chain)(store.dispatch) // 第二次赋值