React知识点

React
Word count: 2.3k   |   Reading time≈ 8 min

1.React生命周期有哪些，16版本生命周期发生了哪些变化？

15生命周期

  • 初始化阶段
    • constructor 构造函数
    • getDefaultPropsprops默认值
    • getInitialStatestate默认值
  • 挂载阶段
    • componentWillMount 组件初始化渲染前调用
    • render 组件渲染
    • componentDidMount组件挂载到 DOM后调用
  • 更新阶段
    • componentWillReceiveProps 组件将要接收新 props前调用
    • shouldComponentUpdate 组件是否需要更新
    • componentWillUpdate 组件更新前调用
    • render 组件渲染
    • componentDidUpdate 组件更新后调用
  • 卸载阶段
    • componentWillUnmount 组件卸载前调用

16生命周期

  • 初始化阶段

    • constructor 构造函数
    • getDefaultPropsprops默认值
    • getInitialStatestate默认值

  • 挂载阶段

    • static getDerivedStateFromProps(props,state)
    • render
    • componentDidMount

    getDerivedStateFromProps：组件每次被 rerender的时候，包括在组件构建之后(虚拟 dom之后，实际 dom挂载之前)，每次获取新的 props或 state之后；每次接收新的props之后都会返回一个对象作为新的 state，返回null则说明不需要更新 state；配合 componentDidUpdate，可以覆盖 componentWillReceiveProps的所有用法。

  • 更新阶段

    • static getDerivedStateFromProps(props,state)
    • shouldComponentUpdate
    • render
    • getSnapshotBeforeUpdate(prevProps,prevState)
    • componentDidUpdate

    getSnapshotBeforeUpdate：触发时间: update发生的时候，在 render之后，在组件 dom渲染之前；返回一个值，作为 componentDidUpdate的第三个参数；配合 componentDidUpdate, 可以覆盖 componentWillUpdate的所有用法。

  • 卸载阶段

    • componentWillUnmount

  • 错误处理

    • componentDidCatch

React16新的生命周期弃用了 componentWillMount、componentWillReceivePorps，componentWillUpdate新增了 getDerivedStateFromProps、getSnapshotBeforeUpdate来代替弃用的三个钩子函数。

React16并没有删除这三个钩子函数，但是不能和新增的钩子函数混用， React17将会删除这三个钩子函数，新增了对错误的处理（ componentDidCatch）。

2. setState是同步的还是异步的？

  • 生命周期和合成事件中

在 React的生命周期和合成事件中， React仍然处于他的更新机制中，这时无论调用多少次 setState，都会不会立即执行更新，而是将要更新的·存入 _pendingStateQueue，将要更新的组件存入 dirtyComponent。
当上一次更新机制执行完毕，以生命周期为例，所有组件，即最顶层组件 didmount后会将批处理标志设置为 false。这时将取出 dirtyComponent中的组件以及 _pendingStateQueue中的 state进行更新。这样就可以确保组件不会被重新渲染多次。

1
2
3
4
5
6
componentDidMount() {
this.setState({
      index: this.state.index + 1
})
console.log('state', this.state.index);
}

所以，如上面的代码，当我们在执行 setState后立即去获取 state，这时是获取不到更新后的 state的，因为处于 React的批处理机制中， state被暂存起来，待批处理机制完成之后，统一进行更新。
所以。setState本身并不是异步的，而是 React的批处理机制给人一种异步的假象。

  • 异步代码和原生事件中

    1
    2
    3
    4
    5
    6
    7
    8
    9
    componentDidMount() {
        setTimeout(() => {
          console.log('调用setState');
            this.setState({
                index: this.state.index + 1
            })
            console.log('state', this.state.index);
        }, 0);
    }

    如上面的代码，当我们在异步代码中调用 setState时，根据 JavaScript的异步机制，会将异步代码先暂存，等所有同步代码执行完毕后在执行，这时 React的批处理机制已经走完，处理标志设被设置为 false，这时再调用 setState即可立即执行更新，拿到更新后的结果。
    在原生事件中调用 setState并不会出发 React的批处理机制，所以立即能拿到最新结果。

  • 最佳实践

setState的第二个参数接收一个函数，该函数会在 React的批处理机制完成之后调用，所以你想在调用 setState后立即获取更新后的值，请在该回调函数中获取。

1
2
3
this.setState({ index: this.state.index + 1 }, () => {
      console.log(this.state.index);
})

链接：由实际问题探究setState的执行机制。

3. 为什么有时连续多次setState只有一次生效？

例如下面的代码，两次打印出的结果是相同的：

1
2
3
4
5
6
7
8
componentDidMount() {
    this.setState({ index: this.state.index + 1 }, () => {
        console.log(this.state.index);
    })
    this.setState({ index: this.state.index + 1 }, () => {
        console.log(this.state.index);
    })
}

原因就是 React会批处理机制中存储的多个 setState进行合并，来看下 React源码中的 _assign函数，类似于 Object的 assign：
如果传入的是对象，很明显会被合并成一次，所以上面的代码两次打印的结果是相同的：

1
2
3
4
5
Object.assign( 
  nextState,
{index: state.index+ 1},
{index: state.index+ 1}
)

注意， assign函数中对函数做了特殊处理，处理第一个参数传入的是函数，函数的参数 preState是前一次合并后的结果，所以计算结果是准确的：

1
2
3
4
5
6
7
8
9
10
11
12
componentDidMount() {
    this.setState((state, props) => ({
            index: state.index + 1
    }), () => { 
        console.log(this.state.index);
    })
    this.setState((state, props) => ({
            index: state.index + 1
    }), () => {
        console.log(this.state.index);
    })
}

所以上面的代码两次打印的结果是不同的。

  • 最佳实践
    React会对多次连续的 setState进行合并，如果你想立即使用上次 setState后的结果进行下一次 setState，可以让 setState 接收一个函数而不是一个对象。这个函数用上一个 state 作为第一个参数，将此次更新被应用时的 props 做为第二个参数。

4. 虚拟Dom比普通Dom更快吗？

很多文章说 VitrualDom可以提升性能，这一说法实际上是很片面的。
直接操作 DOM是非常耗费性能的，这一点毋庸置疑。但是 React使用 VitrualDom也是无法避免操作 DOM的。
如果是首次渲染， VitrualDom不具有任何优势，甚至它要进行更多的计算，消耗更多的内存。
VitrualDom的优势在于 React的 Diff算法和批处理策略， React在页面更新之前，提前计算好了如何进行更新和渲染 DOM。实际上，这个计算过程我们在直接操作 DOM时，也是可以自己判断和实现的，但是一定会耗费非常多的精力和时间，而且往往我们自己做的是不如 React好的。所以，在这个过程中 React帮助我们”提升了性能”。
所以，我更倾向于说， VitrualDom帮助我们提高了开发效率，在重复渲染时它帮助我们计算如何更高效的更新，而不是它比 DOM操作更快。

5. 为什么代码中一定要引入React？

JSX只是为 React.createElement(component,props,…children)方法提供的语法糖。
所有的 JSX代码最后都会转换成 React.createElement(…)， Babel帮助我们完成了这个转换的过程。
所以使用了 JSX的代码都必须引入 React。

6. 为什么React组件首字母必须大写？

babel在编译时会判断 JSX中组件的首字母，当首字母为小写时，其被认定为原生 DOM标签， createElement的第一个变量被编译为字符串；当首字母为大写时，其被认定为自定义组件， createElement的第一个变量被编译为对象。

7. React在渲染真实Dom时做了哪些性能优化？

在 IE（8-11）和 Edge浏览器中，一个一个插入无子孙的节点，效率要远高于插入一整个序列化完整的节点树。
React通过 lazyTree，在 IE（8-11）和 Edge中进行单个节点依次渲染节点，而在其他浏览器中则首先将整个大的 DOM结构构建好，然后再整体插入容器。
并且，在单独渲染节点时， React还考虑了 fragment等特殊节点，这些节点则不会一个一个插入渲染。

8. Hook有哪些优势？

  • 减少状态逻辑复用的风险

Hook和 Mixin在用法上有一定的相似之处，但是 Mixin引入的逻辑和状态是可以相互覆盖的，而多个 Hook之间互不影响，这让我们不需要在把一部分精力放在防止避免逻辑复用的冲突上。在不遵守约定的情况下使用 HOC也有可能带来一定冲突，比如 props覆盖等等，使用 Hook则可以避免这些问题。

  • 避免地狱式嵌套

大量使用 HOC的情况下让我们的代码变得嵌套层级非常深，使用 HOC，我们可以实现扁平式的状态逻辑复用，而避免了大量的组件嵌套。

  • 让组件更容易理解

在使用 class组件构建我们的程序时，他们各自拥有自己的状态，业务逻辑的复杂使这些组件变得越来越庞大，各个生命周期中会调用越来越多的逻辑，越来越难以维护。使用 Hook，可以让你更大限度的将公用逻辑抽离，将一个组件分割成更小的函数，而不是强制基于生命周期方法进行分割。

  • 使用函数代替class

相比函数，编写一个 class可能需要掌握更多的知识，需要注意的点也越多，比如 this指向、绑定事件等等。另外，计算机理解一个 class比理解一个函数更快。Hooks让你可以在 classes之外使用更多 React的新特性。

请我喝杯咖啡吧~

支付宝
微信