React 中如何实现组件之间的通信？


1. Props 传递

最直接的通信方式是通过 props 将数据从父组件传递给子组件。父组件通过属性将数据传递给子组件，而子组件则可以通过

1. this.props

复制代码

访问这些数据。
示例代码：

1. import React from 'react';
   
2. 
   
3. class ParentComponent extends React.Component {
   
4.   render() {
   
5.     const message = "Hello from Parent!";
   
6.     return (
   
7.       <div>
   
8.         <h1>Parent Component</h1>
   
9.         <ChildComponent message={message} />
   
10.       </div>
    
11.     );
    
12.   }
    
13. }
    
14. 
    
15. class ChildComponent extends React.Component {
    
16.   render() {
    
17.     return (
    
18.       <div>
    
19.         <h2>Child Component</h2>
    
20.         <p>{this.props.message}</p>
    
21.       </div>
    
22.     );
    
23.   }
    
24. }
    
25. 
    
26. export default ParentComponent;

复制代码

在这个例子中，ParentComponent 通过 message 属性将数据传递给 ChildComponent，后者通过 this.props.message 访问并展示这条消息。

2. 回调函数

除了通过 props 传递数据外，父组件还可以通过回调函数与子组件进行通信。子组件可以调用来自父组件的函数，与父组件进行状态更新或传递数据。
示例代码：

1. import React from 'react';
   
2. 
   
3. class ParentComponent extends React.Component {
   
4.   handleChildMessage = (msg) => {
   
5.     alert("Message from Child: " + msg);
   
6.   }
   
7. 
   
8.   render() {
   
9.     return (
   
10.       <div>
    
11.         <h1>Parent Component</h1>
    
12.         <ChildComponent onSendMessage={this.handleChildMessage} />
    
13.       </div>
    
14.     );
    
15.   }
    
16. }
    
17. 
    
18. class ChildComponent extends React.Component {
    
19.   sendMessage = () => {
    
20.     this.props.onSendMessage("Hello from Child!");
    
21.   }
    
22. 
    
23.   render() {
    
24.     return (
    
25.       <div>
    
26.         <h2>Child Component</h2>
    
27.         <button onClick={this.sendMessage}>Send Message</button>
    
28.       </div>
    
29.     );
    
30.   }
    
31. }
    
32. 
    
33. export default ParentComponent;

复制代码

在此示例中，子组件中有一个按钮，点击后会触发 sendMessage 方法，通过 this.props.onSendMessage 调用父组件中的方法，从而在父组件中弹出子组件发送的消息。

3. Context API

对于较深层次的组件嵌套，直接通过 props 传递可能会导致 props drilling（即多层传递 props），在这种情况下，使用 React 的 Context API 可以让你在多个组件之间共享数据，而不必通过每一层进行传递。
示例代码：

1. import React from 'react';
   
2. 
   
3. // 创建 Context
   
4. const MessageContext = React.createContext();
   
5. 
   
6. class ParentComponent extends React.Component {
   
7.   state = {
   
8.     message: "Hello from Parent via Context!",
   
9.   };
   
10. 
    
11.   render() {
    
12.     return (
    
13.       <MessageContext.Provider value={this.state.message}>
    
14.         <NestedComponent />
    
15.       </MessageContext.Provider>
    
16.     );
    
17.   }
    
18. }
    
19. 
    
20. class NestedComponent extends React.Component {
    
21.   render() {
    
22.     return (
    
23.       <div>
    
24.         <h1>Nested Component</h1>
    
25.         <ChildComponent />
    
26.       </div>
    
27.     );
    
28.   }
    
29. }
    
30. 
    
31. class ChildComponent extends React.Component {
    
32.   static contextType = MessageContext;
    
33. 
    
34.   render() {
    
35.     return (
    
36.       <div>
    
37.         <h2>Child Component</h2>
    
38.         <p>{this.context}</p>
    
39.       </div>
    
40.     );
    
41.   }
    
42. }
    
43. 
    
44. export default ParentComponent;

复制代码

在这个例子中，ParentComponent 中创建了一个 Context，并使用 Provider 提供值。ChildComponent 通过 static contextType = MessageContext 直接访问 context 中的值。

4. Redux

当应用程序变得复杂时，使用 Redux 进行状态管理可以帮助我们集中管理应用的状态并实现组件间的通信。Redux 将应用的所有状态保存在一个 store 中，并通过 actions 和 reducers 来管理状态的变更。
示例代码：

1. import React from 'react';
   
2. import { createStore } from 'redux';
   
3. import { Provider, connect } from 'react-redux';
   
4. 
   
5. // Redux reducer
   
6. const initialState = { message: "Initial Message" };
   
7. const messageReducer = (state = initialState, action) => {
   
8.   switch (action.type) {
   
9.     case 'UPDATE_MESSAGE':
   
10.       return { ...state, message: action.payload };
    
11.     default:
    
12.       return state;
    
13.   }
    
14. };
    
15. 
    
16. // Create Redux store
    
17. const store = createStore(messageReducer);
    
18. 
    
19. // Parent Component
    
20. class ParentComponent extends React.Component {
    
21.   updateMessage = () => {
    
22.     this.props.updateMessage("New Message from Parent!");
    
23.   }
    
24. 
    
25.   render() {
    
26.     return (
    
27.       <div>
    
28.         <h1>Parent Component</h1>
    
29.         <button onClick={this.updateMessage}>Update Message</button>
    
30.         <ChildComponent />
    
31.       </div>
    
32.     );
    
33.   }
    
34. }
    
35. 
    
36. // Child Component
    
37. const ChildComponent = ({ message }) => {
    
38.   return (
    
39.     <div>
    
40.       <h2>Child Component</h2>
    
41.       <p>{message}</p>
    
42.     </div>
    
43.   );
    
44. };
    
45. 
    
46. // Connect components to Redux store
    
47. const mapStateToProps = state => ({
    
48.   message: state.message,
    
49. });
    
50. 
    
51. const mapDispatchToProps = dispatch => ({
    
52.   updateMessage: (msg) => dispatch({ type: 'UPDATE_MESSAGE', payload: msg }),
    
53. });
    
54. 
    
55. const ConnectedParentComponent = connect(null, mapDispatchToProps)(ParentComponent);
    
56. const ConnectedChildComponent = connect(mapStateToProps)(ChildComponent);
    
57. 
    
58. // App Component
    
59. const App = () => (
    
60.   <Provider store={store}>
    
61.     <ConnectedParentComponent />
    
62.   </Provider>
    
63. );
    
64. 
    
65. export default App;

复制代码

在此示例中，我们通过 Redux 管理状态，

1. ParentComponent

复制代码

可以通过

1. dispatch

复制代码

更新消息，而

1. ChildComponent

复制代码

则直接从 Redux store 获取当前的消息。

总结

在 React 中，组件之间的通信有多种方法，包括 props 传递、回调函数、Context API 以及 Redux 等状态管理工具。选择哪种方法取决于应用的复杂性和需求。简单的应用可以直接使用 props 和回调函数，而复杂的应用则可能需要使用 Context API 或 Redux 来处理状态。通过理解和掌握这些沟通方式，你将能够构建出更高效、更可维护的 React 应用。
以上就是React实现组件之间通信的示例代码的详细内容，更多关于React组件之间通信的资料请关注脚本之家其它相关文章！

来源：https://www.jb51.net/database/335584f67.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！