资讯专栏INFORMATION COLUMN

上云采购季！| 爆款云服务器低至4.6元/月，首单享0.9折

免费试用
首页/文章专栏/redux以及react-redux简单实现

redux以及react-redux简单实现

elliott_hu / 1417人阅读

摘要：写在前头简介随着单页应用开发日趋复杂，需要管理比任何时候都要多的状态。如果一个的变化会引起另一个变化，那么当变化时，就可能引起对应以及另一个的变化，依次地，可能会引起另一个的变化。一些库如试图在视图层禁止异步和直接操作来解决这个问题。

写在前头 
redux 简介

  随着 JavaScript 单页应用开发日趋复杂，JavaScript 需要管理比任何时候都要多的 state （状态）。 这些 state 可能包括服务器响应、缓存数据、本地生成尚未持久化到服务器的数据，也包括 UI 状态，如激活的路由，被选中的标签，是否显示加载动效或者分页器等等。

  管理不断变化的 state 非常困难。如果一个 model 的变化会引起另一个 model 变化，那么当 view 变化时，就可能引起对应 model 以及另一个 model 的变化，依次地，可能会引起另一个 view 的变化。直至你搞不清楚到底发生了什么。state 在什么时候，由于什么原因，如何变化已然不受控制。 当系统变得错综复杂的时候，想重现问题或者添加新功能就会变得举步维艰。

  如果这还不够糟糕，考虑一些来自前端开发领域的新需求，如更新调优、服务端渲染、路由跳转前请求数据等等。前端开发者正在经受前所未有的复杂性，难道就这么放弃了吗？当然不是。

  这里的复杂性很大程度上来自于：我们总是将两个难以理清的概念混淆在一起：变化和异步。 如果把二者分开，能做的很好，但混到一起，就变得一团糟。一些库如 React 试图在视图层禁止异步和直接操作 DOM 来解决这个问题。美中不足的是，React 依旧把处理 state 中数据的问题留给了我们自己。而 redux 就可以来帮我管理这些状态；

demo 演示

demo 结构树
├── config-overrides.js
├── .gitignore
├── package.json
├── package-lock.json
├── public
│   ├── favicon.ico
│   ├── index.html
│   └── manifest.json
├── README.md
└── src
    ├── App.js
    ├── Demo
    │   ├── actionCreate.js
    │   ├── Demo.jsx
    │   ├── react-redux.js
    │   ├── reducer.js
    │   ├── redux.js
    │   ├── style.css
    │   └── thunk.js
    └── index.js
一、 redux API createStore 的实现

  首先我们先结合 reducer 以及 action 的知识简单实现开头展示的 demo, 并逐步揭晓 createStore 的神秘面纱；

1.1 准备工作：
创建 reducer 并导出 reducer
// reducer.js
const initState = { user: "qianyin", age: 18, sex: "男" };
export const reducer = (state=initState, action) => {
  switch(action.type){
    case "USER_UPDATE":
      return {...state, ...action.payload};
    case "AGE_GROW":
      return {...state, age: state.age + 1};
    case "SEX_UPDATE":
      return {...state, ...action.payload};
    default:
      return state;
  }
}
创建 action 创建函数
// actionCreate.js
export const changeUser = (user) => {
  return {
    payload:{user},
    type: "USER_UPDATE",
  };
}

export const changeAge = () => {
  return { type: "AGE_GROW" };
}
通过 react 在页面上预先绘制出基本的元素
/* style.css */
.btn{
  height: 31px;

}
.input{
  height: 25px;
}
// Demo.jsx
import React from "react";
import "./style.css";

export default class Demo extends React.Component{
  onChange = () => {}
  onClick = () => {}
  render(){
    return (
      

        
user: xxx, age: xxx

        user: 
        
         
        
      

    );
  }
}
最终页面将渲染如下：

1.2 demo 的初次实现代码

创建全局状态 state；

创建监听队列；

针对监听队列，新增函数用于将指定监听对象添加到队列中；

在函数 dispatch 中执行 reducer 将返回值作为新的 state, 同时依次执行监听对象；

默认执行一次 dispatch 给定一个 type 相对唯一的 action， 目的是为了匹配 reducer 的默认状态值，从而实现对 redux state 的初始化；

在组件 Demo 通过在函数 update 使用 this.setState 将全局 state 保存到 react state 中，并将函数 update 添加到监听队列中；从而使得当我们一旦试图通过 dispatch 修改全局状态时，能够及时更新 react state 最终触发 react 生命周期 render；

在 react 生命周期 componentDidMount 中我们除了将 update 添加到监听队列以外，还需手动执行一次 update 其主要目的就是为了首次初始化 react state;

// Demo.jsx
import React from "react";
import { changeAge, changeUser } from "./actionCreate";
import { reducer } from "./reducer";
import "./style.css";

let state;
const listeners = [];
const subscribe = (listener) => {
  listeners.push(listener);
}
const dispatch = (action) => {
  state = reducer(state, action);
  console.log(state);
  listeners.forEach(v => v());
}
dispatch({type: "%$&HJKAJJHDJHJ"});

export default class Demo extends React.Component{
  state = {user: "xxx", age: "xxx"};
  componentDidMount(){
    subscribe(this.update);
    this.update();
  }

  update = () => {
    this.setState(state);
  }

  onChange = (e) => {
    dispatch(changeUser(e.target.value));
  }

  onClick = () => {
    dispatch(changeAge());
  }

  render(){
    return (
      

        
user: {this.state.user}, age: {this.state.age}

        user: 
        
         
        
      

    );
  }
}
1.3 API createStore 的实现

  其实上文的代码中对于 createStore 的实现原理已经基本描述清除，下面我们只是单纯的对代码进行了简单的封装；当然为了能够获取到 state 我们专门增加了一个函数 getState 来实现它；

createStore 函数实现
// redux.js

export const createStore = (reducer) => {
  // 声明常量
  let state;
  const listeners = [];

  // 获取状态
  const getState = () => {
    return state;
  }

  // 添加监听对象
  const subscribe = (listener) => {
    listeners.push(listener);
  }

  // [1]执行reducer修改状态 [2]遍历执行监听对象
  const dispatch = (action) => {
    state = reducer(state, action);
    listeners.forEach(v => v());
  }

  // 初始化 state
  dispatch({type: "%$&HJKAJJHDJHJ"});
    
  // 暴露接口
  return {getState, subscribe, dispatch};
}
调用 createStore 并对 demo 进行修改
// Demo.jsx
import React from "react";
import "./style.css";
import { changeAge, changeUser } from "./actionCreate";
import { reducer } from "./reducer";
import { createStore } from "./redux";

const store = createStore(reducer);

export default class Demo extends React.Component{
  state = {user: "xxx", age: "xxx"};
  componentDidMount(){
    store.subscribe(this.update);
    this.update();
  }

  update = () => {
    this.setState(store.getState());
  }

  onChange = (e) => {
    store.dispatch(changeUser(e.target.value));
  }

  onClick = () => {
    store.dispatch(changeAge());
  }

  render(){
    return (
      

        
user: {this.state.user}, age: {this.state.age}

        user: 
        
         
        
      

    );
  }
}
二、 react-redux API Provider 的实现

  在 react 中大多数情况下我们需要将状态传递给后代组件进行使用的，当然通过 props 是可以实现状态从父级到子级的传递，但是当状态需要传递的层级比较深的情况下再使用 props 就显得无力了，那么在 react-redux 中它是如何实现对 store 的传递的呢？

2.1 react context 的引入
在 App.js 中创建 store 并通过 context 传递 store
// App.js
import React, { Component } from "react";
import propTypes from "prop-types";
import { createStore } from "./Demo/redux";
import { reducer } from "./Demo/reducer";
import Demo from "./Demo/Demo";

// 创建 store
const store = createStore(reducer);

class App extends Component {
  // 声明 childContextTypes 状态属性类型
  static childContextTypes = {
    store: propTypes.object
  };
  // 设置 childContext
  getChildContext(){
    return {store}
  }
  render() {
    return ;
  }
}
export default App;
在子组件 Demo 中通过 context 获取 store 并对代码进行简单修改
// Demo.jsx
import React from "react";
import propTypes from "prop-types";
import "./style.css";
import { changeAge, changeUser } from "./actionCreate";

export default class Demo extends React.Component{
  // 设置 context 状态值类型
  static contextTypes = {
    store: propTypes.object
  };

  constructor(props, context){
    super(props, context);
    // 获取store
    this.store = context.store;
    this.state = {user: "xxx", age: "xxx"};
  }
  
  componentDidMount(){
    this.store.subscribe(this.update);
    this.update();
  }

  update = () => {
    this.setState(this.store.getState());
  }

  onChange = (e) => {
    this.store.dispatch(changeUser(e.target.value));
  }

  onClick = () => {
    this.store.dispatch(changeAge());
  }

  render(){
    return (
      

        
user: {this.state.user}, age: {this.state.age}

        user: 
        
         
        
      

    );
  }
}
2.2 封装代码实现 Provider

  通过 react context 我们实现了对 store 的传递，到这里 Provider 的功能以及实现原理基本上应该算是清晰了，无非就是对组件进行包裹同时通过 react context 来传递共享 store；那么接下来我们通过对代码的封装来实现 Provider 组件；

Provider 组件：实现对 store 的传递
// react-redux.js
import React from "react";
import propTypes from "prop-types";

export class Provider extends React.Component{
  // 设置 childContext 状态值类型
  static childContextTypes = {
    store: propTypes.object
  };

  // 设置 childContext
  getChildContext(){
    return {store: this.props.store}
  }
  
  render(){
    return this.props.children;
  }
}
重写 App.js： 对 Provider 组件的调用
// App.js
import React, { Component } from "react";
import { createStore } from "./Demo/redux";
import { Provider } from "./Demo/react-redux";
import { reducer } from "./Demo/reducer";
import Demo from "./Demo/Demo";

// 创建 store
const store = createStore(reducer);

class App extends Component {
  render() {
    // 调用接口 Provider
    return ;
  }
}
export default App;
三、 react-redux API connect 高阶组件的实现

  上文中在后代组件如果需要获取 store 则需要手动通过获取 react context 来调用 store 并且需要显性的调用 store 内部的方法来进行一些操作；接下来我们来实现这么一个高阶组件 connect，我们只需要提供所需的 redux state 以及 action 创建函数，即可通过 props 获取到相应的 redux state , 并且允许直接通过 props 调用action 创建函数来试图修改 redux state ；

创建高阶组件 connect
// react-redux.js
export const connect = (mapStateToProps, mapDispatchToProps) => (Component) => {
  return class NewComponent extends React.Component{
    render(){
      return 
    }
  }
}
获取store
// react-redux.js
export const connect = (mapStateToProps, mapDispatchToProps) => (Component) => {
  return class NewComponent extends React.Component{
    // 设置 context 状态值类型
    static contextType = {
      store: propTypes.object
    };
      // [1]获取 store [2]设置空 react state
    constructor(props, context){
      super(props, context);
      this.store = context.store;
      this.state = {};
    }
    render(){
      return 
    }
  }
}
添加监听对象，并尝试通过 props 将状态传递给子组件
export const connect = (mapStateToProps, mapDispatchToProps) => (Component) => {
  return class NewComponent extends React.Component{
    static contextType = {
      store: propTypes.object
    };
    constructor(props, context){
      super(props, context);
      this.store = context.store;
      this.state = {};
    }
      // [1]添加监听对象 [2]手动执行监听对象，初始化 react state
    componentDidMount(){
      this.store.subscribe(this.update);
      this.update();
    }
  
    update = () => {
      // 获取全部redux state 并添加到 react state
      const state = this.store.getState();
      this.setState(state);
    }
    render(){
      // 通过 props 将 react state 全部传给子组件
      return 
    }
  }
}
通过 mapStateToProps 获取指定 redux state
// react-redux.js
export const connect = (mapStateToProps, mapDispatchToProps) => (Component) => {
  return class NewComponent extends React.Component{
    static contextType = {
      store: propTypes.object
    };
    constructor(props, context){
      super(props, context);
      this.store = context.store;
      this.state = {};
    }
    componentDidMount(){
      this.store.subscribe(this.update);
      this.update();
    }
  
    update = () => {
      // 执行 mapStateToProps 只获取用户指定需求的 state
      const state = this.store.getState();
      const filterState = mapStateToProps(state);
      this.setState(filterState);
    }
    render(){
      return 
    }
  }
}
通过 mapDispatchToProps 获取 action 创建函数： 使用 dispatch 包裹后返回
// react-redux.js
// react-redux.js
export const connect = (mapStateToProps, mapDispatchToProps) => (Component) => {
  return class NewComponent extends React.Component{
    static contextTypes = {
      store: propTypes.object
    };
    constructor(props, context){
      super(props, context);
      this.store = context.store;
      this.state = {};
    }
    componentDidMount(){
      this.store.subscribe(this.update);
      this.update();
    }
  
    update = () => {
      // 处理 state ===> 获取用户指定的 state
      const state = this.store.getState();
      const filterState = mapStateToProps(state);

      // 使用 dispatch 对 mapDispatchToProps 中的 action 创建函数进行包裹后返回
      const actionFun = {};
      for(let key in mapDispatchToProps){
        actionFun[key] = (...args) => {
          this.store.dispatch(mapDispatchToProps[key](...args));
        }
      }
  // 一种简写方式： 骚操作
  // const actionFun = Object.keys(mapDispatchToProps)
  //  .reduce((total, item) => {
  //    return { ...total, [item]: (...args) => {dispatch(mapDispatchToProps[item](...args));}
  //   } } ,{});

      this.setState({...filterState, ...actionFun});
    }
    render(){
      return 
    }
  }
}
调用高阶组件：修改 Demo.jsx
// Demo.jsx
import React from "react";
import { changeAge, changeUser } from "./actionCreate";
import { connect } from "./react-redux";
import "./style.css";

// 编写 mapStateToProps 参数 redux state 返回所需的 redux state
const mapStateToProps = (state) => {
  return {user: state.user, age: state.age};
}

// 调用高阶组件
@connect(mapStateToProps, {changeAge, changeUser})
export default class Demo extends React.Component{
  onChange = (e) => {
    this.props.changeUser(e.target.value);
  }
  onClick = () => {
    this.props.changeAge();
  }
  render(){
    return (
      

        
user: {this.props.user}, age: {this.props.age}

        user: 
        
         
        
      

    );
  }
}
四、redux API bindactioncreators 的实现

  在上文我们对 mapDispatchToProps 的处理过程就是 API bindactioncreators 的功能： 将给定 action 创建函数使用 dispatch 进行包裹后返回；

封装 bindactioncreators
// redux.js
export const bindactioncreators = (mapDispatchToProps, dispatch) => {
  const actionFun = {};
  // 遍历 mapDispatchToProps 中每个 action 创建函数 并使用 dispatch 包裹后返回
  for(let key in mapDispatchToProps){
    actionFun[key] = (...args) => {
      dispatch(mapDispatchToProps[key](...args));
    }
  }

  return actionFun;
  // 一种简写方式： 骚操作
  // return actionFun = Object.keys(mapDispatchToProps)
  //  .reduce((total, item) => {
  //    return { ...total, [item]: (...args) => {dispatch(mapDispatchToProps[item](...args));}
  //   } } ,{});
}
修改 connect ：
// react-redux.js
import { bindactioncreators } from "./redux";
....
export const connect = (mapStateToProps, mapDispatchToProps) => (Component) => {
  return class NewComponent extends React.Component{
    static contextTypes = {
      store: propTypes.object
    };
    constructor(props, context){
      super(props, context);
      this.store = context.store;
      this.state = {};
    }
    componentDidMount(){
      this.store.subscribe(this.update);
      this.update();
    }
  
    update = () => {
      const state = this.store.getState();
      const filterState = mapStateToProps(state);
      
      // 调用 API bindactioncreators 
      // 对 mapDispatchToProps 内每个 action 创建函数使用 dispatch 进行包裹后返回
      const actionFun = bindactioncreators(mapDispatchToProps, this.store.dispatch);
      this.setState({...filterState, ...actionFun});
    }
    render(){
      return 
    }
  }
}
五、redux API applyMiddleware 的实现

  到此简化版的 react-redux 算是已经初步完成，但是假如我们想要我们的 age 值的增长是一个异步操作，比如：通过按钮点击后经过两秒再修改 age ，而不是一点击按钮就立即修改值；这样我们又该怎么实现呢？
  当然我们可以通过 setTimeout 两秒后再执行 action 创建函数，比如这样：

onClick = () => {
  setTimeout(()=>{
      // 两秒后执行 action 创建函数
      this.props.changeAge();
  }, 2000);
}

  但是呢事实上我们并不愿意像上面那么整，我们想要这么一种效果：我们只需要简单的调用 action 创建函数即可实现异步操作，而不是需要进行额外的操作；这时我们就需要为我们的 react-redux 编写一个中间件来实现这么一个效果；

5.1 准备工作
新增action 创建函数

  在这之前我们所有的 acton 创建函数都是直接返回一个 action 对象，下面我们写一个不一样的 action 创建函数， 它返回的不再是一个 action 对象而是一个函数，并且该函数接收两个参数 dispatch 以及 getState， 在该函数内部我们进行相应的异步操作，比如：修改 age 值；

// actionCreate.js
export const asyncChangeAge = () => {
  // 返回函数
  return (dispatch, getState) => {
    setTimeout(v=>{
      console.log("==>", getState());
      dispatch({type: "AGE_GROW"});
    }, 1000);
  }
}
修改页面：新增按钮并绑定点击事件，并且调用 asyncChangeAge 函数；
// Demo.jsx
// Demo.jsx
import React from "react";
import "./style.css";
// 导入 asyncChangeAge
import { changeAge, changeUser, asyncChangeAge } from "./actionCreate";
import { connect } from "./react-redux";

const mapStateToProps = (state) => {
  return {user: state.user, age: state.age};
}

// 添加 asyncChangeAge
@connect(mapStateToProps, {changeAge, changeUser, asyncChangeAge})
export default class Demo extends React.Component{
  onChange = (e) => {
    this.props.changeUser(e.target.value);
  }
  onClick = () => {
      this.props.changeAge();
  }
  // 点击事件
  onClickAsync = () => {
    this.props.asyncChangeAge();
  }
  render(){
    return (
      

        
user: {this.props.user}, age: {this.props.age}

        user: 
        
         
        
        {/* 新增按钮 */}
        
      

    );
  }
}
页面的变化其实很简单就是新增了一个按钮：

5.2 需求实现

  接下来我们先什么都不考虑先来实现我们的需求，现在 action 创建函数 asyncChangeAge 因为返回的是一个对象，其 type 值为 undefined 所以当我们点击按钮时 reducer 将会一直匹配到默认情况，返回的将是当前的状态，接下来我们先让我们的 action 创建函数 asyncChangeAge 生效，达到异步修改状态的作用；

扩展 createStore

  既然 asyncChangeAge 返回的不再是一个 action 对象，而是一个函数；那么其实我们要做的事情是很简单的，我们只需要针对 createStore 中的返回值 dispatch 进行一个简单的扩展即可；通过判断 dispatch 中的 action 参数是否是函数而进行不同的操作：

// redux.js
export const createStore = (reducer) => {
    ......
    // 在createStore 我们对返回值 dispatch 进行了封装
  const dispatchExtend = (action) => {
    if(typeof action === "function"){
      // action 为函数，执行函数
      action(dispatch, getState);
    } else {
      // action 为非函数（对象）调用dispatch
      dispatch(action);
    }
  }
  return {getState, dispatch: dispatchExtend, subscribe};
}
5.3 抽离封装

  上文我们通过对 createStore 的返回值 dispatch 进行了扩展，实现了 redux-react 的异步操作，但问题是我们将代码写死在 createStore 中了，redux-react 的异步操作应该是一个可选项而不应该是必选项；

重新扩展 createStore ：

  新增参数 middleware （函数）， 在函数 createStore 开始位置判断 middleware 是否存在，存在则执行；

// redux.js
export const createStore = (reducer, middleware) => {
    // 判断 middleware 是否存在，存在则执行
  if(middleware){
    return middleware(createStore)(reducer);
  }

  let state;
  const listeners = [];

  const getState = () => {
    return state;
  }

  const dispatch = (action) => {
    state = reducer(state, action);
    listeners.forEach(v => v());
  }

  const subscribe = (listener) => {
    listeners.push(listener);
  }

  dispatch({type: "%$&HJKAJJHDJHJ"});

  return {getState, dispatch, subscribe};
}

编写函数 applyMiddleware ，在创建 store 时 作为 createStore 第二参数
// App.js
const applyMiddleware = (createStore) => (redux)=> {
  // 在这里进行创建 store
  const store = createStore(redux);
  // 返回store
  return {...store}
}

const store = createStore(reducer, applyMiddleware);
在 applyMiddleware 函数内扩展 dispatch

  上文 applyMiddleware 函数并其实没做任何事情， 只是在 createStore 函数外面套了一层函数，那么接下来我们做点正事，来扩展一下我们的 dispatch

// App.js
const applyMiddleware = (createStore) => (redux)=> {
  const store = createStore(redux);

  const midApi = {
    getState: store.getState,
    dispatch: (...args) => {dispatch(...args);}
  };

  const dispatch = (action) => {
    if( typeof action === "function" ){
      action(midApi.dispatch, midApi.getState);
    } else {
      store.dispatch(action);
    }
  }

  return {
    ...store,
    dispatch
  };
}
现在我们来看看效果：

GPU服务器 海外云主机 react-redux 简单cdn部署实现 实现简单计算器 php简单实现mvc

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/97070.html

相关文章

  • React-redux基础

    摘要：简介创建的函数，返回一个对象，包含等方法合并多个中间件处理，在实际的前调用一系列中间件，类似于绑定和函数式编程中常见的方法，介绍官方提供的绑定库。 前言 在学习了React之后， 紧跟着而来的就是Redux了~ 在系统性的学习一个东西的时候， 了解其背景、设计以及解决了什么问题都是非常必要的。接下来记录的是， 我个人在学习Redux时的一些杂七杂八~ Redux是什么 通俗理解 h...

    jsyzchen 评论0 收藏0

  • 详解react、redux、react-redux之间的关系

    摘要：或者兄弟组件之间想要共享某些数据，也不是很方便传递获取等。后面要讲到的就是通过让各个子组件拿到中的数据的。所以，确实和没有什么本质关系，可以结合其他库正常使用。 本文介绍了react、redux、react-redux之间的关系，分享给大家，也给自己留个笔记，具体如下： React 一些小型项目，只使用 React 完全够用了，数据管理使用props、state即可，那什么时候需要引入...

    xioqua 评论0 收藏0

  • React 新 Context API 在前端状态管理的实践

    摘要：本文转载至今日头条技术博客众所周知，的单向数据流模式导致状态只能一级一级的由父组件传递到子组件，在大中型应用中较为繁琐不好管理，通常我们需要使用来帮助我们进行管理，然而随着的发布，新成为了新的选择。 本文转载至：今日头条技术博客showImg(https://segmentfault.com/img/bVbiNJO?w=900&h=383);众所周知，React的单向数据流模式导致状态...

    wing324 评论0 收藏0

  • React专题：react，redux以及react-redux常见一些面试题

    摘要：我们可以为元素添加属性然后在回调函数中接受该元素在树中的句柄，该值会作为回调函数的第一个参数返回。使用最常见的用法就是传入一个对象。单向数据流，比较有序，有便于管理，它随着视图库的开发而被概念化。 面试中问框架，经常会问到一些原理性的东西，明明一直在用，也知道怎么用， 但面试时却答不上来，也是挺尴尬的，就干脆把react相关的问题查了下资料，再按自己的理解整理了下这些答案。 reac...

    darcrand 评论0 收藏0

发表评论

登陆后可评论

0条评论

elliott_hu

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<