React里父子组件可以通过props通信,兄弟组件通信需要把数据传递给父组件,再由父组件传递给另一个子组件。以兄弟组件通信为需求,写一个Redux。
export const INCREMENT = 'INCREMENT';
export const DECREMENT = 'DECREMENT';
export default function reducer(state = {number: 0},action) {
switch (action.type) {
case types.INCREMENT:
return {
number: state.number + 1
};
case types.DECREMENT:
return {
number: state.number - 1
};
default:
return state;
}
}
const store = {
listeners:[],
getState(){
return this.state;
},
dispatch(action){
this.state = reducer(this.state,action);
this.listeners.forEach(listener=>listener());
},
subscribe(listener){
this.listeners.push(listener);
return function () {
this.listeners = listeners.filter(item=>item!==listener);
}
}
};
store.dispatch({}); //初始化state
export default store;
export default class Number extends React.Component{
componentDidMount(){
this.unsubscribe = store.subscribe(()=>this.setState({}));
}
componentWillUnmount(){
this.unsubscribe();
}
render(){
return (
<div>
{store.getState().number}
</div>
)
}
}
export default class Counter extends React.Component{
render(){
return (
<div>
<button onClick={()=>store.dispatch({type:types.INCREMENT})}>+</button>
<button onClick={()=>store.dispatch({type:types.DECREMENT})}>-</button>
</div>
)
}
}
上面实现了兄弟组件的通信,但是复用性差,而且store里的listeners不应该被外界修改。
export default function createStore(reducer) {
let state;
let listeners = [];
function getState() {
return state;
}
function dispatch(action) {
state = reducer(state,action);
listeners.forEach(listener=>listener());
}
dispatch({});
function subscribe(listener) {
listeners.push(listener);
return function () {
const index = listeners.indexOf(listener);
listeners.splice(index,1);
}
}
return {
getState,dispatch,subscribe
}
}
export default function combineReducers(reducers) {
return function (state = {},action) {
let newState = {};
for(const key in reducers){
newState[key] = reducers[key](state[key],action);
}
return newState;
}
};
<button onClick={()=>store.dispatch({type:types.INCREMENT})}>+</button>
export default class Counter extends React.Component{
action = bindActionCreators(actions,store.dispatch)
render(){
return (
<div>
<button onClick={this.action.increment}>+</button>
<button onClick={this.action.decrement}>-</button>
</div>
)
}
}
export default {
increment() {
return {
type: 'INCREMENT'
}
},
decrement() {
return {
type: 'DECREMENT'
}
},
changeText(value) {
return {
type: 'CHANGE_TEXT',
text: value
}
}
}
export default function bindActionCreators(actions,dispatch) {
let boundActionCreators = {};
for (const attr in actions){
boundActionCreators[attr] = function () {
const action = actions[attr](...arguments);
dispatch(action);
}
}
return boundActionCreators;
}
export default class Provider extends Component {
static childContextTypes = {
store:propTypes.object
}
getChildContext(){
return {
store:this.props.store
}
}
render(){
return this.props.children
}
}
export default function (mapStateToProps,mapDispatchToProps) {
return function (Component) {
return class ProxyComponent extends React.Component{
static contextTypes = {
store:propTypes.object
}
constructor(props,context){
super(props,context);
this.store = context.store;
this.state = mapStateToProps(this.store.getState());
}
componentDidMount(){
const store = this.store;
this.unsubscribe = store.subscribe(()=>this.setState(mapStateToProps(store.getState())));
}
componentWillUnmount(){
this.unsubscribe();
}
render(){
const actions = bindActionCreators(mapDispatchToProps,this.store.dispatch);
return <Component
{...actions}
{...this.state}
/>
}
}
}
}
ReactDOM.render(
<Provider store={store}>
<Counter/>
<Number/>
</Provider>, document.getElementById('root'));
class Counter extends React.Component{
render(){
return (
<div>
<button onClick={()=>this.props.increment()}>+</button>
<button onClick={()=>this.props.decrement()}>-</button>
</div>
)
}
}
export default connect(state=>state.counter,actions)(Counter);
class Number extends React.Component{
render(){
return (
<div>
{this.props.number}
</div>
)
}
}
export default connect(state=>state.counter,actions)(Number);
最后实现redux中间件。Redux中间件是洋葱模型,和Koa的中间件原理一样。
开发中会有多个中间件,中间件是函数,要把第一个中间件的结果作为参数传递给第二个中间件,依次执行,先实现这个compose函数
function compose(...fns) {
if (fns.length===0) return arg=>arg;
return fns.reduce((prev, next, index) => (...args) => prev(next(...args)));
}
export default compose;
export default function applyMiddleware(...middlewares) {
return function (createStore) {
return function (reducers) {
const store = createStore(reducers);
let dispatch = store.dispatch;
let middlewareApi = {
dispatch:action=>dispatch(action),
getState:store.getState
};
middlewares = middlewares.map(middleware=>middleware(middlewareApi));
dispatch = compose(...middlewares)(dispatch);
return {
...store,
dispatch
};
};
}
}
const store = applyMiddleware(thunk, logger)(createStore)(reducers);
Redux是管理页面状态和数据传递,从最开始组件通信的问题,一步步的实现类似一个Redux的库,方便我们学习Redux和理解Redux原理。