事件处理

绑定事件

采用on+事件名的方式来绑定一个事件，注意，这里和原生的事件是有区别的，原生的事件全是小写onclick, React里的事件是驼峰onClick，React的事件并不是原生事件，而是合成事件。

事件handler的写法

• 直接在render里写行内的箭头函数(不推荐)
• 在组件内使用箭头函数定义一个方法(推荐)
• 直接在组件内定义一个非箭头函数的方法，然后在render里直接使用onClick={this.handleClick.bind(this)}(不推荐)
• 直接在组件内定义一个非箭头函数的方法，然后在constructor里bind(this)(推荐)

Event 对象

和普通浏览器一样，事件handler会被自动传入一个 event 对象，这个对象和普通的浏览器 event 对象所包含的方法和属性都基本一致。不同的是 React中的 event 对象并不是浏览器提供的，而是它自己内部所构建的。它同样具有event.stopPropagation、event.preventDefault 这种常用的方法

​ 事件对象中的值很多都是null,但是可以正常使用

事件的参数传递

• 在render里调用方法的地方外面包一层箭头函数
• 在render里通过this.handleEvent.bind(this, 参数)这样的方式来传递
• 通过event传递
• 比较推荐的是做一个子组件, 在父组件中定义方法，通过props传递到子组件中，然后在子组件件通过this.props.method来调用

处理用户输入

import React, { Component } from 'react'
import ReactDOM from 'react-dom'class App extends Component {constructor() {super()this.state = {xing: '',ming: ''}}handleInputChange = (e) => {this.setState({[e.target.name]: e.target.value})}render () {const {xing,ming} = this.statereturn (<div><label><span>姓:</span><inputtype="text"name="xing"value={xing}onChange={this.handleInputChange}/></label><label><span>名:</span><inputtype="text"name="ming"value={ming}onChange={this.handleInputChange}/></label><p>欢迎您: {xing}{ming}</p></div>)}
}
ReactDOM.render(<App/>,document.getElementById('root')
)

组件的生命周期

React中组件有生命周期，也就是说也有很多钩子函数供我们使用, 组件的生命周期，我们会分为四个阶段，初始化、运行中、销毁、错误处理(16.3之后)

​ 生命周期钩子函数一定不要写成箭头函数

初始化

在组件初始化阶段会执行

1. constructor
2. static getDerivedStateFromProps() ---- 将来会使用,
3. componentWillMount() / UNSAFE_componentWillMount() 带有UNSAFE属于过时的钩子函数
   - componentWillMount会在17版本之后弃用（ 使用static getDerivedStateFromProps）
4. render()
5. componentDidMount()

更新阶段

props或state的改变可能会引起组件的更新，组件重新渲染的过程中会调用以下方法：

1. componentWillReceiveProps() / UNSAFE_componentWillReceiveProps()
2. static getDerivedStateFromProps()
3. shouldComponentUpdate() // react性能优化第二方案
4. componentWillUpdate() / UNSAFE_componentWillUpdate()
5. render()
6. getSnapshotBeforeUpdate() ---- 将来会使用
7. componentDidUpdate()

卸载阶段

1. componentWillUnmount()

错误处理

1. componentDidCatch() — 16.3版本之后才有的

各生命周期详解

1.constructor(props)

React组件的构造函数在挂载之前被调用。在实现React.Component构造函数时，需要先在添加其他内容前，调用super(props)，用来将父组件传来的props绑定到这个类中，使用this.props将会得到。

官方建议不要在constructor引入任何具有副作用和订阅功能的代码，这些应当使用componentDidMount()。

constructor中应当做些初始化的动作，如：初始化state，将事件处理函数绑定到类实例上，但也不要使用setState()。如果没有必要初始化state或绑定方法，则不需要构造constructor，或者把这个组件换成纯函数写法。

当然也可以利用props初始化state，在之后修改state不会对props造成任何修改，但仍然建议大家提升状态到父组件中，或使用redux统一进行状态管理。

constructor(props) {super(props);this.state = {isLiked: props.isLiked};
}

2.static getDerivedStateFromProps(nextProps, prevState)

getDerivedStateFromProps 是react16.3之后新增，在组件实例化后，和接受新的props后被调用。他必须返回一个对象来更新状态，或者返回null表示新的props不需要任何state的更新。

如果是由于父组件的props更改，所带来的重新渲染，也会触发此方法。

调用steState()不会触发getDerivedStateFromProps()。

之前这里都是使用constructor+componentWillRecieveProps完成相同的功能的

3. componentWillMount() / UNSAFE_componentWillMount()

componentWillMount()将在React未来版本(官方说法 17.0)中被弃用。UNSAFE_componentWillMount()在组件挂载前被调用，在这个方法中调用setState()不会起作用，是由于他在render()前被调用。

为了避免副作用和其他的订阅，官方都建议使用componentDidMount()代替。这个方法是用于在服务器渲染上的唯一方法。这个方法因为是在渲染之前被调用，也是惟一一个可以直接同步修改state的地方。

4.render()

render()方法是必需的。当他被调用时，他将计算this.props和this.state，并返回以下一种类型：

1. React元素。通过jsx创建，既可以是dom元素，也可以是用户自定义的组件。
2. 字符串或数字。他们将会以文本节点形式渲染到dom中。
3. Portals【'portl】。react 16版本中提出的新的解决方案，可以使组件脱离父组件层级直接挂载在DOM树的任何位置。
4. null，什么也不渲染
5. 布尔值。也是什么都不渲染。

当返回null,false,ReactDOM.findDOMNode(this)将会返回null，什么都不会渲染。

render()方法必须是一个纯函数，他不应该改变state，也不能直接和浏览器进行交互，应该将事件放在其他生命周期函数中。
如果shouldComponentUpdate()返回false，render()不会被调用。

5. componentDidMount

componentDidMount在组件被装配后立即调用。初始化使得DOM节点应该进行到这里。

通常在这里进行ajax请求

如果要初始化第三方的dom库，也在这里进行初始化。只有到这里才能获取到真实的dom.

6.componentWillReceiveProps()/UNSAFE_componentWillReceiveProps(nextProps)

官方建议使用getDerivedStateFromProps函数代替componentWillReceiveProps。当组件挂载后，接收到新的props后会被调用。如果需要更新state来响应props的更改，则可以进行this.props和nextProps的比较，并在此方法中使用this.setState()。

如果父组件会让这个组件重新渲染，即使props没有改变，也会调用这个方法。

React不会在组件初始化props时调用这个方法。调用this.setState也不会触发。

7.shouldComponentUpdate(nextProps, nextState)

调用shouldComponentUpdate使React知道，组件的输出是否受state和props的影响。默认每个状态的更改都会重新渲染，大多数情况下应该保持这个默认行为。

在渲染新的props或state前，shouldComponentUpdate会被调用。默认为true。这个方法不会在初始化时被调用，也不会在forceUpdate()时被调用。返回false不会阻止子组件在state更改时重新渲染。

如果shouldComponentUpdate()返回false，componentWillUpdate,render和componentDidUpdate不会被调用。

官方并不建议在shouldComponentUpdate()中进行深度查询或使用JSON.stringify()，他效率非常低，并且损伤性能。

8.componentWillUpdate/UNSAFE_componentWillUpdate(nextProps, nextState)

在渲染新的state或props时，UNSAFE_componentWillUpdate会被调用，将此作为在更新发生之前进行准备的机会。这个方法不会在初始化时被调用。

不能在这里使用this.setState()，也不能做会触发视图更新的操作。如果需要更新state或props，调用getDerivedStateFromProps。

9.getSnapshotBeforeUpdate()

在react render()后的输出被渲染到DOM之前被调用。它使您的组件能够在它们被潜在更改之前捕获当前值（如滚动位置）。这个生命周期返回的任何值都将作为参数传递给componentDidUpdate（）。

10.componentDidUpdate(prevProps, prevState, snapshot)

在更新发生后立即调用componentDidUpdate()。此方法不用于初始渲染。当组件更新时，将此作为一个机会来操作DOM。只要您将当前的props与以前的props进行比较（例如，如果props没有改变，则可能不需要网络请求），这也是做网络请求的好地方。

如果组件实现getSnapshotBeforeUpdate()生命周期，则它返回的值将作为第三个“快照”参数传递给componentDidUpdate()。否则，这个参数是undefined。

11.componentWillUnmount()

在组件被卸载并销毁之前立即被调用。在此方法中执行任何必要的清理，例如使定时器无效，取消网络请求或清理在componentDidMount中创建的任何监听。

12.componentDidCatch(error, info)

错误边界是React组件，可以在其子组件树中的任何位置捕获JavaScript错误，记录这些错误并显示回退UI，而不是崩溃的组件树。错误边界在渲染期间，生命周期方法以及整个树下的构造函数中捕获错误。

如果类组件定义了此生命周期方法，则它将成错误边界。在它中调用setState()可以让你在下面的树中捕获未处理的JavaScript错误，并显示一个后备UI。只能使用错误边界从意外异常中恢复; 不要试图将它们用于控制流程。

错误边界只会捕获树中下面组件中的错误。错误边界本身不能捕获错误。

PureComponent

PureComponnet里如果接收到的新属性或者是更改后的状态和原属性、原状态相同的话，就不会去重新render了
在里面也可以使用shouldComponentUpdate，而且。是否重新渲染以shouldComponentUpdate的返回值为最终的决定因素。

import React, { PureComponent } from 'react'class YourComponent extends PureComponent {……
}

ref

React提供的这个ref属性，表示为对组件真正实例的引用，其实就是ReactDOM.render()返回的组件实例,ref可以挂载到组件上也可以是dom元素上。

• 挂到组件(class声明的组件)上的ref表示对组件实例的引用。不能在函数式组件上使用 ref 属性，因为它们没有实例：
• 挂载到dom元素上时表示具体的dom元素节点。

在React 最新的版本中，要使用ref, 需要使用React.createRef方法先生成一个ref。

import React, { Component, createRef } from 'react'
import ReactDOM from 'react-dom'class App extends Component {constructor() {super()// 创建inputRefthis.inputRef=createRef()}componentDidMount () {console.log(this.inputRef.current) // <input type="text">}render () {return (<div>{/* 关联ref和dom */}<input type="text" ref={this.inputRef} /></div>)}
}
ReactDOM.render(<App/>,document.getElementById('root')
)

React Hooks

React Hooks 是 React 16.7.0-alpha 版本推出的新特性, 有了React Hooks，在 react 函数组件中，也可以使用类组件（classes components）的 state 和 组件生命周期。通过下面几个例子来学习React Hooks。

• State Hook

// useState是react包提供的一个方法
import React, { useState } from "react";
import ReactDOM from "react-dom";const Counter = () => {// useState 这个方法可以为我们的函数组件拥有自己的state，它接收一个用于初始 state 的值，返回一对变量。这里我们把计数器的初始值设置为0, 方法都是以set开始const [count, setCount] = useState(0);return (<div><p>你点击了{count}次</p><button onClick={() => setCount(count + 1)}>点击</button></div>);
};const rootElement = document.getElementById("root");ReactDOM.render(<Counter />, rootElement);

• Effect Hook

// useState是react包提供的一个方法
import React, { useState, useEffect } from "react";
import ReactDOM from "react-dom";const Counter = () => {// useState 这个方法可以为我们的函数组件拥有自己的state，它接收一个用于初始 state 的值，返回一对变量。这里我们把计数器的初始值设置为0, 方法都是以set开始const [count, setCount] = useState(0);// 类似于componentDidMount或者componentDidUpdate:useEffect(() => {// 更改网页的标题，还可以做其它的监听document.title = `你点击了${count}次`;});return (<div><p>你点击了{count}次</p><button onClick={() => setCount(count + 1)}>点击</button></div>);
};const rootElement = document.getElementById("root");ReactDOM.render(<Counter />, rootElement);

• React Hooks 的规则
  • 只能在顶层调用Hooks。不要在循环，条件或嵌套函数中调用Hook。
  • 不要从常规JavaScript函数中调用Hook。只在React函数式组件调用Hooks。
• 自定义hooks可以选择讲解
• react 内置hooks api
  • Basic Hooks
    • useState
    • useEffect
    • useContext
  • Additional Hooks
    • useReducer
    • useCallback
    • useMemo
    • useRef
    • useImperativeHandle
    • useLayoutEffect
    • useDebugValue

组件通信

分类：

​ 父子组件通信

​ 无论父组件传递是props还是state,子组件都是通过props接收

​ 子父组件通信

​ 父组件传递方法给子组件，子组件调用父组件传递过来的方法

​ 注意： 自己的状态自己更改

​ 非父子组件通信

​ ref链

​ 1. ref = ‘xxx’ this.refs.xxx

​ 2. ref = { el => this.xxx = el } this.xxx 【 推荐 】

​ 跨组件通信

​ context

​ 使用流程

​ - 创建上下文 React.createContext()

​ - 使用上下文包裹目标组件的父组件

    <MoneyContext.Provider value = { money }><Father></Father></MoneyContext.Provider>

​ - 在目标组件中先定义一个静态属性 static contextType = MoneyContext

​ - 通过 this.context来使用数据

多组件状态共享

​ Flux

​ redux

​ mobx ( 阿里 )

父组件与子组件通信

• 父组件将自己的状态传递给子组件，子组件当做属性来接收，当父组件更改自己状态的时候，子组件接收到的属性就会发生改变

• 父组件利用ref对子组件做标记，通过调用子组件的方法以更改子组件的状态,也可以调用子组件的方法…

子组件与父组件通信

• 父组件将自己的某个方法传递给子组件，在方法里可以做任意操作，比如可以更改状态，子组件通过this.props接收到父组件的方法后调用。

跨组件通信

在react没有类似vue中的事件总线来解决这个问题，我们只能借助它们共同的父级组件来实现，将非父子关系装换成多维度的父子关系。react提供了context api来实现跨组件通信, React 16.3之后的contextapi较之前的好用。

实例，使用context 实现购物车中的加减功能

// counterContext.js
import React, { Component, createContext } from 'react'const {Provider,Consumer: CountConsumer
} = createContext()class CountProvider extends Component {constructor () {super()this.state = {count: 1}}increaseCount = () => {this.setState({count: this.state.count + 1})}decreaseCount = () => {this.setState({count: this.state.count - 1})}render() {return (<Provider value={{count: this.state.count,increaseCount: this.increaseCount,decreaseCount: this.decreaseCount}}>{this.props.children}</Provider>)}
}export {CountProvider,CountConsumer
}

// 定义CountButton组件
const CountButton = (props) => {return (<CountConsumer>// consumer的children必须是一个方法{({ increaseCount, decreaseCount }) => {const { type } = propsconst handleClick = type === 'increase' ? increaseCount : decreaseCountconst btnText = type === 'increase' ? '+' : '-'return <button onClick={handleClick}>{btnText}</button>}}</CountConsumer>)
}

// 定义count组件，用于显示数量
const Count = (prop) => {return (<CountConsumer>{({ count }) => {return <span>{count}</span>}}</CountConsumer>)
}

// 组合
class App extends Component {render () {return (<CountProvider><CountButton type='decrease' /><Count /><CountButton type='increase' /></CountProvider>)}
}

复杂的非父子组件通信在react中很难处理，多组件间的数据共享也不好处理，在实际的工作中我们会使用flux、redux、mobx来实现

HOC(高阶组件)

Higher-Order Components就是一个函数，传给它一个组件，它返回一个新的组件。

功能：

​ 1. 进行某些方法或是属性的复用

​ 2. 让外层的组件替我们完成任务，那么里层组件直接使用就可以了

const NewComponent = higherOrderComponent(YourComponent)

比如，我们想要我们的组件通过自动注入一个版权信息。

// withCopyright.js 定义一个高阶组件
import React, { Component, Fragment } from 'react'const withCopyright = (WrappedComponent) => {return class NewComponent extends Component {render() {return (<Fragment><WrappedComponent /><div>&copy;版权所有 千锋教育 2019 </div></Fragment>)}}
}
export default withCopyright

// 使用方式
import withCopyright from './withCopyright'class App extends Component {render () {return (<div><h1>Awesome React</h1><p>React.js是一个构建用户界面的库</p></div>)}
}
const CopyrightApp = withCopyright(App)

这样只要我们有需要用到版权信息的组件，都可以直接使用withCopyright这个高阶组件包裹即可。

在这里要讲解在CRA 中配置装饰器模式的支持。

状态管理

传统MVC框架的缺陷

什么是MVC？

MVC的全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，是一种软件设计典范。

V即View视图是指用户看到并与之交互的界面。

M即Model模型是管理数据 ，很多业务逻辑都在模型中完成。在MVC的三个部件中，模型拥有最多的处理任务。

C即Controller控制器是指控制器接受用户的输入并调用模型和视图去完成用户的需求，控制器本身不输出任何东西和做任何处理。它只是接收请求并决定调用哪个模型构件去处理请求，然后再确定用哪个视图来显示返回的数据。

MVC只是看起来很美

MVC框架的数据流很理想，请求先到Controller, 由Controller调用Model中的数据交给View进行渲染，但是在实际的项目中，又是允许Model和View直接通信的。然后就出现了这样的结果：

前端几个核心框架出现的时间

1. Backbone.js      MVP    2010.10
2. Angular.js ( 1.0 版本)  MVC ->MVVM   2010.10
3. React  可以认为是MVC中的V      2013
4. Vue 1.0   MVVM   2014
5. Vue 2.0  MVVM    2016/9
6. Angular.ts( 2.0 版本)     2016年

​

Flux Redux 都是和MVC MVP MVVM 一样是架构层级

Flux Redux 都是状态管理工具

1. 数据的集中存储者（ 集中存储数据的一个仓库 ）
2. 数据的管理者

Flux

在2013年，Facebook让React亮相的同时推出了Flux框架，React的初衷实际上是用来替代jQuery的，Flux实际上就可以用来替代Backbone.js，Ember.js等一系列MVC架构的前端JS框架。

其实Flux在React里的应用就类似于Vue中的Vuex的作用，但是在Vue中，Vue是完整的mvvm框架，而Vuex只是一个全局的插件。

React只是一个MVC中的V(视图层)，只管页面中的渲染，一旦有数据管理的时候，React本身的能力就不足以支撑复杂组件结构的项目，在传统的MVC中，就需要用到Model和Controller。Facebook对于当时世面上的MVC框架并不满意，于是就有了Flux, 但Flux并不是一个MVC框架，他是一种新的思想（ 新的架构思想 ）。

[外链图片转存失败(img-Xfqx0t4L-1562849685193)(./images/flux.png)]

Flux 组成部分

• View： 视图层 （ 用React的组件来代替 ）
• ActionCreators（动作创造者）：视图层发出的消息（比如mouseClick）
• Dispatcher（派发器）：用来接收Actions、执行回调函数
• Store（数据层）：用来存放应用的状态，一旦发生变动，就提醒Views要更新页面

Flux的流程：

1. 组件获取到store中保存的数据挂载在自己的状态上
2. 用户产生了操作，调用actions的方法
3. actions接收到了用户的操作，进行一系列的逻辑代码、异步操作
4. 然后actions会创建出对应的action，action带有标识性的属性
5. actions调用dispatcher的dispatch方法将action传递给dispatcher
6. dispatcher接收到action并根据标识信息判断之后，调用store的更改数据的方法
7. store的方法被调用后，更改状态，并触发自己的某一个事件
8. store更改状态后事件被触发，该事件的处理程序会通知view去获取最新的数据

Redux

Store 数据的管理者和数据的存储者

actionCreators 动作的创建者，发送动作给 reducers

react Components 组件（ 用来充当视图层 ）

reducers 数据的修改者，返回一个新的 newstate 给store

React 只是 DOM 的一个抽象层，并不是 Web 应用的完整解决方案。有两个方面，它没涉及。

• 代码结构
• 组件之间的通信

2013年 Facebook 提出了 Flux 架构的思想，引发了很多的实现。2015年，Redux 出现，将 Flux 与函数式编程结合一起，很短时间内就成为了最热门的前端架构。

如果你不知道是否需要 Redux，那就是不需要它

只有遇到 React 实在解决不了的问题，你才需要 Redux

简单说，如果你的UI层非常简单，没有很多互动，Redux 就是不必要的，用了反而增加复杂性。

• 用户的使用方式非常简单
• 用户之间没有协作
• 不需要与服务器大量交互，也没有使用 WebSocket
• 视图层（View）只从单一来源获取数据

需要使用Redux的项目:

• 用户的使用方式复杂
• 不同身份的用户有不同的使用方式（比如普通用户和管理员）
• 多个用户之间可以协作
• 与服务器大量交互，或者使用了WebSocket
• View要从多个来源获取数据

从组件层面考虑，什么样子的需要Redux：

• 某个组件的状态，需要共享
• 某个状态需要在任何地方都可以拿到
• 一个组件需要改变全局状态
• 一个组件需要改变另一个组件的状态

Redux的设计思想：

1. Web 应用是一个状态机，视图与状态是一一对应的。
2. 所有的状态，保存在一个对象里面（唯一数据源）。

注意：flux、redux都不是必须和react搭配使用的，因为flux和redux是完整的架构，在学习react的时候，只是将react的组件作为redux中的视图层去使用了。

Redux的使用的三大原则：

• Single Source of Truth(唯一的数据源)
• State is read-only(状态是只读的)
• Changes are made with pure function(数据的改变必须通过纯函数完成)

自己实现Redux

这个部分，可以根据班级情况看是否讲解。对于学生使用redux有很大的帮助。不使用react，直接使用原生的html/js来写一个简易的的redux

基本的状态管理及数据渲染

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>Redux principle 01</title>
</head>
<body><h1>redux principle</h1><div class="counter"><span class="btn" onclick="dispatch({type: 'COUNT_DECREMENT', number: 10})">-</span><span class="count" id="count"></span><span class="btn" id="add" onclick="dispatch({type: 'COUNT_INCREMENT', number: 10})">+</span></div><script>// 定义一个计数器的状态const countState = {count: 10}// 定一个方法叫changeState，用于处理state的数据，每次都返回一个新的状态const changeState = (action) => {switch(action.type) {// 处理减case 'COUNT_DECREMENT':countState.count -= action.numberbreak;// 处理加        case 'COUNT_INCREMENT':countState.count += action.numberbreak;default:break;}}// 定义一个方法用于渲染计数器的domconst renderCount = (state) => {const countDom = document.querySelector('#count')countDom.innerHTML = state.count}// 首次渲染数据renderCount(countState)// 定义一个dispatch的方法，接收到动作之后，自动调用const dispatch = (action) => {changeState(action)renderCount(countState)}</script>
</body>
</html>

创建createStore方法

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>Redux principle 02</title>
</head>
<body><h1>redux principle</h1><div class="counter"><span class="btn" onclick="store.dispatch({type: 'COUNT_DECREMENT', number: 10})">-</span><span class="count" id="count"></span><span class="btn" id="add" onclick="store.dispatch({type: 'COUNT_INCREMENT', number: 10})">+</span></div><script>// 定义一个方法，用于集中管理state和dispatchconst createStore = (state, changeState) => {// getState用于获取状态const getState = () => state// 定义一个监听器，用于管理一些方法const listeners = []const subscribe = (listener) => listeners.push(listener)// 定义一个dispatch方法，让每次有action传入的时候返回render执行之后的结果const dispatch = (action) => {// 调用changeState来处理数据changeState(state, action)// 让监听器里的所以方法运行listeners.forEach(listener => listener())}return {getState,dispatch,subscribe}}// 定义一个计数器的状态const countState = {count: 10}// 定一个方法叫changeState，用于处理state的数据，每次都返回一个新的状态const changeState = (state, action) => {switch(action.type) {// 处理减case 'COUNT_DECREMENT':state.count -= action.numberbreak;// 处理加        case 'COUNT_INCREMENT':state.count += action.numberbreak;default:break;}}// 创建一个storeconst store = createStore(countState, changeState)// 定义一个方法用于渲染计数器的domconst renderCount = () => {const countDom = document.querySelector('#count')countDom.innerHTML = store.getState().count}// 初次渲染数据renderCount()// 监听，只要有dispatch，这个方法就会自动运行store.subscribe(renderCount)</script>
</body>
</html>

让changeState方法变为一个纯函数

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>Redux principle 03</title>
</head>
<body><h1>redux principle</h1><div class="counter"><span class="btn" onclick="store.dispatch({type: 'COUNT_DECREMENT', number: 10})">-</span><span class="count" id="count"></span><span class="btn" id="add" onclick="store.dispatch({type: 'COUNT_INCREMENT', number: 10})">+</span></div><script>// 定义一个方法，用于集中管理state和dispatchconst createStore = (state, changeState) => {// getState用于获取状态const getState = () => state// 定义一个监听器，用于管理一些方法const listeners = []const subscribe = (listener) => listeners.push(listener)// 定义一个dispatch方法，让每次有action传入的时候返回render执行之后的结果const dispatch = (action) => {// 调用changeState来处理数据state = changeState(state, action)// 让监听器里的所有方法运行listeners.forEach(listener => listener())}return {getState,dispatch,subscribe}}// 定义一个计数器的状态const countState = {count: 10}// 定一个方法叫changeState，用于处理state的数据，每次都返回一个新的状态const changeState = (state, action) => {switch(action.type) {// 处理减case 'COUNT_DECREMENT':return {...state,count: state.count - action.number}// 处理加        case 'COUNT_INCREMENT':return {...state,count: state.count + action.number}default:return state}}// 创建一个storeconst store = createStore(countState, changeState)// 定义一个方法用于渲染计数器的domconst renderCount = () => {const countDom = document.querySelector('#count')countDom.innerHTML = store.getState().count}// 初次渲染数据renderCount()// 监听，只要有dispatch，这个方法就会自动运行store.subscribe(renderCount)</script>
</body>
</html>

合并state和changeState(最终版)

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>Redux principle 04</title>
</head>
<body><h1>redux principle</h1><div class="counter"><span class="btn" onclick="store.dispatch({type: 'COUNT_DECREMENT', number: 10})">-</span><span class="count" id="count"></span><span class="btn" id="add" onclick="store.dispatch({type: 'COUNT_INCREMENT', number: 10})">+</span></div><script>// 定义一个方法，用于集中管理state和dispatch, changeState改名了，专业的叫法是reducerconst createStore = (reducer) => {// 定义一个初始的statelet state = null// getState用于获取状态const getState = () => state// 定义一个监听器，用于管理一些方法const listeners = []const subscribe = (listener) => listeners.push(listener)// 定义一个dispatch方法，让每次有action传入的时候返回reducer执行之后的结果const dispatch = (action) => {// 调用reducer来处理数据state = reducer(state, action)// 让监听器里的所有方法运行listeners.forEach(listener => listener())}//  初始化statedispatch({})return {getState,dispatch,subscribe}}// 定义一个计数器的状态const countState = {count: 10}// 定一个方法叫changeState，用于处理state的数据，每次都返回一个新的状态const changeState = (state, action) => {// 如果state是null, 就返回countStateif (!state) return countStateswitch(action.type) {// 处理减case 'COUNT_DECREMENT':return {...state,count: state.count - action.number}// 处理加        case 'COUNT_INCREMENT':return {...state,count: state.count + action.number}default:return state}}// 创建一个storeconst store = createStore(changeState)// 定义一个方法用于渲染计数器的domconst renderCount = () => {const countDom = document.querySelector('#count')countDom.innerHTML = store.getState().count}// 初次渲染数据renderCount()// 监听，只要有dispatch，renderCount就会自动运行store.subscribe(renderCount)</script>
</body>
</html>