combineReducers 的作用就是把多个reducer 合并成一个，疑问createStore的时候只接受一个reducer参数

combineReducers

 export default function combineReducers(reducers) {
  var reducerKeys = Object.keys(reducers)
  var finalReducers = {}
  for (var i = 0; i < reducerKeys.length; i++) {
    var key = reducerKeys[i]
    if (typeof reducers[key] === 'function') {
      finalReducers[key] = reducers[key]
    }
  }
  var finalReducerKeys = Object.keys(finalReducers)

  var sanityError
  try {
    assertReducerSanity(finalReducers)
  } catch (e) {
    sanityError = e
  }

  return function combination(state = {}, action) {
    if (sanityError) {
      throw sanityError
    }

    if (process.env.NODE_ENV !== 'production') {
      var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action)
      if (warningMessage) {
        warning(warningMessage)
      }
    }

    var hasChanged = false
    var nextState = {}
    for (var i = 0; i < finalReducerKeys.length; i++) {
      var key = finalReducerKeys[i]
      var reducer = finalReducers[key]
      var previousStateForKey = state[key]
      var nextStateForKey = reducer(previousStateForKey, action)
      if (typeof nextStateForKey === 'undefined') {
        var errorMessage = getUndefinedStateErrorMessage(key, action)
        throw new Error(errorMessage)
      }
      nextState[key] = nextStateForKey
      hasChanged = hasChanged || nextStateForKey !== previousStateForKey
    }
    return hasChanged ? nextState : state
  }
}

分解 reducerkey

var reducerKeys = Object.keys(reducers)
var finalReducers = {}
for (var i = 0; i < reducerKeys.length; i++) {
  var key = reducerKeys[i]
  if (typeof reducers[key] === 'function') {
    finalReducers[key] = reducers[key]
  }
}
var finalReducerKeys = Object.keys(finalReducers)

因为是包含多个reducer的obj,用先把key找出来,并做基本过滤得到finalReducers

assertReducerSanity

var sanityError
try {
  assertReducerSanity(finalReducers)
} catch (e) {
  sanityError = e
}

这里涉及到分支function assertReducerSanity, 也就是检查每个reducer是不是都相应的处理了初始state
和对随机type的处理

function assertReducerSanity(reducers) {
  Object.keys(reducers).forEach(key => {
    var reducer = reducers[key]
    var initialState = reducer(undefined, { type: ActionTypes.INIT })

    if (typeof initialState === 'undefined') {
      throw new Error(
        `Reducer "${key}" returned undefined during initialization. ` +
        `If the state passed to the reducer is undefined, you must ` +
        `explicitly return the initial state. The initial state may ` +
        `not be undefined.`
      )
    }

    var type = '@@redux/PROBE_UNKNOWN_ACTION_' + Math.random().toString(36).substring(7).split('').join('.')
    if (typeof reducer(undefined, { type }) === 'undefined') {
      throw new Error(
        `Reducer "${key}" returned undefined when probed with a random type. ` +
        `Don't try to handle ${ActionTypes.INIT} or other actions in "redux/*" ` +
        `namespace. They are considered private. Instead, you must return the ` +
        `current state for any unknown actions, unless it is undefined, ` +
        `in which case you must return the initial state, regardless of the ` +
        `action type. The initial state may not be undefined.`
      )
    }
  })
}

combination

return function combination(state = {}, action) {
   if (sanityError) {
     throw sanityError
   }

   if (process.env.NODE_ENV !== 'production') {
     var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action)
     if (warningMessage) {
       warning(warningMessage)
     }
   }

   var hasChanged = false
   var nextState = {}
   for (var i = 0; i < finalReducerKeys.length; i++) {
     var key = finalReducerKeys[i]
     var reducer = finalReducers[key]
     var previousStateForKey = state[key]
     var nextStateForKey = reducer(previousStateForKey, action)
     if (typeof nextStateForKey === 'undefined') {
       var errorMessage = getUndefinedStateErrorMessage(key, action)
       throw new Error(errorMessage)
     }
     nextState[key] = nextStateForKey
     hasChanged = hasChanged || nextStateForKey !== previousStateForKey
   }
   return hasChanged ? nextState : state
 }

返回的function shape和普通reducer保持一致 (state, action) => state

getUnexpectedStateShapeWarningMessage

开发环境下回多做一步检查:

function getUnexpectedStateShapeWarningMessage(inputState, reducers, action) {
  var reducerKeys = Object.keys(reducers)
  var argumentName = action && action.type === ActionTypes.INIT ?
    'initialState argument passed to createStore' :
    'previous state received by the reducer'

  if (reducerKeys.length === 0) {
    return (
      'Store does not have a valid reducer. Make sure the argument passed ' +
      'to combineReducers is an object whose values are reducers.'
    )
  }

  if (!isPlainObject(inputState)) {
    return (
      `The ${argumentName} has unexpected type of "` +
      ({}).toString.call(inputState).match(/\s([a-z|A-Z]+)/)[1] +
      `". Expected argument to be an object with the following ` +
      `keys: "${reducerKeys.join('", "')}"`
    )
  }

  var unexpectedKeys = Object.keys(inputState).filter(key => !reducers.hasOwnProperty(key))

  if (unexpectedKeys.length > 0) {
    return (
      `Unexpected ${unexpectedKeys.length > 1 ? 'keys' : 'key'} ` +
      `"${unexpectedKeys.join('", "')}" found in ${argumentName}. ` +
      `Expected to find one of the known reducer keys instead: ` +
      `"${reducerKeys.join('", "')}". Unexpected keys will be ignored.`
    )
  }
}

检查是否包含多个reducer, state的字段是否和reducer的key对应

这里就说明了 combineReducer的基本形态, key之间的对应关系

// explain the combineReducers

// function reducer(state = {}, action) {
//   return {
//     a: doSomethingWithA(state.a, action),
//     b: processB(state.b, action),
//     c: c(state.c, action)
//   }
// }

state对比

var hasChanged = false
var nextState = {}
for (var i = 0; i < finalReducerKeys.length; i++) {
  var key = finalReducerKeys[i]
  var reducer = finalReducers[key]
  var previousStateForKey = state[key]
  var nextStateForKey = reducer(previousStateForKey, action)
  if (typeof nextStateForKey === 'undefined') {
    var errorMessage = getUndefinedStateErrorMessage(key, action)
    throw new Error(errorMessage)
  }
  nextState[key] = nextStateForKey
  hasChanged = hasChanged || nextStateForKey !== previousStateForKey
}

这里对传入combineReducers的 state 每个字段(var previousStateForKey = state[key])都和
处理后的新state(var nextStateForKey = reducer(previousStateForKey, action))对比
如果state里对应的字段内容相同,hasChanged 为false

返回值

return hasChanged ? nextState : state

调用combineReducers 后得到的就是一个state, 可能是新的,可能是传进来的那个旧的