点击查看【bilibili】

children props

通常来说,在react中父子组件传递数据,都是通过props的形式,

  1. class Parent extends React.Component{
  2. state = {name: 'Tom'}
  3. render() {
  4. return <child name = {this.state.name}/>
  5. }
  6. }
  7. class Child extends React.Component{
  8. render() {
  9. console.log(this.props.name)
  10. return
  11. }
  12. }

很自然的,我们可以在Child组件中通过this.props.name拿到数据。那么,下面这种写法Child组件如何拿到数据呢?

  1. class Parent extends React.Component{
  2. state = {name: 'Tom'}
  3. render() {
  4. return (
  5. <Child>
  6. {this.state.name}
  7. <Child/>
  8. )
  9. }
  10. }

原来,在React中,将标签体里面的内容通过props中的children属性传递给了子组件。那么Child组件这么写可以拿到父组件的数据。

  1. class Child extends React.Component{
  2. render() {
  3. console.log(this.props.children)
  4. return
  5. }
  6. }

我们对于父组件—子组件—孙组件的嵌套写法如下所示:

  1. // 父组件
  2. class Parent extends Component {
  3. render() {
  4. return ( <A/> );
  5. }
  6. }
  7. // 子组件
  8. class A extends Component {
  9. render() {
  10. return ( <B/> );
  11. }
  12. }
  13. // 孙组件
  14. class B extends Component {
  15. render() {
  16. return ( );
  17. }
  18. }

同样的,我们可以在Parent组件中来构造AB组件的父子关系。并在A组件中使用this.props.children

  1. // 父组件
  2. class Parent extends Component {
  3. render() {
  4. return (
  5. <A>
  6. <B/>
  7. </A>
  8. )
  9. }
  10. }
  11. // 子组件
  12. class A extends Component {
  13. render() {
  14. return ( <div> {this.props.children} </div> );
  15. }
  16. }
  17. // 孙组件
  18. class B extends Component {
  19. render() {
  20. return ( <h3>我是B组件</h3> );
  21. }
  22. }

但是,当组件A需要传递值给组件B时,如何在Parent组件中传递值呢?很显然在Parent组件无法获得A组件的name。那我又想把A的name传递给B。how?这时候就引出了render props的做法。

  1. // 父组件
  2. class Parent extends Component {
  3. render() {
  4. return (
  5. <A>
  6. <B/>
  7. </A>
  8. );
  9. }
  10. }
  11. // 子组件
  12. class A extends Component {
  13. state = {name: "Tom"}
  14. ...
  15. }
  16. // 孙组件
  17. class B extends Component {
  18. ...
  19. }

render props

直接上方案:

  1. class Parent extends Component {
  2. render() {
  3. return (
  4. <div>
  5. <h3>我是Parent组件</h3>
  6. <A render={(name) => <B name={name}/>}/>
  7. </div>
  8. );
  9. }
  10. }
  11. class A extends Component {
  12. state = {name: "Tom"}
  13. render() {
  14. return (<div> {this.props.render(this.state.name)} </div>)
  15. }
  16. }
  17. class B extends Component {
  18. render() {
  19. return (<h4>{this.props.name}</h4>)
  20. }
  21. }

在Parent组件中,给A组件传递一个render方法,该方法参数为name,返回一个组件B,且props为传递的参数。之后在组件A中调用render方法。

意义

为什么要这么麻烦呢?直接Parent里嵌套A,A里嵌套B,数据通过props传递不行吗?当然可以,但在开发过程中AB组件可能由不同的人开发,并不确定AB会成为父子组件,直接在A里写死并不是合适的做法。因此,通过render props这种方式,可以最后确定AB组件的关系,并且还能传递数据。

参考

官方 render props