React优化子组件render

在 react 中，父组件的重新 render 会引发子组件的重新 render，但是一些情况下我们会觉得这样做有些多余，比如：

1. 父组件并未传递 props 给子组件
2. 新传递的 props 渲染结果不变

class A extends React.Component {render() {console.log('render')
        return <div> 这是 A 组件 </div>
    }
}

class Main extends React.Component {render() {
        return (
            <div>
                // 点击 button 会让 A 不断调用 render
                <button onClick={() => this.setState({ a: 1})}>Main</button>
                <A />
            </div>
        )
    }
}

为了解决这个问题，需要分为 ES6 类组件和函数式组件两种：

类组件

使用 shouldComponentUpdate 来对 props 和 state 进行判断以此决定是否进行 render

class A extends React.Component {shouldComponentUpdate(nextProps, nextState) {
        // 两次 props 对比
        return nextProps.a === this.props.a ? false : true
    }
    render() {console.log('render')
        return <div> 这是 A 组件 </div>
    }
}

class Main extends React.Component {
    // ...
    render() {
        return (
            <div>
                <button onClick={() => this.setState({ a: 1})}>Main</button>
                <A a={this.state.a} />
            </div>
        )
    }
}

通过返回 false 来跳过这次更新

使用 React.PureComponent，它与React.Component 区别在于它已经内置了 shouldComponentUpdate 来对 props 和 state 进行浅对比, 并跳过更新

//PureComponent
class A extends React.PureComponent {render() {console.log('render')
        return <div> 这是 A 组件 </div>
    }
}

class Main extends React.Component {
    state = {a: 1}
    render() {
        return (
            <div>
                <button onClick={() => this.setState({ a: 1})}>Main</button>
                <A a={this.state.a} />
            </div>
        )
    }
}

函数组件

使用高阶组件 React.memo 来包裹函数式组件，它和类组件的 PureComponent 类似，也是对对 props 进行浅比较决定是否更新

const A = props => {console.log('render A')
    return <div> 这是 A 组件 </div>
}
// React.memo 包裹 A
const B = React.memo(A)

const Main = props => {const [a, setA] = useState(1)
    console.log('render Main')

    return (
        <div>
            // 通过 setA(a + 1)让父组件重新 render
            <button onClick={() => setA(a + 1)}>Main</button>
            // 一直传入相同的 props 不会让子组件重新 render
            <B a={1} />
        </div>
    )
}

它的第二个参数接受一个两次 props 作为参数的函数，返回 true 则禁止子组件更新

其他

上面提到的浅比较就是根据内存地址判断是否相同：

// extends React.Component
class A extends React.Component {render() {console.log('render A')
        console.log(this.props)
        return <div> 这是组件 A </div>
    }
}

class Main extends React.Component {test = [1, 2, 3]
    render() {console.log('render Main')
        return (
            <div>
                <button
                    onClick={() => {
                        // 父组件 render
                        this.setState({})
                        this.test.push(4)
                    }}
                >
                    Main
                </button>
                <A test={this.test} />
            </div>
        )
    }
}

结果是：
使用 React.component:

使用 React.PureComponent:

使用 React.component，点击之后子组件重新 render。改为 React.PureComponent 之后，点击 button 子组件并不会 render。也因此，PureComponent 根据前后内存地址判断是否相等，所以向子组件传递函数作为 props 时，使用内联箭头函数的形式将会导致子组件的重新 render；所以可以用箭头函数作为成员变量的形式再将函数引用作为 props 传递。