摘要：是這個(gè)函數(shù)名翻譯為獲取未定義的錯(cuò)誤信息對(duì)于返回一定要很明確的返回之前的這樣就可以忽略一個(gè)如果你想這個(gè)沒(méi)有返回值你可以返回而不是獲取與預(yù)期不符的的結(jié)構(gòu)警告信息聲明結(jié)構(gòu)初始化時(shí)返回如果傳給的是你一定要很明確地返回初始初始可能是如果你不想給這

import { ActionTypes } from "./createStore"
import isPlainObject from "lodash/isPlainObject"
import warning from "./utils/warning"
/**
 * ActionTypes 是這個(gè)
 * export const ActionTypes = {
 *       INIT: "@@redux/INIT"
 *  }
 */
function getUndefinedStateErrorMessage(key, action) { //函數(shù)名翻譯為獲取未定義的state錯(cuò)誤信息
  const actionType = action && action.type
  const actionName = (actionType && `"${actionType.toString()}"`) || "an action"

  return (
    `Given action ${actionName}, reducer "${key}" returned undefined. ` +
    `To ignore an action, you must explicitly return the previous state. ` +
    `If you want this reducer to hold no value, you can return null instead of undefined.`
  )
  //對(duì)于action xxx ,reducer yyy 返回undefined
  //一定要很明確的返回之前的state,這樣就可以忽略一個(gè)action
  //如果你想這個(gè)reducer沒(méi)有返回值,你可以返回null而不是undefined
}

//獲取與預(yù)期不符的state的結(jié)構(gòu)警告信息
function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
  const reducerKeys = Object.keys(reducers)
  const argumentName = action && action.type === ActionTypes.INIT ?
    "preloadedState 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("", "")}"`
    )
  }

  const unexpectedKeys = Object.keys(inputState).filter(key =>
    !reducers.hasOwnProperty(key) &&
    !unexpectedKeyCache[key]
  )

  unexpectedKeys.forEach(key => {
    unexpectedKeyCache[key] = true
  })

  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結(jié)構(gòu)
function assertReducerShape(reducers) {
  Object.keys(reducers).forEach(key => {
    const reducer = reducers[key]
    const 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. If you don"t want to set a value for this reducer, ` +
        `you can use null instead of undefined.`
      )
      //reducer xxx 初始化時(shí)返回undefined, 如果傳給reducer的state是undefined,你一定要
      //很明確地返回初始state, 初始state可能是undefined, 如果你不想給這個(gè)reducer
      //設(shè)置value值,你可以用null代替undefined
    }

    const 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, but can be null.`
      )
      //當(dāng)probed(探索)隨機(jī)的type時(shí),reducer xxx 返回undefined. 不要在"redux/*"命名空間操作
      // ${ActionTypes.INIT},也就是"@@redux/INIT", 或任意的action.他們是私有的. 
      //相反,對(duì)于未知的action,你應(yīng)該返回當(dāng)前的state,除非它是undefined.不管action的type是什么,
      //你都應(yīng)該返回初始的state,出示的state可能不是undefined,但可以是null
    }
  })
}

/**
 * Turns an object whose values are different reducer functions, into a single
 * reducer function. It will call every child reducer, and gather their results
 * into a single state object, whose keys correspond to the keys of the passed
 * reducer functions.
 *
 * 將一個(gè)value值是不同reducer函數(shù)的對(duì)象變成一個(gè)單一的reducer函數(shù),它將會(huì)調(diào)用每一個(gè)子reducer
 * 將它們的結(jié)果組合成一個(gè)單一的state對(duì)象,這個(gè)對(duì)象的key對(duì)應(yīng)傳進(jìn)來(lái)的reducer的key
 * 
 * @param {Object} reducers An object whose values correspond to different
 * reducer functions that need to be combined into one. One handy way to obtain
 * it is to use ES6 `import * as reducers` syntax. The reducers may never return
 * undefined for any action. Instead, they should return their initial state
 * if the state passed to them was undefined, and the current state for any
 * unrecognized action.
 *
 * reducers是一個(gè)對(duì)應(yīng)不同reducer函數(shù)的對(duì)象,這些reducer函數(shù)需要組合成一個(gè)reducer.
 * 一個(gè)很方便獲取到它的方法就是使用ES6 的`import * as reducers`語(yǔ)法,reducer可能不會(huì)
 * 返回undefined.相反,它們應(yīng)該返回初始的state. 如果傳給它們的state是undefined,任何
 * 不被識(shí)別的action都會(huì)返回當(dāng)前的state
 * 
 * @returns {Function} A reducer function that invokes every reducer inside the
 * passed object, and builds a state object with the same shape.
 * 
 * 返回一個(gè)reducer函數(shù),會(huì)觸發(fā)傳進(jìn)來(lái)的對(duì)象中的每一個(gè)reducer,建立一個(gè)有相同結(jié)構(gòu)的state對(duì)象
 */
export default function combineReducers(reducers) {
  const reducerKeys = Object.keys(reducers) //將reducers的key提取為數(shù)組
  const finalReducers = {}
  for (let i = 0; i < reducerKeys.length; i++) {
    const key = reducerKeys[i]

    if (process.env.NODE_ENV !== "production") {
      if (typeof reducers[key] === "undefined") {
        warning(`No reducer provided for key "${key}"`)
      }
    }

    if (typeof reducers[key] === "function") {
      finalReducers[key] = reducers[key]
    }
  }
  const finalReducerKeys = Object.keys(finalReducers)

  let unexpectedKeyCache
  if (process.env.NODE_ENV !== "production") {
    unexpectedKeyCache = {}
  }

  let shapeAssertionError
  try {
    assertReducerShape(finalReducers)
  } catch (e) {
    shapeAssertionError = e
  }

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

    if (process.env.NODE_ENV !== "production") {
      const warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache)
      if (warningMessage) {
        warning(warningMessage)
      }
    }

    let hasChanged = false
    const nextState = {}
    for (let i = 0; i < finalReducerKeys.length; i++) {  //finalReducerKeys就是reducers的key值復(fù)制了一份
      const key = finalReducerKeys[i]   //第 i 個(gè)key
      const reducer = finalReducers[key]  //key所對(duì)應(yīng)的reducer
      const previousStateForKey = state[key] //把key作為屬性賦給state
      const nextStateForKey = reducer(previousStateForKey, action)  //返回新的state
      if (typeof nextStateForKey === "undefined") {
        const errorMessage = getUndefinedStateErrorMessage(key, action)
        throw new Error(errorMessage)
      }
      nextState[key] = nextStateForKey  //給nextState添加key屬性,并賦值,key與reducer名字相同
      hasChanged = hasChanged || nextStateForKey !== previousStateForKey
    }
    return hasChanged ? nextState : state
  }
}

源碼解析請(qǐng)參考https://segmentfault.com/a/11...