Interpret some of the Redux source code through ES6 writing

This article mainly introduces the interpretation of part of the Redux source code through ES6 writing. It has a certain reference value. Now I share it with you. Friends in need can refer to it.

In the Redux source code, there are mainly Four filescreateStore,applyMiddleware,bindActionCreators,combineRedures

createStore.js

export default function createStore(reducer, preloadedState, enhancer), where the reducer function is used to calculate rules, preloadedState is the initial state, and enhancer (high-order combination function) is used to enhance the store object and return the enhanced store

createStore will encapsulate private variables through closures, and the state and other states in the store will be saved

//Return to the interface exposed by the store

return {
dispatch, //唯一一个可以改变 state 的哈按时
subscribe, //订阅一个状态改变后，要触发的监听函数
getState, // 获取 store 里的 state
replaceReducer, //Redux热加载的时候可以替换 Reducer
[$$observable]: observable //对象的私有属性，供内部使用
}

If preloadedState is a function, and enhancer is null, then exchange the two, the enhancer must be function

if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
enhancer = preloadedState // 把 preloadedState 赋值给 enhancer
preloadedState = undefined // 把 preloadedState 赋值为 undefined
}

function subscribe(listener) mainly returns an unsubscription function through the observer mode. Subscription is completed through an array queue, before adding or canceling the listener. A subscription snapshot will be saved

In function dispatch(action),

//Mark dispatch is running

isDispatching = true

//Execute the current Reducer function to return the new state

currentState = currentReducer(currentState, action)

Then traverse all subscription array queues

//所有的的监听函数赋值给 listeners
var listeners = currentListeners = nextListeners
 
//遍历所有的监听函数
for (var i = 0; i < listeners.length; i++) {
 
// 执行每一个监听函数
listeners[i]()

applyMiddleware

return a function that can accept the createStore method as a parameter and wrap the returned store's dispatch method again

return function (reducer, preloadedState, enhancer) {
var store = createStore(reducer, preloadedState, enhancer);
var _dispatch = store.dispatch; //获取dispatch
var chain = [];
 
var middlewareAPI = {
getState: store.getState,
dispatch: function dispatch(action) {
return _dispatch(action);
}
};
chain = middlewares.map(function (middleware) { //遍历middlewares绑定
return middleware(middlewareAPI);
});
_dispatch = compose.apply(undefined, chain)(store.dispatch);
 
return _extends({}, store, {
dispatch: _dispatch
});
};

bindActionCreators

Bind action and dispatch:

bindActionCreators(actionCreators, dispatch)

// 判断 actionCreators 是一个函数
if (typeof actionCreators === 'function') {
// 调用 bindActionCreator ， 返回包装后的 actionCreators , 包装后 actionCreators 可以直接 dispath
return bindActionCreator(actionCreators, dispatch);
}
如果是Object对象的话，遍历Object的key,获取Oobject每个key对应的value
// 获取 actionCreators 所有的 key
var keys = Object.keys(actionCreators);
// 用来保存新 转换后的 actionCreators
var boundActionCreators = {};
 
// 遍历 所有的 actionCreators keys
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
// 获取当前的 actionCreator
var actionCreator = actionCreators[key];
// 当前的 actionCreator 是一个函数
if (typeof actionCreator === &#39;function&#39;) {
// 调用 bindActionCreator ， 返回包装后的 actionCreators , 包装后 actionCreators 可以直接 dispath
boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
}

combineReducers

Get the object passed in by combineReduces and get all the key collection finalReducerKeys of the object.

<Provider store={store}>
</Provider>

Get the state collection, traverse the reducers collection to find the state in the current reducers, and then compare it with the new state obtained after the reducer. If there is a change, return the state

//循环遍历 finalReducerKeys ,执行所有的 reducer, 所以大家一定不要有相同的 action.type ,否则你的状态一定会混乱的
for (var i = 0; i < finalReducerKeys.length; i++) {
//获取当前的 key
var key = finalReducerKeys[i]
//获取当前 reducer
var reducer = finalReducers[key]
//获取当前 key 的 state
var previousStateForKey = state[key]
//执行 reducer ，获取 state
var nextStateForKey = reducer(previousStateForKey, action)
//判断执行完Reducer后, 返回回来的 nextStateForKey 是 undefined
if (typeof nextStateForKey === &#39;undefined&#39;) {
//得到 Undefined 状态的错误消息
var errorMessage = getUndefinedStateErrorMessage(key, action)
//抛出异常
throw new Error(errorMessage)
}
//赋值给 nextState
nextState[key] = nextStateForKey
//判断 state 是否经过 Reducer 改变了
hasChanged = hasChanged || nextStateForKey !== previousStateForKey
}
//返回state
return hasChanged ? nextState : state

The above is this article The entire content, I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

This object in Javascript

Similarities and differences between foreach, for in, for of

Basic introduction to React-Reflux

The above is the detailed content of Interpret some of the Redux source code through ES6 writing. For more information, please follow other related articles on the PHP Chinese website!