摘要：定義了幾個函數(shù)用于修改上面的幾個局部變量主要包括函數(shù)用于獲取用于替換用于修改列表用于觸發(fā)執(zhí)行，生成新的，并且，執(zhí)行列表中的每一個函數(shù)完整解析請參考我的，如果對您有幫助，歡迎，有任何問題也請指正。

歡迎關注redux源碼分析系列文章：
redux源碼分析之一：createStore.js
redux源碼分析之二：combineReducers.js
redux源碼分析之三：bindActionCreators.js
redux源碼分析之四：compose.js
redux源碼分析之五：applyMiddleware

createStore.js是redux的核心文件，暴露了一個函數(shù)createStore，函數(shù)執(zhí)行后返回一個對象，該對象包含了4個關鍵的方法：dispatch, subscribe, getState, replaceReducer，代碼如下。

export default function createStore(reducer, preloadedState, enhancer) {
    //中間代碼略
    return {
        dispatch,
        subscribe,
        getState,
        replaceReducer,
        [$$observable]: observable
      }
}

reducer：reducer是一個函數(shù)，該函數(shù)會返回一個全新的state，而state則保存了所有的數(shù)據

preloadedState：初始state

enhancer：這個參數(shù)特別有意思，如果該enhancer參數(shù)存在的話，會將當前的createStore函數(shù)作為參數(shù)傳入enhancer函數(shù)，并且，enhancer執(zhí)行之后得到一個新函數(shù)，該新函數(shù)其實就是一個加強版的createStore函數(shù)，新的函數(shù)會把之前的reducer和preloadeState作為參數(shù)傳入并執(zhí)行。這個enhancer參數(shù)為redux中間件提供了入口。

//如果preloadedState沒有傳，但是enhancer參數(shù)傳了，重置一下變量
if (typeof preloadedState === "function" && typeof enhancer === "undefined")          
  {
    enhancer = preloadedState
    preloadedState = undefined
  }
//如果enhancer傳了，但是不是函數(shù)，則報錯提示，否則執(zhí)行enhancer函數(shù)，
//并繼續(xù)執(zhí)行enhancer函數(shù)返回的加強版的createStore函數(shù)，
//參數(shù)reducer以及preloadeState和原createStore函數(shù)保持一致
if (typeof enhancer !== "undefined") {
    if (typeof enhancer !== "function") {
      throw new Error("Expected the enhancer to be a function.")
    }
    return enhancer(createStore)(reducer, preloadedState)
  }
//如果reducer不是函數(shù)，則報錯
if (typeof reducer !== "function") {
    throw new Error("Expected the reducer to be a function.")
}

let currentReducer = reducer //保存了當前的reducer函數(shù)，該reducer函數(shù)可以被動態(tài)替換掉
let currentState = preloadedState //保存了當前的state數(shù)據
let currentListeners = [] //保存了當前注冊的函數(shù)列表
let nextListeners = currentListeners
let isDispatching = false  //是否正在dispatch一個action

最關鍵的是currentState變量，調用createStore之后，currentState變量保存了當前狀態(tài)的所有數(shù)據

//確保nextListeners和currentListeners不是同一個引用
function ensureCanMutateNextListeners() {
  if (nextListeners === currentListeners) {
    //如果是同一個引用，則淺拷貝currentListeners到nextListeners
    nextListeners = currentListeners.slice()
  }
}

//getState函數(shù)，返回局部變量currentState，以獲取當前狀態(tài)
function getState() {
  return currentState
}

  //注冊一個函數(shù)，將注冊函數(shù)放入局部變量nextListeners數(shù)組里面
  //注冊函數(shù)的返回值是一個注銷函數(shù)，注銷函數(shù)執(zhí)行可以將剛剛添加進nextListeners的listener函數(shù)又刪除掉。這里很有意思，外部必須在調用subscribe執(zhí)行現(xiàn)場保存好unsubscribe函數(shù)，否則將無法注銷一個函數(shù)
  function subscribe(listener) {
    //如果listener不是函數(shù)，直接報錯
    if (typeof listener !== "function") {
      throw new Error("Expected listener to be a function.")
    }

    let isSubscribed = true
    //確保nextListeners不是currentListeners，以保證修改的是nextListeners，而不是currentListeners
    ensureCanMutateNextListeners()
    //將監(jiān)聽函數(shù)放入監(jiān)聽函數(shù)列表尾部
    nextListeners.push(listener)

    //返回一個函數(shù)，該函數(shù)可以從監(jiān)聽函數(shù)列表中刪除剛剛注冊的監(jiān)聽函數(shù)
    return function unsubscribe() {
      if (!isSubscribed) {
        return
      }

      isSubscribed = false

      ensureCanMutateNextListeners()
      const index = nextListeners.indexOf(listener)
      nextListeners.splice(index, 1)
    }
  }

  //觸發(fā)action的函數(shù)：每次觸發(fā)一個action，currentListeners中的所有函數(shù)都要執(zhí)行一遍
  function dispatch(action) {
    //如果action不是普通的對象，直接報錯
    if (!isPlainObject(action)) {
      throw new Error(
        "Actions must be plain objects. " +
        "Use custom middleware for async actions."
      )
    }
    //如果action沒有type屬性，直接報錯：說明action對象必須要包含type字段
    if (typeof action.type === "undefined") {
      throw new Error(
        "Actions may not have an undefined "type" property. " +
        "Have you misspelled a constant?"
      )
    }
    //如果當前正在觸發(fā)另外一個action，直接報錯
    if (isDispatching) {
      throw new Error("Reducers may not dispatch actions.")
    }

    try {
      //先將標志位置為true
      isDispatching = true
      //執(zhí)行傳入的reducer函數(shù)，該函數(shù)返回一個新的state對象，并賦值給currentState變量
      currentState = currentReducer(currentState, action)
    } finally {
      //reducer函數(shù)執(zhí)行完成后，將isDispatching恢復成false，方便下次action的觸發(fā)
      isDispatching = false
    }

    //每一次觸發(fā)一個action，所有的監(jiān)聽函數(shù)都要全部重新執(zhí)行一遍，
    //并且把上次得到的新的監(jiān)聽函數(shù)列表賦值成為當前的監(jiān)聽函數(shù)列表。這是一個懶操作，并不是在subscribe的時候就操作了，而是在dispatch的時候才操作
    const listeners = currentListeners = nextListeners
    for (let i = 0; i < listeners.length; i++) {
      const listener = listeners[i]
      listener()
    }

    //該dispatch函數(shù)的返回值是原來的action
    return action
  }

  //替換reducer函數(shù)：這個函數(shù)允許運行時動態(tài)替換最開始調用createStore函數(shù)時傳入的reducer，并且替換掉reducer之后，重新dispatch一個action，得到全新的currentState對象
  function replaceReducer(nextReducer) {
    //如果nextReducer不是函數(shù)，直接報錯
    if (typeof nextReducer !== "function") {
      throw new Error("Expected the nextReducer to be a function.")
    }
    //把新的reducer賦值給當前的currentReducer變量，得到一個全新的currentReducer
    currentReducer = nextReducer
    // 觸發(fā)一個初始action：
    // 1.這樣就可以完成一次監(jiān)聽函數(shù)列表的全部調用
    // 2.可以得到一個全新的currentState；
    dispatch({type: ActionTypes.INIT})
  }

function observable() {
    const outerSubscribe = subscribe
    return {
      /**
       * The minimal observable subscription method.
       * @param {Object} observer Any object that can be used as an observer.
       * The observer object should have a `next` method.
       * @returns {subscription} An object with an `unsubscribe` method that can
       * be used to unsubscribe the observable from the store, and prevent further
       * emission of values from the observable.
       */
      subscribe(observer) {
        if (typeof observer !== "object") {
          throw new TypeError("Expected the observer to be an object.")
        }

        function observeState() {
          if (observer.next) {
            observer.next(getState())
          }
        }

        observeState()
        const unsubscribe = outerSubscribe(observeState)
        return {unsubscribe}
      },

      [$$observable]() {
        return this
      }
    }
  }

初始化很簡單，一句代碼，直接調用一次dispatch，就會執(zhí)行所有的注冊函數(shù)，并且執(zhí)行reducer函數(shù)，生成初始化的state

//馬上內部調用一次初始化的操作，根據傳入的reducer函數(shù)，preloadedState生成一個全新的currentState和全新的reducer
  dispatch({type: ActionTypes.INIT})

總結一下就是：

createStore函數(shù)定義了幾個局部變量用于記錄狀態(tài)，主要包括currentState記錄數(shù)據狀態(tài)，currentListeners記錄注冊函數(shù)列表，currentReducer記錄當前的reducer函數(shù)。

定義了幾個函數(shù)用于修改上面的幾個局部變量：主要包括getState函數(shù)用于獲取currentState；replaceReducer用于替換currentReducer；subscribe用于修改currentListeners列表；dispatch用于觸發(fā)currentReducer執(zhí)行，生成新的currentState，并且，執(zhí)行currentListeners列表中的每一個函數(shù)；

完整解析請參考我的github：https://github.com/abczhijia/...，如果對您有幫助，歡迎star，有任何問題也請指正。

（完）