今天就跟大家聊聊有关使用React怎么实现组件间的通信，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。

创新互联公司-专业网站定制、快速模板网站建设、高性价比修武网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式修武网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖修武地区。费用合理售后完善，十年实体公司更值得信赖。

处理组件之间的通信， 主要取决于组件之间的关系，因此我们划分为以下三种：

1. 【父组件】向【子组件】传值；

2. 【子组件】向【父组件】传值；

3. 【组件A】向无关系【组件B】传值，一般为兄弟组件；

一、「父组件」向「子组件」传值

这是最普遍的用法，实现上也非常简单，主要是利用props来实现

// 父组件
import React from 'react';
import Son from './components/son';
class Father extends React.Component {
  constructor(props) {
    // 这里要加super，否则会报错
    super(props);
    this.state = {
      checked: true
    }
  }

  render() {
    return (
      
    )
  }
}

// 子组件
class Son extends React.Component {
  render() {
    // 接收来自父组件的参数
    let checked = this.props.checked,
      text = this.props.text;
    return (
      {text}: 
    )
  }
}

多想一点：

如果组件的嵌套层次太多，那么从外到内的交流成本就会加深，通过 props 传值的优势就不明显，因此，我们还是要尽可能的编写结构清晰简单的组件关系， 既也要遵循组件独立原则，又要适当控制页面，不可能或极少可能会被单用的代码片，可不编写成一个子组件

二、「子组件」向「父组件」传值

我们知道，react的数据控制分为两种，为 props 和 state；其中，props 如上刚介绍过，它是父组件向子组件传值时作为保存参数的数据对象；而 state 是组件存放自身数据的数据对象。这两者最主要的区别就是，props属于父组件传给子组件的只读数据，在子组件中不能被修改，而state在自身组件中使用时，可以通过setState来修改更新。

子组件向父组件传值，需要控制自己的state，并发起父组件的事件回调来通知父组件

// 父组件
import Son from './components/son';
class Father extends React.Component {
  constructor(props) {
    super(props)
    this.state = {
      checked: false
    }
  }
  onChildChanged() {
    this.setState({
      checked: newState
    })
  }

  render() {
    let isChecked = this.state.checked ? 'yes' : 'no';
    return (
      

        Are you checked: {isChecked }
        
      
    )
  }
}

// 子组件
class Son extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      checked: this.props.initialChecked
    }
  }
  onTextChange() {
    let newState = !this.state.check.checked；
    this.setState({
      checked: newState
    });
    // 注意，setState 是一个异步方法，state值不会立即改变，回调时要传缓存的当前值，   
    // 也可以利用传递一个函数(以上传的是对象)，并传递prevState参数来实现数据的同步更新
    this.props.callbackParent(newState);
  }
  render() {
    let text= this.props.text;
    let checked = this.state.checked;
    return (
      {text}: 
    )
  }
}

多想一点：

1. 同样应当避免深层次的组件嵌套

2. 这里其实是依赖了props来传递事件的引用，并通过回调的方式来实现，在没有使用工具情况下，可以使用该办法

拓展一点：

在onChange 事件或者其他React事件中，你能获取以下信息：

1. 「this」 指向你的组件

2. 「一个参数」 一个react合成事件, SyntheticEvent

我们知道，React对所有事件的管理都是自己封装实现的，html中的 onclick 被封装成了 onClick， onchange 被封装成了 onChange。从根本上来说，他们都是被绑定在body上的。

多个子组件回调同一个回调函数情况

父组件中大概率包含多个子组件，为节省和简洁代码，遵循 don't repeat yourself 原则，我们会让一个回调函数实现多个子组件的功能，或多个组件协作完成指定功能

import React from 'react';
import Son from './components/son';
class Father extends React.Componnet {
  constructor(props) {
    super(props);
    this.state = {
      totalChecked: 0
    }
  }
  onChildChangeed() {
    let newTotal = this.state.totalChecked + (new State ? 1 ： -1 )；
    this.setState({
       totalChecked = this.state.totalChecked;
    });
  }
  render() {
    return (
      

        
Checked numbers: {this.state.totalChecked}
        
        
         
      
    )
  }
}

// 子组件
class Son extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      checked: this.props.initialChecked
    }
  } 

  onTextChange() {
    let newState = !this.state.checked;
    this.setState({
      checked: newState
    })
    // setState异步方法问题，注意传值
    this.props.callbackParent(newState);
  }

  render() {
    let text = this.props.checked;
    let checked = this.state.checked;
    return {
      {text}: 
    }
  }
}

多想一点：

在本案例中，我们引用了三个 Son 子组件， 每个 Son 组件都独立工作互不干扰，该例中，增加了一个 totalChecked 来替代之前的 checked, 当组件触发onTextChange 后，触发父组件的回调函数使得父组件的值得以改变。

三、组件A和无关系组件B之间的通信

如果组件之间没有任何关系，或者组件嵌套的层次比较深，或者，你为了一些组件能够订阅，写入一些信号，不想让两个组件之间插入一个组件，而是让两个组件出于独立的关系。对于时间系统，有两个基本操作：

1. 订阅： subscribe

2. 监听： listen

并发送 send / 触发 trigger / 发布 publish / 发送 dispatch 通知那些想要的组件

1. Event Emitter/Target/Dispatcher

特点： 需要一个指定的订阅源

// to subscribe
otherObiect.addEventListener('clickEvent', function() {
  alert('click!');
})
// to dispatch
this.dispatchEvent('clickEvent');

2. Publish / Subscribe

特点： 触发的时候，不需要指定一个特定的源，使用全局对象广播的方式来处理事件

// to subscribe
globalBroadcaster.subcribe('clickEvent', function() {
  alert('cilck!');  
})
// to publish
globalBroadcaster.publish('clickEvent');

这种方案还有一个插件可用， 即 PubSubJs；用法如下：

import Pubsub from 'pubsub-js';
...
// to subscribe
Pubsub.subscribe('EVENT', (msg, param) => {
  console.log(msg, param);
})；
// to publish
Pubsub.publish('EVENT', param);

3. Single

特点： 与 Event Emitter/Target/Dispatcher 类似，但是不要使用随机字符串作为事件触发的引用。触发事件的每一个对象都需要一个确切的名字，并且在触发的时候，也必须要指定确切的事件

// to subscribe
otherObject.clicked.add(function() {
  alert('click');
})
// to dispatch
this.clicked.dispatch();

React 团队使用的是：js-signals 它基于 Signals 模式，用起来相当不错。

事件订阅与取消

使用React事件的时候，必须关注以下两个方法:

1. componentDidMount

2. componentWillUnmount

在 componentDidMount 事件中，等待组件挂载 mounted 完成，再订阅事件；订阅的事件需要在组件卸载 componentWillUnmount 的时候取消事件的订阅。

因为组件的渲染和销毁是有 React 来控制的，我们不知道怎么引用他们，所以EventEmitter 模式在处理事件的时候用处不大，Pub/Sub 模式就好用些，因为我们不需要知道引用在哪。

ES6策略： yield and js-csp

ES6中有一种传递信息的方式，使用生成函数 generators 和 yield 关键字，用法参考以下例子

import csp from 'js-csp';

function* list() {
  for(var i = 0; i< arguments.length; i++) {
    yield arguments[i];
  }
  return "done";
}
var o = list(1, 2, 3);
var cur = o.next;
while (!cur.done) {
  cur = o.next();
  console.log(cur);
}

看完上述内容，你们对使用React怎么实现组件间的通信有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注创新互联行业资讯频道，感谢大家的支持。

分享文章：使用React怎么实现组件间的通信
本文链接：http://scgulin.cn/article/pgsoos.html