频道栏目
首页 > 程序开发 > web前端 > HTML/CSS > 正文
React优化子组件render-个人文章-SegmentFault思否
2019-05-11 22:05:10           
收藏   我要投稿

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

父组件并未传递props给子组件 新传递的props渲染结果不变
class A extends React.Component {
    render() {
        console.log('render')
        return <p>这是A组件</p>
    }
}

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

为了解决这个问题,需要分为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 <p>这是A组件</p>
    }
}

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

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

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

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

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

函数组件

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

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

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

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

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

其他

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

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

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

结果是:
使用React.component:
使用React.component
使用React.PureComponent:
使用React.PureComponent

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

点击复制链接 与好友分享!回本站首页
相关TAG标签
上一篇:【前端刷题笔记02】字节跳动2019面试题-一只想做全栈的猫-SegmentFault思否
下一篇:积梦前端的路由方案ruled-router-题叶-SegmentFault思否
相关文章
图文推荐
点击排行

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站