createStore创建一个 Redux store 来以存放应用中所有的 state，应用中应有且仅有一个 store。其中暴露 dispatch, subscribe, getState, replaceReducer 方法。

createStore概念图

源码及分析

/**
 * 初始化时，默认传递的 action，默认也应该返回初始化的 state
 */
export var ActionTypes = {
  INIT: '@@redux/INIT'
}
/**
 * 创建 store, 参数根 reducer, state 以及中间件
 */
export default function createStore(reducer, preloadedState, enhancer) {
//判断接受的参数个数，来指定 reducer 、 preloadedState 和 enhancer
  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
    enhancer = preloadedState
    preloadedState = undefined
  }
// 如果 enhancer 存在并且适合合法的函数，那么调用 enhancer，并且终止当前函数执行
  if (typeof enhancer !== 'undefined') {
    if (typeof enhancer !== 'function') {
      throw new Error('Expected the enhancer to be a function.')
    }
    return enhancer(createStore)(reducer, preloadedState)
  }
  if (typeof reducer !== 'function') {
    throw new Error('Expected the reducer to be a function.')
  }
// 储存当前的 currentReducer
  var currentReducer = reducer
// 储存当前的状态
  var currentState = preloadedState
 // 储存当前的监听函数列表
  var currentListeners = []
// 储存下一个监听函数列表
  var nextListeners = currentListeners
  var isDispatching = false

  // 这个函数可以根据当前监听函数的列表生成新的下一个监听函数列表引用
  function ensureCanMutateNextListeners() {
    if (nextListeners === currentListeners) {
      nextListeners = currentListeners.slice()
    }
  }
  
//这个函数可以获取当前的状态，createStore 中的 currentState 储存当前的状态树，这是一个闭包
  function getState() {
    return currentState
  }

  // 订阅事件，返回移除订阅函数，巧妙的利用了闭包
  function subscribe(listener) {
      // 判断传入的参数是否为函数
    if (typeof listener !== 'function') {
      throw new Error('Expected listener to be a function.')
    }
    var isSubscribed = true
    ensureCanMutateNextListeners()
    nextListeners.push(listener)
    return function unsubscribe() {
      if (!isSubscribed) {
        return
      }
      isSubscribed = false
      ensureCanMutateNextListeners()
      var index = nextListeners.indexOf(listener)
      nextListeners.splice(index, 1)
    }
  }
  // 执行 reducer，并触发订阅事件
  function dispatch(action) {
    // https://lodash.com/docs#isPlainObject
    if (!isPlainObject(action)) {
      throw new Error(
        'Actions must be plain objects. ' +
        'Use custom middleware for async actions.'
      )
    }

     // 判断 action 是否有 type｛必须｝ 属性
    if (typeof action.type === 'undefined') {
      throw new Error(
        'Actions may not have an undefined "type" property. ' +
        'Have you misspelled a constant?'
      )
    }

    // 如果正在 dispatch 则抛出错误
    if (isDispatching) {
      throw new Error('Reducers may not dispatch actions.')
    }

    // 对抛出 error 的兼容，但是无论如何都会继续执行 isDispatching = false 的操作
    try {
      isDispatching = true
      // 产生新的 state
      currentState = currentReducer(currentState, action)
    } finally {
      isDispatching = false
    }
    // 触发订阅的事件
    var listeners = currentListeners = nextListeners
    for (var i = 0; i < listeners.length; i++) {
      listeners[i]()
    }
    return action
  }
  /**
   * 动态替换 reducer
   */
  function replaceReducer(nextReducer) {
    if (typeof nextReducer !== 'function') {
      throw new Error('Expected the nextReducer to be a function.')
    }
    currentReducer = nextReducer
    dispatch({ type: ActionTypes.INIT })
  }
  dispatch({ type: ActionTypes.INIT })
  return {
    dispatch,
    subscribe,
    getState,
    replaceReducer
  }
}

首先定义了一个 ActionTypes 对象，它是一个 action，是一个 Redux 的私有 action，不允许外界触发，用来初始化 Store 的状态树和改变 reducers 后初始化 Store 的状态树。

参数

它可以接受三个参数，reducer、preloadedState、enhancer：

• reducer：是一个函数，返回下一个状态，接受两个参数：当前状态 和 触发的 action；
• preloadedState：初始状态对象，可以很随意指定，比如服务端渲染的初始状态，但是如果使用 combineReducers 来生成 reducer，那必须保持状态对象的 key 和 combineReducers 中的 key 相对应；
• enhancer：store 的增强器函数，可以指定为 第三方的中间件，时间旅行，持久化 等等，但是这个函数只能用 Redux 提供的 applyMiddleware 函数来生成；

返回

调用完函数它返回的接口是 dispatch、subscribe、getStatere、placeReducer，这也是我们开发中主要使用的几个接口。