【React】拓展 - setState - 路由组件懒加载 - Hooks - Fragment - Context - PureComponent - 插槽 - 错误边界 - 组件通信方式总结

1. setState

setState更新状态其实有两种写法
setState这个方法在调用的时候是同步的，但是引起React的状态更新是异步的
【React状态更新是异步的】

1.1 对象式

setState(stateChange, [callback])

1. stateChange为状态改变对象 (该对象可以体现出状态的更改)
2. callback是可选的回调函数, 它在状态更新完毕、界面也更新后(render调用后)才被调用【异步更新后调用，可以拿到更新后的状态的值】

【例子】
之前一直写的，就是直接传一个对象

this.setState({ count: this.state.count+1 })

1.2 函数式

setState(updater, [callback])

1. updater为返回stateChange对象的函数【返回值是对象】
2. updater可以接收到state和props
3. callback是可选的回调函数, 它在状态更新、界面也更新后(render调用后)才被调用【和对象式是一样的】

【例子】
传的时候回调函数，可以接收到state和props，函数的返回值是设置状态的对象

setState(state => ({count: state.count+1})) 

1.3 总结

1. 对象式的setState是函数式的setState的简写方式【语法糖】
2. 使用原则
   1. 如果新状态不依赖于原状态【使用对象方式】
   2. 如果新状态依赖于原状态 【使用函数方式】
   3. 如果需要在setState()执行后，获取最新的状态数据，可以在第二个callback函数中读取到异步更新的最新值

2. 路由组件的懒加载 lazyLoad

用的时候才加载，一般是路由组件进行懒加载
如果不用路由懒加载，页面在第一次进入的时候，就请求了所有组件的数据，如果组件过多，过多的请求这就没有必要了，应该是用户按哪个链接再请求哪个组件

1. 通过React的lazy函数配合import()函数动态加载路由组件【路由组件代码会被分开打包】
2. 通过指定在加载得到路由打包文件前显示一个自定义loading界面

import React, { Component, lazy, Suspense} from 'react'
import {NavLink,Route} from 'react-router-dom'

// import Home from './Home'
// import About from './About'

import Loading from './Loading'
const Home = lazy(()=> import('./Home') )
const About = lazy(()=> import('./About'))

export default class Demo extends Component {
  render() {
    return (
      <div>
        <div className="row">
          <div className="col-xs-offset-2 col-xs-8">
            <div className="page-header"><h2>React Router Demo</h2></div>
          </div>
        </div>
        <div className="row">
          <div className="col-xs-2 col-xs-offset-2">
            <div className="list-group">
              {/* 在React中靠路由链接实现切换组件--编写路由链接 */}
              <NavLink className="list-group-item" to="/about">About</NavLink>
              <NavLink className="list-group-item" to="/home">Home</NavLink>
            </div>
          </div>
          <div className="col-xs-6">
            <div className="panel">
              <div className="panel-body">
                <Suspense fallback={<Loading/>}>
                  {/* 注册路由 */}
                  <Route path="/about" component={About}/>
                  <Route path="/home" component={Home}/>
                </Suspense>
              </div>
            </div>
          </div>
        </div>
      </div>
    )
  }
}

3. Hooks

3.1 React Hook/Hooks是什么?

Hook 是 React 16.8 的新增特性。
它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。【函数式组件】

3.2 三个常用的Hook

1. State Hook: React.useState()
2. Effect Hook: React.useEffect()
3. Ref Hook: React.useRef()

3.3 State Hook

1. State Hook让函数组件也可以有state状态, 并进行状态数据的读写操作
2. 语法: const [xxx, setXxx] = React.useState(initValue)
3. useState()说明:
   1. 参数: 第一次初始化指定的值在内部作缓存
   2. 返回值: 包含2个元素的数组, 第1个为内部当前状态值, 第2个为更新状态值的函数
4. setXxx()2种写法:
   setXxx(newValue): 参数为非函数值, 直接指定新的状态值, 内部用其覆盖原来的状态值
   setXxx(value => newValue): 参数为函数, 接收原本的状态值, 返回新的状态值, 内部用其覆盖原来的状态值

3.4 Effect Hook

1. Effect Hook 可以让你在函数组件中执行副作用操作(用于模拟类组件中的生命周期钩子)

2. React中的副作用操作:
   发ajax请求数据获取
   设置订阅 / 启动定时器
   手动更改真实DOM

3. 语法和说明:

useEffect(() => { 
  // 在此可以执行任何带副作用操作【挂载+更新】
  return () => { // 在组件卸载前执行
    // 在此做一些收尾工作, 比如清除定时器/取消订阅等【卸载前】
  }
}, [stateValue]) // 如果指定的是[], 回调函数只会在第一次render()后执行

4. 可以把 useEffect Hook 看做如下三个函数的组合

componentDidMount()
componentDidUpdate()
componentWillUnmount() 

3.5 Ref Hook

1. Ref Hook可以在函数组件中存储/查找组件内的标签或任意其它数据
2. 语法: const refContainer = useRef()
3. 作用:保存标签对象,功能与React.createRef()一样

代码示例

import React from 'react'
import ReactDOM from 'react-dom'

//类式组件
/* class Demo extends React.Component {

  state = {count:0}

  myRef = React.createRef()

  add = ()=>{
    this.setState(state => ({count:state.count+1}))
  }

  unmount = ()=>{
    ReactDOM.unmountComponentAtNode(document.getElementById('root'))
  }

  show = ()=>{
    alert(this.myRef.current.value)
  }

  componentDidMount(){
    this.timer = setInterval(()=>{
      this.setState( state => ({count:state.count+1}))
    },1000)
  }

  componentWillUnmount(){
    clearInterval(this.timer)
  }

  render() {
    return (
      

        
        
当前求和为{this.state.count}
        点我+1
        卸载组件
        点击提示数据
      
    )
  }
} */

function Demo(){
  //console.log('Demo');

  const [count,setCount] = React.useState(0)
  const myRef = React.useRef()

  React.useEffect(()=>{
    let timer = setInterval(()=>{
      setCount(count => count+1 )
    },1000)
    return ()=>{
      clearInterval(timer)
    }
  },[])

  //加的回调
  function add(){
    //setCount(count+1) //第一种写法
    setCount(count => count+1 )
  }

  //提示输入的回调
  function show(){
    alert(myRef.current.value)
  }

  //卸载组件的回调
  function unmount(){
    ReactDOM.unmountComponentAtNode(document.getElementById('root'))
  }

  return (
    <div>
      <input type="text" ref={myRef}/>
      <h2>当前求和为：{count}</h2>
      <button onClick={add}>点我+1</button>
      <button onClick={unmount}>卸载组件</button>
      <button onClick={show}>点我提示数据</button>
    </div>
  )
}

export default Demo

4. Fragment

文档碎片

4.1 使用

<Fragment><Fragment>
或者
<></>

4.2 作用

可以不用必须有一个真实的DOM根标签了

import React, { Component,Fragment } from 'react'

export default class Demo extends Component {
  render() {
    return (
      <Fragment kye={1}>
        <input type="text"/>
        <input type="text"/>
      </Fragment>
    )
  }
}

5. Context

上下文

5.1 理解

一种组件间通信方式, 常用于【祖组件】与【后代组件】间通信

5.2 使用

1. 创建Context容器对象

const XxxContext = React.createContext()  

2. 渲染子组时，外面包裹xxxContext.Provider, 通过value属性给后代组件传递数据：

<xxxContext.Provider value={数据}>
	子组件
</xxxContext.Provider>

3. 后代组件读取数据：

第一种方式:仅适用于类组件

static contextType = xxxContext  // 声明接收context
this.context // 读取context中的value数据

第二种方式: 函数组件与类组件都可以

<xxxContext.Consumer>
  {
    value => ( // value就是context中的value数据
      要显示的内容
    )
  }
</xxxContext.Consumer>

5.3 注意

在应用开发中一般不用context, 一般都用它来封装react插件

import React, { Component } from 'react'
import './index.css'

//创建Context对象
const MyContext = React.createContext()
const { Provider, Consumer } = MyContext

export default class A extends Component {

  state = {username:'tom',age:18}

  render() {
    const {username,age} = this.state
    return (
      <div className="parent">
        <h3>我是A组件</h3>
        <h4>我的用户名是:{username}</h4>
        <Provider value={{username,age}}>
          <B/>
        </Provider>
      </div>
    )
  }
}

class B extends Component {
  render() {
    return (
      <div className="child">
        <h3>我是B组件</h3>
        <C/>
      </div>
    )
  }
}

/* class C extends Component {
  //声明接收context
  static contextType = MyContext
  render() {
    const {username,age} = this.context
    return (
      

        
我是C组件
        
我从A组件接收到的用户名:{username},年龄是{age}
      
    )
  }
} */

function C(){
  return (
    <div className="grand">
      <h3>我是C组件</h3>
      <h4>我从A组件接收到的用户名:
      <Consumer>
        {value => `${value.username},年龄是${value.age}`}
      </Consumer>
      </h4>
    </div>
  )
}

6. 组件优化

6.1 Component的问题

1. 只要执行setState(),即使不改变状态数据, 组件也会重新render() ==> 效率低

2. 只当前组件重新render(), 就会自动重新render子组件，纵使子组件没有用到父组件的任何数据 ==> 效率低

6.2 效率高的做法

只有当组件的state或props数据发生改变时才重新render()

6.3 原因

Component中的shouldComponentUpdate()总是返回true

6.4 解决

办法1: 重写shouldComponentUpdate()方法

比较新旧state或props数据, 如果有变化才返回true, 如果没有返回false

shouldComponentUpdate(nextProps,nextState){
  // console.log(this.props,this.state); //目前的props和state
  // console.log(nextProps,nextState); //接下要变化的目标props，目标state
  return !this.state.carName === nextState.carName
} 

办法2: 使用PureComponent

PureComponent重写了shouldComponentUpdate(), 只有state或props数据有变化才返回true

注意

• 只是进行state和props数据的浅比较, 如果只是数据对象内部数据变了, 返回false
• 不要直接修改state数据, 而是要产生新数据

项目中一般使用PureComponent来优化

import React, { PureComponent } from 'react'
import './index.css'

export default class Parent extends PureComponent {

  state = {carName:"奔驰c36",stus:['小张','小李','小王']}

  addStu = ()=>{
    /* const {stus} = this.state
    stus.unshift('小刘')
    this.setState({stus}) */

    const {stus} = this.state
    this.setState({stus:['小刘',...stus]})
  }

  changeCar = ()=>{
    this.setState({carName:'迈巴赫'})

    // const obj = this.state
    // obj.carName = '迈巴赫'
    // console.log(obj === this.state);
    // this.setState(obj)
  }

  /* shouldComponentUpdate(nextProps,nextState){
    // console.log(this.props,this.state); //目前的props和state
    // console.log(nextProps,nextState); //接下要变化的目标props，目标state
    return !this.state.carName === nextState.carName
  } */

  render() {
    console.log('Parent---render');
    const {carName} = this.state
    return (
      <div className="parent">
        <h3>我是Parent组件</h3>
        {this.state.stus}&nbsp;
        <span>我的车名字是：{carName}</span><br/>
        <button onClick={this.changeCar}>点我换车</button>
        <button onClick={this.addStu}>添加一个小刘</button>
        <Child carName="奥拓"/>
      </div>
    )
  }
}

class Child extends PureComponent {

  /* shouldComponentUpdate(nextProps,nextState){
    console.log(this.props,this.state); //目前的props和state
    console.log(nextProps,nextState); //接下要变化的目标props，目标state
    return !this.props.carName === nextProps.carName
  } */

  render() {
    console.log('Child---render');
    return (
      <div className="child">
        <h3>我是Child组件</h3>
        <span>我接到的车是：{this.props.carName}</span>
      </div>
    )
  }
}

7. render props

7.1 如何向组件内部动态传入带内容的结构(标签)?

类似于Vue中的插槽
Vue中:
使用slot技术, 也就是通过组件标签体传入结构
React中:
使用children props: 通过组件标签体传入结构
使用render props: 通过组件标签属性传入结构,而且可以携带数据，一般用render函数属性

7.2 children props

<A>
  <B>xxxx</B>
</A>

使用

{this.props.children}

问题: 如果B组件需要A组件内的数据, ==> 做不到 

7.3 render props

<A render={(data) => <C data={data}></C>}></A>

使用
A组件: {this.props.render(内部state数据)}
C组件: 读取A组件传入的数据显示 {this.props.data}

8. 错误边界

8.1 理解

错误边界(Error boundary)：用来捕获后代组件错误，渲染出备用页面

8.2 特点

只能捕获后代组件生命周期产生的错误，不能捕获自己组件产生的错误和其他组件在合成事件、定时器中产生的错误

8.3 使用方式

getDerivedStateFromError配合componentDidCatch

// 生命周期函数，一旦后台组件报错，就会触发
static getDerivedStateFromError(error) {
    console.log(error);
    // 在render之前触发
    // 返回新的state
    return {
        hasError: true,
    };
}

componentDidCatch(error, info) {
    // 统计页面的错误。发送请求发送到后台去
    console.log(error, info);
}

8.4 示例

import React, { Component } from 'react'
import Child from './Child'

export default class Parent extends Component {

	state = {
		hasError:'' // 用于标识子组件是否产生错误
	}

	//当Parent的子组件出现报错时候，会触发getDerivedStateFromError调用，并携带错误信息
	static getDerivedStateFromError(error){
		console.log('@@@',error);
		return {hasError:error}
	}

	componentDidCatch(){
		console.log('此处统计错误，反馈给服务器，用于通知编码人员进行bug的解决');
	}

	render() {
		return (
			<div>
				<h2>我是Parent组件</h2>
				{this.state.hasError ? <h2>当前网络不稳定，稍后再试</h2> : <Child/>}
			</div>
		)
	}
}

9. 组件通信方式总结

9.1 组件间的关系

• 父子组件
• 兄弟组件（非嵌套组件）
• 祖孙组件（跨级组件）

9.2 几种通信方式

1. props：
   (1).children props
   (2).render props
2. 消息订阅-发布：
   pubs-sub、event等等
3. 集中式管理：
   redux、dva等等
4. Context:
   生产者-消费者模式

9.3 比较好的搭配方式

父子组件：props

兄弟组件：消息订阅-发布、集中式管理

祖孙组件(跨级组件)：消息订阅-发布、集中式管理、Context(开发用的少，封装插件用的多)