react-redux原始碼解析

一、 react-redux 和 redux是兩個東西。在做react專案的時候，一般用react-redux和redux搭配起來開發。redux主要是做資料、狀態的管理，而react-redux主要是方便資料redux在react使用。

二、原始碼解析

1)、 入口檔案index.js

import Provider, { createProvider } from `./components/Provider`
import connectAdvanced from `./components/connectAdvanced`
import connect from `./connect/connect`

/*
    對外暴露的API
    Provider,
    createProvider,
    connectAdvanced,
    connect,
    根據每個APi追溯其源頭
 */
export { Provider, createProvider, connectAdvanced, connect }

2)、Provider.js 

import { Component, Children } from `react`
import PropTypes from `prop-types`
import { storeShape, subscriptionShape } from `../utils/PropTypes`
import warning from `../utils/warning`

let didWarnAboutReceivingStore = false
function warnAboutReceivingStore() {
  if (didWarnAboutReceivingStore) {
    return
  }
  didWarnAboutReceivingStore = true

  warning(
    `<Provider> does not support changing `store` on the fly. ` +
    `It is most likely that you see this error because you updated to ` +
    `Redux 2.x and React Redux 2.x which no longer hot reload reducers ` +
    `automatically. See https://github.com/reduxjs/react-redux/releases/` +
    `tag/v2.0.0 for the migration instructions.`
  )
}
// 對外暴露 createProvider 方法 。
export function createProvider(storeKey = `store`, subKey) {
    const subscriptionKey = subKey || `${storeKey}Subscription`

    // 定義一個Provider類
    class Provider extends Component {
        getChildContext() {
          return { [storeKey]: this[storeKey], [subscriptionKey]: null }
        }

        constructor(props, context) {
          super(props, context)
          this[storeKey] = props.store;
        }
        // 其實就是頂層元件
        render() {
          return Children.only(this.props.children)
        }
    }

    if (process.env.NODE_ENV !== `production`) {
      Provider.prototype.componentWillReceiveProps = function (nextProps) {
        if (this[storeKey] !== nextProps.store) {
          warnAboutReceivingStore()
        }
      }
    }

    Provider.propTypes = {
        store: storeShape.isRequired,
        children: PropTypes.element.isRequired,
    }
    Provider.childContextTypes = {
        [storeKey]: storeShape.isRequired,
        [subscriptionKey]: subscriptionShape,
    }

    return Provider
}

// 對外暴露Provider 元件   createProvider() => Provider;
export default createProvider()

3)、connect.js

import connectAdvanced from `../components/connectAdvanced`
import shallowEqual from `../utils/shallowEqual`
import defaultMapDispatchToPropsFactories from `./mapDispatchToProps`
import defaultMapStateToPropsFactories from `./mapStateToProps`
import defaultMergePropsFactories from `./mergeProps`
import defaultSelectorFactory from `./selectorFactory`

/*
  connect is a facade over connectAdvanced. It turns its args into a compatible
  selectorFactory, which has the signature:

    (dispatch, options) => (nextState, nextOwnProps) => nextFinalProps
  
  connect passes its args to connectAdvanced as options, which will in turn pass them to
  selectorFactory each time a Connect component instance is instantiated or hot reloaded.

  selectorFactory returns a final props selector from its mapStateToProps,
  mapStateToPropsFactories, mapDispatchToProps, mapDispatchToPropsFactories, mergeProps,
  mergePropsFactories, and pure args.

  The resulting final props selector is called by the Connect component instance whenever
  it receives new props or store state.
 */

function match(arg, factories, name) {
  for (let i = factories.length - 1; i >= 0; i--) {
    const result = factories[i](arg)
    if (result) return result
  }

  return (dispatch, options) => {
    throw new Error(`Invalid value of type ${typeof arg} for ${name} argument when connecting component ${options.wrappedComponentName}.`)
  }
}

function strictEqual(a, b) { return a === b }

// createConnect with default args builds the `official` connect behavior. Calling it with
// different options opens up some testing and extensibility scenarios
// 對外暴露crateConnect方法
export function createConnect({
  connectHOC = connectAdvanced,
  mapStateToPropsFactories = defaultMapStateToPropsFactories,
  mapDispatchToPropsFactories = defaultMapDispatchToPropsFactories,
  mergePropsFactories = defaultMergePropsFactories,
  selectorFactory = defaultSelectorFactory
} = {}) {
  // 返回一個connect函式。 接收 mapStateToProps, mapDispatchToProps, megeProps等等引數
  return function connect(
    mapStateToProps,
    mapDispatchToProps,
    mergeProps,
    {
      pure = true,
      areStatesEqual = strictEqual,
      areOwnPropsEqual = shallowEqual,
      areStatePropsEqual = shallowEqual,
      areMergedPropsEqual = shallowEqual,
      ...extraOptions
    } = {}
  ) {
    const initMapStateToProps = match(mapStateToProps, mapStateToPropsFactories, `mapStateToProps`)
    const initMapDispatchToProps = match(mapDispatchToProps, mapDispatchToPropsFactories, `mapDispatchToProps`)
    const initMergeProps = match(mergeProps, mergePropsFactories, `mergeProps`)
    // 呼叫connectHOC方法
    return connectHOC(selectorFactory, {
      // used in error messages
      methodName: `connect`,

       // used to compute Connect`s displayName from the wrapped component`s displayName.
      getDisplayName: name => `Connect(${name})`,

      // if mapStateToProps is falsy, the Connect component doesn`t subscribe to store state changes
      shouldHandleStateChanges: Boolean(mapStateToProps),

      // passed through to selectorFactory
      initMapStateToProps,
      initMapDispatchToProps,
      initMergeProps,
      pure,
      areStatesEqual,
      areOwnPropsEqual,
      areStatePropsEqual,
      areMergedPropsEqual,

      // any extra options args can override defaults of connect or connectAdvanced
      ...extraOptions
    })
  }
}

export default createConnect()