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则禁止子组件更新

• useCallback 在函数组件中，函数做为props传递给子组件时，不管子组件是pureComponent仍是用React.memo进行包裹，都会让子组件render，须要使用useCallback来对传递的方法进行保存，将useCallback的返回值传递给子组件就能让子组件不随父组件render。固然，使用闭包的形式，将变量保存在组件外部再传入也能解决这个问题。

其余

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

// 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传递。