React学习笔记十二——组件之间的通信方式

￡神魔★判官ぃ 2022-09-05 13:59 110阅读 0赞

## 前言 ##

前面我们直接介绍了用redux来进行组件通信。如果是一些小型的项目，其实我们无需用到redux，那组件之间要如何来通信呢，父传子我们都知道用pros，兄弟组件和一些不相干的组件之间呢？接下来我们就详细的介绍一下组件通信的所有方式。

## 父组件 => 子组件 ##

### props ###

父组件利用props把值或者函数传给子组件，子组件通过this.props.xx去获取；

import React from "react";
    import PropTypes from 'prop-types';
    
    class Child extends React.Component{ 
    	static propTypes = { 
    	    data: PropTypes.string
    	}；
    	static defaultProps = { 
    	   data: '子组件默认数据',
    	 }; 
        render(){ 
             return(
               <div>{ Tthis.props.data}</div>
             )
         } 
    }
    
    class Parent extends React.Component { 
        state = { 
           data: '我是父组件的数据'
        }
        render() { 
            return (
                <Child data={ this.state.data} />
            )
        }
    }

## 子组件 => 父组件 ##

### 方法一：Instance Methods（实例方法） ###

原理和前面的非受控组件一样，就是父组件可以通过使用refs来直接调用子组件实例的方法；

import React from "react";
    
    class Child extends React.Component{ 
    	click = () => { 
    	  return '我是子组件的数据'
    	}
        render(){ 
             return(
               <div>{ Tthis.props.name}</div>
             )
         } 
    }
    
    class Parent extends React.Component { 
        componentDidMount(){ 
          var data = this.child.click()  // 我是子组件的数据
        }
        render() { 
            return (
                <Child ref={ a => this.child = a} />
            )
        }
    }

### 方法二：Callback Functions（回调函数） ###

子组件通过调用父组件传来的回调函数，从而将数据传给父组件；

import React from "react";
    import PropTypes from 'prop-types';
    
    class Child extends React.Component{ 
    	static propTypes = { 
    	    onClick: PropTypes.fun
    	}；	
        render(){ 
             return(
               <div onClick={ () => this.props.onClick('zach')}>Click Me</div>
             )
         } 
    }
    
    class Parent extends React.Component { 
        handleClick = (data) => { 
            console.log("父组件从子组件接受的数据是: " + data)
        }
        render() { 
            return (
                <Child onClick={ this.handleClick} />
            )
        }
    }

### 方法三：Event Bubbling（事件冒泡） ###

巧妙的利用下事件冒泡机制，我们就可以很方便的在父组件的元素上接收到来自子组件元素的点击事件

class Parent extends React.Component { 
      handleClick = () => { 
        console.log('clicked')
      }
      render() { 
        return (
          <div onClick={ this.handleClick}>
             <Child />
          </div>
        );
      }
    }
    
    function Child { 
      return (
        <button>Click</button>
      );    
    }

## 兄弟组件之间 ##

### 借助父组件 ###

首先我们可以看看它们是否是兄弟组件，即它们是否在同一个父组件下。如果不是的话，考虑下用一个组件把它们包裹起来从而变成兄弟组件是否合适。这样一来，它们就可以通过父组件作为中间层来实现数据互通了。

class Parent extends React.Component { 
      state = { count: 0}
      setCount = () => { 
        this.setState({ count: this.state.count + 1})
      }
      render() { 
        return (
          <div>
            <SiblingA
              count={ this.state.count}
            />
            <SiblingB
              onClick={ this.setCount}
            />
          </div>
        );
      }
    
    }

## 不相干的组件之间 ##

### 方法一：Context ###

一种组件通信的方式，常用于祖组件与后代组件之间的通信；  
我们上一章详细的讲过Context的使用方式，这里我们直接放个案例，如果想详细了解可以去上一张看一下；

const MyContext = React.createContext()
    const { Provider,Consumer} = MyContext 
    
    //祖组件
    class A extends React.Component{ 
     state = { 
       useName:'A组件'
     }
     render(){  
      const { useName} = this.state
       return(
         <div> 
           <h2>我是A组件，用户名为：{ useName}</h2>
           <Provider value={ useName}>
             <B/>
           </Provider>
         </div>
       )
     }
    }
    
    //子组件
    class B extends React.Component{ 
     render(){ 
       return(
         <div> 
            <C />
            <D />
            <h2>我是B组件</h2>
            <h2>我从A组件接收到的用户名是：{ }</h2>
         </div>
       )
     }
    }
    
    //孙组件（类组件）
    class C extends React.Component{ 
    static contextType = MyContext //声明需要接收context
     render(){ 
       return(
         <div> 
            <h2>我是C组件</h2>
            <h2>我从A组件接收到的用户名是：{ this.context}</h2>
         </div>
       )
     }
    }
    
    //孙组件（函数组件）
    function D(){  
      return(
        <div>
           <div> 
            <h2>我是D组件</h2>
            <h2>我从A组件接收到的用户名是：
              <Consumer>
                { 
                  value => { 
                    retrun `${ value.useName}`
                  }
                }
              <Consumer/>
            </h2>
         </div>
        </div>
      )
    }

### 方法二：Observer Pattern（观察者模式） ###

观察者模式是软件设计模式里很常见的一种，它提供了一个订阅模型，假如一个对象订阅了某个事件，当那个事件发生的时候，这个对象将收到通知。

这种模式对于我们前端开发者来说是最不陌生的了，因为我们经常会给某些元素添加绑定事件，会写很多的event handlers，比如给某个元素添加一个点击的响应事件elm.addEventListener(‘click’, handleClickEvent)，每当elm元素被点击时，这个点击事件会通知elm元素，然后我们的回调函数handleClickEvent会被执行。这个过程其实就是一个观察者模式的实现过程。

那这种模式跟我们讨论的react组件通信有什么关系呢？当我们有两个完全不相关的组件想要通信时，就可以利用这种模式，其中一个组件负责订阅某个消息，而另一个元素则负责发送这个消息。javascript提供了现成的api来发送自定义事件: CustomEvent，我们可以直接利用起来。

首先，在ComponentA中，我们负责接受这个自定义事件：

class ComponentA extends React.Component { 
        componentDidMount() { 
            document.addEventListener('myEvent', this.handleEvent)
        }
        componentWillUnmount() { 
            document.removeEventListener('myEvent', this.handleEvent)
        }
        
        handleEvent = (e) => { 
            console.log(e.detail.log)  //i'm zach
        }
    }

然后，ComponentB中，负责在合适的时候发送该自定义事件：

class ComponentB extends React.Component { 
        sendEvent = () => { 
            document.dispatchEvent(new CustomEvent('myEvent', { 
              detail: { 
                 log: "i'm zach"
              }
            }))
        }
        
        render() { 
            return <button onClick={ this.sendEvent}>Send</button>
        }
    }

这样我们就用观察者模式实现了两个不相关组件之间的通信。当然现在的实现有个小问题，我们的事件都绑定在了document上，这样实现起来方便，但很容易导致一些冲突的出现，所以我们可以小小的改良下，独立一个小模块EventBus专门这件事：

class EventBus { 
        constructor() { 
            this.bus = document.createElement('fakeelement');
        }
    
        addEventListener(event, callback) { 
            this.bus.addEventListener(event, callback);
        }
    
        removeEventListener(event, callback) { 
            this.bus.removeEventListener(event, callback);
        }
    
        dispatchEvent(event, detail = { }){ 
            this.bus.dispatchEvent(new CustomEvent(event, {  detail }));
        }
    }
    
    export default new EventBus

然后我们就可以愉快的使用它了，这样就避免了把所有事件都绑定在document上的问题：

import EventBus from './EventBus'
    class ComponentA extends React.Component { 
        componentDidMount() { 
            EventBus.addEventListener('myEvent', this.handleEvent)
        }
        componentWillUnmount() { 
            EventBus.removeEventListener('myEvent', this.handleEvent)
        }
        
        handleEvent = (e) => { 
            console.log(e.detail.log)  //i'm zach
        }
    }
    
    class ComponentB extends React.Component { 
        sendEvent = () => { 
            EventBus.dispatchEvent('myEvent', { log: "i'm zach"}))
        }
        
        render() { 
            return <button onClick={ this.sendEvent}>Send</button>
        }
    }

### 方法三：pubsub-js（消息的发布与订阅插件） ###

点击[pubsub-js][]可到GitHup学习，有详细的讲解和使用案例，这里就不做过多讲解；

### 方法四：Redux ###

前面我们已经详细的介绍过了，可以点击下面链接去查看：  
[React学习笔记八——Redux的使用详解][React_Redux]  
[React学习笔记九——React-redux的使用详解][React_React-redux]  
[React学习笔记十——用react-redux实现多组件数据共享案例][React_react-redux]

[pubsub-js]: https://github.com/mroderick/PubSubJS
[React_Redux]: https://blog.csdn.net/qq_44182284/article/details/118362591?spm=1001.2014.3001.5501
[React_React-redux]: https://blog.csdn.net/qq_44182284/article/details/118383860?spm=1001.2014.3001.5501
[React_react-redux]: https://blog.csdn.net/qq_44182284/article/details/118391878?spm=1001.2014.3001.5501