React组件传参方式你了解吗_Javascript

序言

众所周知，在业务开发中，无论用的什么框架，首要熟悉的有以下几点：

项目搭建，基础配置，命名规范。
路由配置，配置路由规则等。
组件通信，组件规范等等。

我们今天要探究的就是react中组件通信的几种方式，以及各自的应用场景。

父子组件通信

在react中，父组件可以通过 props 向子组件传递数据和回调函数，从而实现父子组件之间的通信。同时，子组件可以通过调用父组件传递的回调函数来向父组件传递数据或者触发父组件的行为，有以下几个注意要点。

props传参，传入数据是只读的。
函数式组件可以直接解构用，类组件需要通过this.props.xxxx。
子组件数据传父组件时，回调函数的返回值就是传的参。

// parentcomponent.js
import react, { usestate } from 'react';
import childcomponent from './childcomponent';

function parentcomponent() {
  const [messagefromchild, setmessagefromchild] = usestate('');

  const handlemessagefromchild = (message) => {
    setmessagefromchild(message);
  };

  return (
    <div>
      <h1>parent component</h1>
      <p>message from child: {messagefromchild}</p>
      <childcomponent givechildren={parentdata} onmessage={handlemessagefromchild} />
    </div>
  );
}

export default parentcomponent;

// childcomponent.js

//1.函数式组件

import react from 'react';

function childcomponent(props) {
  const { onmessage , parentdata } = props;
  const sendmessagetoparent = () => {
    onmessage('hello from child!');
  };

  return (
    <div>
      <h2>child component</h2>
      <h2>{ parentdata }</h2>
      <button onclick={sendmessagetoparent}>send message to parent</button>
    </div>
  );
}

export default childcomponent;

//1. 类组件

import react, { component } from 'react'

export default class childcomponent extends component {
    render() {
        return (
            <div>
                {this.props.parenttochild}
            </div>
        )
    }
}

小结：我们看上面代码，通过在组件上属性名，在子组件中，就可以从props中解构出该属性，这个属性也可以是一个回调函数，当该回调函数调用时，入参就会在父组件的形参那里拿到，跟jsonp的原理一样。

父孙组件通信

聪明的同学相信可以通过父子组件通信举一反三，但是为了一个传参，写好几层回调，这种代码看起来就不适用，所以为了解决这个问题，react 给我们提供了一个方法 createcontext 这是一个创建react 上下文的函数，这个上下文提供了组件中共享值的方法，不用显示的通过props层层传递。

//跨组件通信
import react, { component } from 'react'
//创建context 给初始值
const usermessage = react.createcontext({
    nickname: 'yyy',
    level: 1
})

export default class textsingal extends component {
    constructor(props) {
        super(props)
        this.state = {
            nickname: 'kkk',
            level: 99,
            name: 'ppp',
            age: 9999
        }
    }
    render() {
        const { name, age } = this.state
        return (
            <div>
                <h2>爷爷组件</h2>
                <h3>name:{name}</h3>
                <h3>age:{age}</h3>
                {/* 改变数据孙组件也更新 */}
                <button onclick={() => this.handelclick()}>updated</button>
                {/* 传入state对象和foo回调函数 */}
                {/* foo函数用于孙组件和爷组件通信 */}
                <usermessage.provider value={{ ...this.state, foo: (name, age) => this.updatedatas(name, age) }}>
                    <father />
                </usermessage.provider>

            </div>
        )
    }
    handelclick() {
        this.setstate({
            nickname: '虎威神',
            level: 9999
        })
    }
    updatedatas(name, age) {
        this.setstate({
            name,
            age
        })
    }
}

class father extends component {
    render() {
        return (
            <div>
                <h2>爸爸组件</h2>
                <son />
            </div>
        )
    }
}
class son extends component {
    render() {
        // 解构
        const { nickname, level, foo } = this.context
        return (
            <div>
                <h2>儿子组件</h2>
                <h3>nickname:{nickname}</h3>
                <h3>level:{level}</h3>
                {/* 下面两种调用方式都可以 */}
                {/* 改变爷组件的数据 */}
                <button onclick={() => this.handelclick()}>updated</button>
                <button onclick={() => foo('牛霸天', 18)}>updated</button>
            </div>
        )
    }
    handelclick() {
        this.context.foo('牛霸天', 18)
    }
}
// 接受爷组件传递的值
son.contexttype = usermessage

小结：通过上述我们创建了一个context，然后用context.provider 将组件包裹，那么被包裹的组件将会共享这个context，在context上定义回调，在孙组件通过 this.context 即可调用回调，或者使用传入数据。

兄弟组件通信

相对于vue中兄弟组件传参，react会相对原始一些，vue中可以通过evenbus，便捷的在各种组件中传递参数。而react的做法是，在兄弟组件共同的父组件中，创建一个公用的state，然后兄弟a组件通过跟父组件传递传参改变这个state，父组件将新值也传给b组件，以达到兄弟组件传参的目的。

父组件

//父组件
import react, {component} from "react"
import abrother from './abrother'
import bbrother from './bbrother'

export default class common extends component {
    // 公共的组件部分
    state = {
        inputvalue:''
    }

    handleupdate = (inputvalue) => {
        this.setstate({
            inputvalue
        })
    }

    render(){
        return(
            <>
              <abrother sendfn={this.handleupdate}/>
              <bbrother sendvalue={this.state.inputvalue}/>
            </>
        )
    }
}

兄弟a

import react,{component} from "react";

export default class abrother extends component {

    // 兄弟组件a需要将值先传给一个公共的父组件
    state = {
        inputvalue:''
    }

    handlechange = (e)=>{
        console.log(e.target.value);
        this.setstate({
            inputvalue:e.target.value
        })
    }
    handlesend = () => {
        const {sendfn} = this.props;
        sendfn(this.state.inputvalue)
    }

    render(){
        return(
            <>
               <div>
                   <span>a组件</span>
                   <input type='text' value={this.state.inputvalue} onchange={this.handlechange}></input>
                   <button onclick={this.handlesend}>发送a组件的值</button>
               </div>
            </>
        )
    }
}

兄弟b

import react, {component} from "react"

export default class bbrother  extends component {


    render(){
        const { sendvalue} = this.props;
        return (
            <div>
                <span>b组件</span>
                <h1>{ sendvalue }</h1>
            </div>
        )
    }
}

小结: 组件a,想要将输入框中的值传给组件b，那么先在父组件的 state 中定义一个变量，这个变量就是要传给组件 b 中的值，父组件中将这个值通过props的形式传入b组件。接下来定义父组件和a组件中的回调函数触发，当a组件数据移动，调用回调函数，改变父组件 state 中的值，以达到将新值传给b组件的目的。