createStore(reducer, preloadedState, enhancer)

enhancer(createStore)(reducer, preloadedState)

combineReducers(reducers)

// 传入const reducers = {  count: state => state,  string: state => state};// 函数里处理const keys = ["count", "string"];// 新stateconst state = {};for (const key of keys) {  // 通过上一次key对应的state，调用对应的reducer函数，得到新的state  state[key]=reducers[key](prevKeyState)}return state;

// createStore将自己交给了增强器applyMiddleware(增强器A,增强器B)(createStore)(reducers,preloadedState)// 函数声明大概就是这样function applyMiddleware(增强器A,增强器B) {  return function (createStore) {    return function (reducers,preloadedState) {        const state = createStore(reducers,preloadedState);        // 取出dispatch 使用接收的增强器对他进行增强        ...    }  }}

import $$observable from "./utils/symbol-observable";import ActionTypes from "./utils/actionTypes";export default function createStore(reducer, preloadedState, enhancer) {  	// 如果有增强器  	if (typeof enhancer !== "undefined"){    	return enhancer(createStore)(reducer, preloadedState);    }    // 当前的reducer    let currentReducer = reducer;    // 当前的state    let currentState = preloadedState;    // 当前的listeners    let currentListeners = [];    // 下一次的listeners    let nextListeners = currentListeners;    // 标示是否正在进行dispatch    let isDispatching = false;     // 这是一个对currentListeners的浅复制，所以我们可以将nextListeners当作一个临时的list在dispatch的过程中使用     // 这样做的目的是可以防止在dispatch调用过程中，调用subscribe/unsubscribe产生错误    function ensureCanMutateNextListeners() {        if (nextListeners === currentListeners) {            // 浅复制            nextListeners = currentListeners.slice();        }    }    // 用来获取state tree    function getState() {        return currentState;    }  	// 添加一个state change的监听，它会在每次dispatch调用结束后并且一部分state tree可能被改变时调用  	// 你可以在这个callback里调用getState()来获取当前的state tree  	// 返回值是一个函数，用来退订    function subscribe(listener) {        // 标志已经被订阅        let isSubscribed = true;        // 浅复制一次listeners        // 也就是currentListeners复制到nextListeners        ensureCanMutateNextListeners();        // 添加进nextListeners        nextListeners.push(listener);        // 返回的退订函数        return function unsubscribe() {            // 如果已经退订了，就return            // 防止多次调用函数            if (!isSubscribed) {                return;            }            // 已经退订            isSubscribed = false;            // 浅复制一次            ensureCanMutateNextListeners();            const index = nextListeners.indexOf(listener);            // 删除掉订阅的函数            nextListeners.splice(index, 1);            // currentListeners设置为null的原因是防止内存泄露            // 见https://github.com/reduxjs/redux/issues/3474            currentListeners = null;        };    }     // dispatch一个action，这是触发state改变的唯一方式     // 它只实现了基础的字面量对象action操作，如果你想要dispatch一个Promise、Observable、thunk获取其他的，你需要将创建store的函数放进响应的中间件，比如redux-thunk包     // 为了方便返回值为相同的action对象     // 如果你使用来自定义的中间件，可能会返回其他的东西，比如Promise    function dispatch(action) {        try {            isDispatching = true;            // 通过reducer获取下一个state            currentState = currentReducer(currentState, action);        }        finally {            isDispatching = false;        }        // 通知所有listeners        const listeners = (currentListeners = nextListeners);        for (let i = 0; i < listeners.length; i++) {            const listener = listeners[i];            listener();        }        return action;    }     // 替换store当前使用的reducer来计算state     // 如果你的app实现了代码分割，并且你想动态的加载某些reducers，或者实现来redux的热重载，就需要这个方法    function replaceReducer(nextReducer) {      // ...    }    // 提供给observable/reactive库的接口    function observable() {      // ...    }    // 当store创建好了，会派发一个INIT的action，这样所有的reducer都会返回它们的初始值    // 有效填充了初始的state tree    dispatch({ type: ActionTypes.INIT });    const store = {        dispatch: dispatch,        subscribe,        getState,        replaceReducer,        [$$observable]: observable    };    // 返回store    return store;}

import ActionTypes from "./utils/actionTypes";export default function combineReducers(reducers) {    // 获取传入的reducers对象的keys    const reducerKeys = Object.keys(reducers);    // 实际使用的reducers对象    const finalReducers = {};    for (let i = 0; i < reducerKeys.length; i++) {        const key = reducerKeys[i];        finalReducers[key] = reducers[key];    }    // 获取reducers的key    const finalReducerKeys = Object.keys(finalReducers);    // 返回的合并为一个的reducer函数    return function combination(state = {}, action) {        // 标示state有没有改变        let hasChanged = false;        // 经过reducer处理的下一次state        const nextState = {};        // 循环调用每一个reducer函数        for (let i = 0; i < finalReducerKeys.length; i++) {            // 当前reducer的key            const key = finalReducerKeys[i];            // 当前reducer的函数            const reducer = finalReducers[key];            // 当前key对应的state的值            const previousStateForKey = state[key];            // 经过reducer函数后的下一此state值            const nextStateForKey = reducer(previousStateForKey, action);            // 当前key的值赋值给state对象            nextState[key] = nextStateForKey;            // 如果当前key的state和上一次的state不同，说明state就已经改变了            hasChanged = hasChanged || nextStateForKey !== previousStateForKey;        }        // 如果replace了reducers，可能会需要判断key的length        // 见https://github.com/reduxjs/redux/issues/3488        hasChanged =            hasChanged || finalReducerKeys.length !== Object.keys(state).length;        return hasChanged ? nextState : state;    };}

// 绑定function bindActionCreator(actionCreator, dispatch) {    return function (...args) {        return dispatch(actionCreator.apply(this, args));    };}export default function bindActionCreators(actionCreators, dispatch) {    // 只有一个函数的情况    if (typeof actionCreators === "function") {        return bindActionCreator(actionCreators, dispatch);    }    const boundActionCreators = {};    // 循环绑定    for (const key in actionCreators) {        const actionCreator = actionCreators[key];        boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);    }    return boundActionCreators;}

const a = a => a + "A";const b = b => b + "B";const c = c => c + "C";const composed = compose(a,b,c);composed("args"); // => argsCBA

export default function compose(...funcs) {  	// 参数为0个    if (funcs.length === 0) {        return (arg) => arg;    }  	// 参数为1个    if (funcs.length === 1) {        return funcs[0];    }    return funcs.reduce((a, b) => (...args) => a(b(...args)));}

import compose from "./compose";/** * applyMiddleware函数接收middleware为参数 * 返回另一个函数，这个函数需要接收createStore为函数，这个处理是在createStore中进行的 * * 这里是使用接收的createStore函数，把store创建出来 * 然后把dispatch和getStore传给中间件函数 * 使用compose把已经有dispatch和getStore方法当中间件组合后，将dispatch传入，得到一个新的dispatch * 新的dispatch是经过了中间件的dispatch */export default function applyMiddleware(...middlewares) {    return (createStore) => (reducer, ...args) => {        const store = createStore(reducer, ...args);        // 这里做一个错误处理        // 如果在绑定中间件的时候调用dispatch会报错        let dispatch = () => {            throw new Error("...");        };        const middlewareAPI = {            getState: store.getState,            dispatch: (action, ...args) => dispatch(action, ...args)        };        // 将dispatch和getStore方法传入中间件，得到新的数组        const chain = middlewares.map(middleware => middleware(middlewareAPI));        // 将新的数组用compose绑定起来，再把store.dispatch传入，得到新的dispatch        dispatch = compose(...chain)(store.dispatch);        return {            ...store,            dispatch        };    };}