使用React >= 16.3，你可以使用ref和forwardRef，从父节点获取子节点的DOM。不要再用旧的裁判方式了。 下面是使用你的案例的例子:

import React, { Component } from 'react';

export default class P extends React.Component {
   constructor (props) {
      super(props)
      this.state = {data: 'test' }
      this.onUpdate = this.onUpdate.bind(this)
      this.ref = React.createRef();
   }

   onUpdate(data) {
      this.setState({data : this.ref.current.value}) 
   }

   render () {
      return (
        <div>
           <C1 ref={this.ref} onUpdate={this.onUpdate}/>
           <C2 data={this.state.data}/>
        </div>
      )
   }
}

const C1 = React.forwardRef((props, ref) => (
    <div>
        <input type='text' ref={ref} onChange={props.onUpdate} />
    </div>
));

class C2 extends React.Component {
    render () {
       return <div>C2 reacts : {this.props.data}</div>
    }
}

有关Refs和ForwardRef的详细信息，请参见Refs和ForwardRef。

你应该学习Redux和ReactRedux库。它将在一个存储中构建您的状态和道具，您可以稍后在组件中访问它们。

现在已经使用React构建了一个应用程序，我想分享一些关于半年前我问过的问题的想法。

我建议你读一读

React中的思考 通量

第一篇文章对于理解如何构建React应用非常有帮助。

Flux回答了为什么要这样构造React应用程序(而不是如何构造它)的问题。React只占整个系统的50%，而Flux可以让你看到整个系统，看到它们如何构成一个连贯的系统。

回到刚才的问题。

至于我的第一个解决方案，完全可以让处理程序走相反的方向，因为数据仍然是单向的。

但是，让处理程序触发P中的setState是否正确取决于您的情况。

如果应用程序是一个简单的Markdown转换器，C1是原始输入，C2是HTML输出，那么让C1触发P中的setState是可以的，但有些人可能会认为这不是推荐的方法。

然而，如果应用程序是一个待办事项列表，C1是创建新待办事项的输入，C2是HTML中的待办事项列表，你可能想要处理程序比P高两级——到调度程序，它让存储更新数据存储，然后将数据发送给P并填充视图。请参阅Flux的文章。这里有一个例子:Flux - TodoMVC

一般来说，我更喜欢todo列表示例中描述的方式。应用程序的状态越少越好。

第一个解决方案(将状态保存在父组件中)是正确的。然而，对于更复杂的问题，你应该考虑一些状态管理库，redux是react最常用的一个。

五年后，随着React Hooks的引入，现在有了更优雅的方式来使用useContext钩子。

你在全局范围内定义context，在父组件中导出变量、对象和函数，然后在应用中提供的上下文中包装子组件，并在子组件中导入任何你需要的东西。下面是概念的证明。

import React, { useState, useContext } from "react";
import ReactDOM from "react-dom";
import styles from "./styles.css";

// Create context container in a global scope so it can be visible by every component
const ContextContainer = React.createContext(null);

const initialAppState = {
  selected: "Nothing"
};

function App() {
  // The app has a state variable and update handler
  const [appState, updateAppState] = useState(initialAppState);

  return (
    <div>
      <h1>Passing state between components</h1>

      {/* 
          This is a context provider. We wrap in it any children that might want to access
          App's variables.
          In 'value' you can pass as many objects, functions as you want. 
           We wanna share appState and its handler with child components,           
       */}
      <ContextContainer.Provider value={{ appState, updateAppState }}>
        {/* Here we load some child components */}
        <Book title="GoT" price="10" />
        <DebugNotice />
      </ContextContainer.Provider>
    </div>
  );
}

// Child component Book
function Book(props) {
  // Inside the child component you can import whatever the context provider allows.
  // Earlier we passed value={{ appState, updateAppState }}
  // In this child we need the appState and the update handler
  const { appState, updateAppState } = useContext(ContextContainer);

  function handleCommentChange(e) {
    //Here on button click we call updateAppState as we would normally do in the App
    // It adds/updates comment property with input value to the appState
    updateAppState({ ...appState, comment: e.target.value });
  }

  return (
    <div className="book">
      <h2>{props.title}</h2>
      <p>${props.price}</p>
      <input
        type="text"
        //Controlled Component. Value is reverse vound the value of the variable in state
        value={appState.comment}
        onChange={handleCommentChange}
      />
      <br />
      <button
        type="button"
        // Here on button click we call updateAppState as we would normally do in the app
        onClick={() => updateAppState({ ...appState, selected: props.title })}
      >
        Select This Book
      </button>
    </div>
  );
}

// Just another child component
function DebugNotice() {
  // Inside the child component you can import whatever the context provider allows.
  // Earlier we passed value={{ appState, updateAppState }}
  // but in this child we only need the appState to display its value
  const { appState } = useContext(ContextContainer);

  /* Here we pretty print the current state of the appState  */
  return (
    <div className="state">
      <h2>appState</h2>
      <pre>{JSON.stringify(appState, null, 2)}</pre>
    </div>
  );
}

const rootElement = document.body;
ReactDOM.render(<App />, rootElement);

您可以在代码沙盒编辑器中运行此示例。

最近的回答有一个例子，它使用React.useState

将状态保存在父组件中是推荐的方法。父组件需要访问它，因为它跨两个子组件管理它。不建议将其移动到全局状态，就像由Redux管理的状态一样，原因与在软件工程中全局变量通常不如局部变量的原因相同。

当状态在父组件中时，如果父组件在props中给了子组件值和onChange处理程序，子组件就可以改变它(有时它被称为值链接或状态链接模式)。下面是你如何用钩子做这件事:

function Parent() {
    var [state, setState] = React.useState('initial input value');
    return <>
        <Child1 value={state} onChange={(v) => setState(v)} />
        <Child2 value={state}>
    </>
}

function Child1(props) {
    return <input
        value={props.value}
        onChange={e => props.onChange(e.target.value)}
    />
}

function Child2(props) {
    return <p>Content of the state {props.value}</p>
}

整个父组件将在子组件的输入更改时重新呈现，如果父组件很小/重新呈现的速度很快，这可能不是问题。在一般情况下(例如大型表单)，父组件的重新呈现性能仍然是一个问题。这在你的案例中解决了问题(见下文)。

状态链接模式和无父重渲染使用第三方库更容易实现，如Hookstate -增压React。useState涵盖各种用例，包括您的用例。(声明:我是该项目的作者之一)。

这是胡克州的情况。Child1会改变输入，Child2会对它做出反应。Parent将保留状态，但不会在状态改变时重新呈现，只有Child1和Child2会。

import { useStateLink } from '@hookstate/core';

function Parent() {
    var state = useStateLink('initial input value');
    return <>
        <Child1 state={state} />
        <Child2 state={state}>
    </>
}

function Child1(props) {
    // to avoid parent re-render use local state,
    // could use `props.state` instead of `state` below instead
    var state = useStateLink(props.state)
    return <input
        value={state.get()}
        onChange={e => state.set(e.target.value)}
    />
}

function Child2(props) {
    // to avoid parent re-render use local state,
    // could use `props.state` instead of `state` below instead
    var state = useStateLink(props.state)
    return <p>Content of the state {state.get()}</p>
}

附注:这里还有很多类似的例子，它们涵盖了更复杂的场景，包括深度嵌套数据、状态验证、使用setState钩子的全局状态等等。网上还有一个完整的示例应用程序，它使用了Hookstate和上面解释的技术。