Часто несколько компонентов должны отражать одни и те же изменяющиеся данные. Мы рекомендуем поднимать общее состояние до ближайшего общего предка. Давайте посмотрим, как это работает.
\nВ этом разделе мы создадим калькулятор температуры, вычисляющий вскипит ли вода при заданной температуре.
\nМы начнём с компонента под названием BoilingVerdict. Он принимает температуру по шкале Цельсия в качестве пропа celsius и выводит, достаточна ли температура для кипения воды:
function BoilingVerdict(props) {\n if (props.celsius >= 100) {\n return <p>Вода закипит.</p>; }\n return <p>Вода не закипит.</p>;}Затем мы создадим компонент Calculator. Он рендерит <input> для ввода температуры и сохраняет её значение в this.state.temperature.
Кроме того, он рендерит BoilingVerdict для текущего значения поля ввода.
class Calculator extends React.Component {\n constructor(props) {\n super(props);\n this.handleChange = this.handleChange.bind(this);\n this.state = {temperature: ''}; }\n\n handleChange(e) {\n this.setState({temperature: e.target.value}); }\n\n render() {\n const temperature = this.state.temperature; return (\n <fieldset>\n <legend>Введите температуру в градусах Цельсия:</legend>\n <input value={temperature} onChange={this.handleChange} /> <BoilingVerdict celsius={parseFloat(temperature)} /> </fieldset>\n );\n }\n}Добавим к полю ввода градусов Цельсия поле ввода по шкале Фаренгейта. Оба поля будут синхронизироваться.
\nМы можем начать с извлечения компонента TemperatureInput из Calculator. Добавим в него новый проп scale, значением которого может быть либо "c" или "f":
const scaleNames = { c: 'Цельсия', f: 'Фаренгейта'};\nclass TemperatureInput extends React.Component {\n constructor(props) {\n super(props);\n this.handleChange = this.handleChange.bind(this);\n this.state = {temperature: ''};\n }\n\n handleChange(e) {\n this.setState({temperature: e.target.value});\n }\n\n render() {\n const temperature = this.state.temperature;\n const scale = this.props.scale; return (\n <fieldset>\n <legend>Введите температуру в градусах {scaleNames[scale]}:</legend> <input value={temperature}\n onChange={this.handleChange} />\n </fieldset>\n );\n }\n}Теперь можем изменить Calculator для рендера двух отдельных полей ввода температуры:
class Calculator extends React.Component {\n render() {\n return (\n <div>\n <TemperatureInput scale=\"c\" /> <TemperatureInput scale=\"f\" /> </div>\n );\n }\n}Сейчас у нас есть два поля ввода, но когда вы вводите температуру в одно из них, другое поле не обновляется. Это противоречит нашему требованию — мы хотим их синхронизировать.
\nМы также не можем отображать BoilingVerdict из Calculator. Компонент Calculator не знает текущую температуру, потому что она находится внутри TemperatureInput.
Во-первых, мы напишем две функции для конвертации градусов по шкале Цельсия в Фаренгейт и обратно:
\nfunction toCelsius(fahrenheit) {\n return (fahrenheit - 32) * 5 / 9;\n}\n\nfunction toFahrenheit(celsius) {\n return (celsius * 9 / 5) + 32;\n}Эти две функции конвертируют числа. Мы напишем ещё одну функцию, которая принимает строку с температурой (temperature) и функцию конвертации (convert) в качестве аргументов, и возвращает строку. Мы будем использовать эту функцию для вычисления значения одного поля ввода на основе значения из другого поля ввода.
Данная функция возвращает пустую строку при некорректном значении аргумента temperature и округляет возвращаемое значение до трёх чисел после запятой:
function tryConvert(temperature, convert) {\n const input = parseFloat(temperature);\n if (Number.isNaN(input)) {\n return '';\n }\n const output = convert(input);\n const rounded = Math.round(output * 1000) / 1000;\n return rounded.toString();\n}Например, вызов tryConvert('abc', toCelsius) возвратит пустую строку, а вызов tryConvert('10.22', toFahrenheit) — '50.396'.
В настоящее время оба компонента TemperatureInput независимо хранят свои значения каждое в собственном локальном состоянии:
class TemperatureInput extends React.Component {\n constructor(props) {\n super(props);\n this.handleChange = this.handleChange.bind(this);\n this.state = {temperature: ''}; }\n\n handleChange(e) {\n this.setState({temperature: e.target.value}); }\n\n render() {\n const temperature = this.state.temperature; // ...Однако мы хотим, чтобы эти два поля ввода синхронизировались друг с другом. Когда мы обновляем поле ввода градусов по Цельсию, поле ввода градусов по Фаренгейту должно отражать сконвертированную температуру и наоборот.
\nВ React совместное использование состояния достигается перемещением его до ближайшего предка компонентов, которым оно требуется. Это называется «подъём состояния». Мы удалим внутреннее состояние из TemperatureInput и переместим его в Calculator.
Если Calculator владеет общим состоянием, он становится «источником истины» текущей температуры для обоих полей ввода. Он может предоставить им значения, которые не противоречат друг другу. Поскольку пропсы обоих компонентов TemperatureInput приходят из одного и того же родительского компонента Calculator, два поля ввода будут всегда синхронизированы.
Давайте шаг за шагом посмотрим, как это работает.
\nВо-первых, мы заменим this.state.temperature на this.props.temperature в компоненте TemperatureInput. Пока давайте представим, что this.props.temperature уже существует, хотя нам нужно будет передать его из Calculator в будущем:
render() {\n // Ранее было так: const temperature = this.state.temperature;\n const temperature = this.props.temperature; // ...Мы знаем, что пропсы доступны только для чтения. Когда temperature находилась во внутреннем состоянии, TemperatureInput мог просто вызвать this.setState() для изменения его значения. Однако теперь, когда temperature находится в родительском компоненте в качестве пропа, TemperatureInput не может контролировать его.
В React это обычно решается путём создания «управляемого» компонента. Точно так же, как DOM-элемент <input> принимает атрибуты value и onChange, так и пользовательский TemperatureInput принимает оба пропса temperature и onTemperatureChange от своего родителя Calculator.
Теперь, когда TemperatureInput хочет обновить свою температуру, он вызывает this.props.onTemperatureChange:
handleChange(e) {\n // Ранее было так: this.setState({temperature: e.target.value});\n this.props.onTemperatureChange(e.target.value); // ...\n\nПримечание:
\nВ пользовательских компонентах нет особого смысла в именах пропсов
\ntemperatureилиonTemperatureChange. Мы могли бы назвать их как-то иначе, например,valueиonChange, т. к. подобные имена — распространённое соглашение.
Пропсы onTemperatureChange и temperature будут предоставлены родительским компонентом Calculator. Он будет обрабатывать изменения, модифицируя собственное внутреннее состояние, тем самым повторно отрендеривая оба поля ввода с новыми значениями. Вскоре мы рассмотрим новую реализацию Calculator.
Прежде чем изменить Calculator, давайте вспомним, что поменялось в компоненте TemperatureInput. Мы удалили из него внутреннее состояние, и вместо this.state.temperature теперь используем this.props.temperature. Вместо вызова this.setState(), когда мы хотим изменить состояние, теперь вызываем this.props.onTemperatureChange(), который получен от компонента Calculator:
class TemperatureInput extends React.Component {\n constructor(props) {\n super(props);\n this.handleChange = this.handleChange.bind(this);\n }\n\n handleChange(e) {\n this.props.onTemperatureChange(e.target.value); }\n\n render() {\n const temperature = this.props.temperature; const scale = this.props.scale;\n return (\n <fieldset>\n <legend>Введите градусы по шкале {scaleNames[scale]}:</legend>\n <input value={temperature}\n onChange={this.handleChange} />\n </fieldset>\n );\n }\n}Теперь перейдём к компоненту Calculator.
Мы будем хранить текущие значения temperature и scale во внутреннем состоянии этого компонента. Это состояние, которое мы «подняли» от полей ввода, и теперь оно будет служить «источником истины» для них обоих. Это минимальное представление всех данных, про которое нам нужно знать для рендера обоих полей ввода.
Например, если мы вводим 37 как значение поля ввода для температуры по шкале Цельсия, состояние компонента Calculator будет:
{\n temperature: '37',\n scale: 'c'\n}Если позднее мы изменим поле для ввода градусов по шкале Фаренгейта на 212, состояние Calculator будет:
{\n temperature: '212',\n scale: 'f'\n}Мы могли бы сохранить значения обоих полей ввода, но это оказалось бы ненужным. Достаточно сохранить значение последнего изменённого поля ввода и шкалу, которая это значение представляет. Затем мы можем вывести значение для другого поля ввода, основываясь только на текущих значениях temperature и scale.
Поля ввода остаются синхронизированными, поскольку их значения вычисляются из одного и того же состояния:
\nclass Calculator extends React.Component {\n constructor(props) {\n super(props);\n this.handleCelsiusChange = this.handleCelsiusChange.bind(this);\n this.handleFahrenheitChange = this.handleFahrenheitChange.bind(this);\n this.state = {temperature: '', scale: 'c'}; }\n\n handleCelsiusChange(temperature) {\n this.setState({scale: 'c', temperature}); }\n\n handleFahrenheitChange(temperature) {\n this.setState({scale: 'f', temperature}); }\n\n render() {\n const scale = this.state.scale; const temperature = this.state.temperature; const celsius = scale === 'f' ? tryConvert(temperature, toCelsius) : temperature; const fahrenheit = scale === 'c' ? tryConvert(temperature, toFahrenheit) : temperature;\n return (\n <div>\n <TemperatureInput\n scale=\"c\"\n temperature={celsius} onTemperatureChange={this.handleCelsiusChange} /> <TemperatureInput\n scale=\"f\"\n temperature={fahrenheit} onTemperatureChange={this.handleFahrenheitChange} /> <BoilingVerdict\n celsius={parseFloat(celsius)} /> </div>\n );\n }\n}Теперь, независимо от того, какое поле ввода вы редактируете, this.state.temperature и this.state.scale в Calculator обновляются. Одно из полей ввода получает значение как есть, поэтому введённые пользователем данные сохраняются, а значение другого поля ввода всегда пересчитывается на их основе.
Давайте посмотрим, что происходит, когда вы редактируете поле ввода:
\nonChange на DOM-элементе <input>. В нашем случае это метод handleChange() компонента TemperatureInput.handleChange() в компоненте TemperatureInput вызывает this.props.onTemperatureChange() с новым требуемым значением. Его пропсы, включая onTemperatureChange, были предоставлены его родительским компонентом — Calculator.Calculator рендерился ранее, он указал, что onTemperatureChange в компоненте TemperatureInput по шкале Цельсия — это метод handleCelsiusChange в компоненте Calculator, а onTemperatureChange компонента TemperatureInput по шкале Фаренгейта — это метод handleFahrenheitChange в компоненте Calculator. Поэтому один из этих двух методов Calculator вызывается в зависимости от того, какое поле ввода редактируется.Calculator указывает React сделать повторный рендер себя, используя вызов this.setState() со значением нового поля ввода и текущей шкалой.render() компонентаCalculator, чтобы узнать, как должен выглядеть UI. Значения обоих полей ввода пересчитываются исходя из текущей температуры и шкалы. В этом методе выполняется конвертация температуры.render() конкретных компонентов TemperatureInput с их новыми пропсами, переданными компонентом Calculator. Он узнает, как должен выглядеть UI.render() компонента Boiling Verdict, передавая температуру в градусах Цельсия как проп.Каждое обновление проходит через одни и те же шаги, поэтому поля ввода остаются синхронизированными.
\nДля любых изменяемых данных в React-приложении должен быть один «источник истины». Обычно состояние сначала добавляется к компоненту, которому оно требуется для рендера. Затем, если другие компоненты также нуждаются в нём, вы можете поднять его до ближайшего общего предка. Вместо того, чтобы пытаться синхронизировать состояние между различными компонентами, вы должны полагаться на однонаправленный поток данных.
\nДля подъёма состояния приходится писать больше «шаблонного» кода, чем при подходах с двусторонней привязкой данных, но мы получаем преимущество в виде меньших затрат на поиск и изолирование багов. Так как любое состояние «живёт» в каком-нибудь компоненте, и только этот компонент может его изменить, количество мест с возможными багами значительно уменьшается. Кроме того, вы можете реализовать любую пользовательскую логику для отклонения или преобразования данных, введённых пользователем.
\nЕсли что-то может быть вычислено из пропсов или из состояния, то скорее всего оно не должно находиться в состоянии. Например, вместо сохранения celsiusValue и fahrenheitValue, мы сохраняем только последнюю введённую температуру (temperature) и её шкалу (scale). Значение другого поля ввода можно всегда вычислить из них в методе render(). Это позволяет очистить или применить округление к значению другого поля, не теряя при этом точности значений, введённых пользователем.
Когда вы видите, что в UI что-то отображается неправильно, то можете воспользоваться расширением React Developer Tools. С помощью него можно проверить пропсы и перемещаться по дереву компонентов вверх до тех пор, пока не найдёте тот компонент, который отвечает за обновление состояния. Это позволяет отследить источник багов:
\n![\"Мониторинг](\"/ef94afc3447d75cdc245c77efb0d63be/react-devtools-state.gif\")
","frontmatter":{"title":"Подъём состояния","next":"composition-vs-inheritance.html","prev":"forms.html"},"fields":{"path":"content/docs/lifting-state-up.md","slug":"docs/lifting-state-up.html"}}},"pageContext":{"slug":"docs/lifting-state-up.html"}},"staticQueryHashes":[]}