Состояние как снимок в React

Содержание туториала по React Переменные состояния могут выглядеть как обычные переменные JavaScript, которые вы можете читать и записывать. Однако состояние больше похоже на снимок. Его установка не изменяет уже имеющуюся у вас переменную состояния, а вместо этого запускает повторный рендеринг.

Установка состояния запускает рендеринг

Вы можете думать о своем пользовательском интерфейсе как об изменении непосредственно в ответ на пользовательское событие, такое как клик. В React это работает немного иначе, чем эта ментальная модель. На предыдущей странице вы видели, что изменение состояния запрашивает повторный рендеринг. Это означает, что для того, чтобы интерфейс отреагировал на событие, вам необходимо обновить состояние. В этом примере, когда вы нажимаете "send", setIsSent(true) сообщает React повторно отобразить пользовательский интерфейс:

import { useState } from 'react';

export default function Form() {
  const [isSent, setIsSent] = useState(false);
  const [message, setMessage] = useState('Hi!');
  if (isSent) {
    return <h1>Your message is on its way!</h1>;
  }
  return (
    <form
      onSubmit={(e) => {
        e.preventDefault();
        setIsSent(true);
        sendMessage(message);
      }}
    >
      <textarea
        placeholder="Message"
        value={message}
        onChange={(e) => setMessage(e.target.value)}
      />
      <button type="submit">Send</button>
    </form>
  );
}

function sendMessage(message) {
  // ...
}

Вот что происходит, когда вы нажимаете кнопку:

1. Выполняется обработчик события onSubmit.
2. setIsSent(true) устанавливает isSent в true и кладет в очередь новый рендеринг.
3. React повторно отображает компонент в соответствии с новым значением isSent.

Давайте подробнее рассмотрим взаимосвязь между состоянием и рендерингом.

Рендеринг делает снимок во времени

"Рендеринг" означает, что React вызывает ваш компонент, который является функцией. JSX, который вы возвращаете из этой функции, подобен снимку пользовательского интерфейса в момент времени. Его пропсы, обработчики событий и локальные переменные были рассчитаны с использованием его состояния во время рендеринга. В отличие от фотографии или кадра фильма, "снимок" пользовательского интерфейса, который вы возвращаете, является интерактивным. Он включает в себя логику, такую ​​как обработчики событий, которые определяют, что происходит в ответ на входные данные. Затем React обновляет экран в соответствии с этим снимком и подключает обработчики событий. В результате нажатие кнопки вызовет обработчик кликов из вашего JSX. Когда React перерисовывает компонент:

1. React снова вызывает вашу функцию.
2. Ваша функция возвращает новый снимок JSX.
3. Затем React обновляет экран в соответствии со снимком, который вы вернули.

Состояние, как память компонента, не похоже на обычную переменную, которая исчезает после возврата из вашей функции. Состояние на самом деле «живет» в самом React — как будто на полке! — вне вашей функции. Когда React вызывает ваш компонент, он дает вам снимок состояния для этого конкретного рендеринга. Ваш компонент возвращает снимок пользовательского интерфейса со свежим набором пропсов и обработчиков событий в своем JSX, и все они рассчитаны с использованием значений состояния из этого рендеринга.

Вот небольшой эксперимент, чтобы показать вам, как это работает. В этом примере вы можете ожидать, что нажатие кнопки «+3» увеличит счетчик на три, потому что он вызывается setNumber(number + 1) три раза. Посмотрите, что происходит, когда вы нажимаете кнопку «+3»:

import { useState } from 'react';

export default function Counter() {
  const [number, setNumber] = useState(0);

  return (
    <>
      <h1>{number}</h1>
      <button
        onClick={() => {
          setNumber(number + 1);
          setNumber(number + 1);
          setNumber(number + 1);
        }}
      >
        +3
      </button>
    </>
  );
}

Обратите внимание, что number увеличивается только один раз за клик! Установка состояния изменяет его только для следующего рендера. Во время первого рендера number было 0. Вот почему в обработчике этого рендеринга onClick значение number по-прежнему остается 0 даже после вызова setNumber(number + 1):

<button
  onClick={() => {
    setNumber(number + 1);
    setNumber(number + 1);
    setNumber(number + 1);
  }}
>
  +3
</button>

Вот что обработчик нажатия этой кнопки сообщает React:

1. setNumber(number + 1): number равно 0 таким образом setNumber(0 + 1).
   • React готовится изменить number на 1 в следующем рендеринге.
2. setNumber(number + 1): number равно 0 таким образом setNumber(0 + 1).
   • React готовится изменить number на 1 в следующем рендеринге.
3. setNumber(number + 1): number равно 0 таким образом setNumber(0 + 1).
   • React готовится изменить number на 1 в следующем рендеринге.

Несмотря на то, что вы вызвали setNumber(number + 1) три раза, в этом рендере обработчик событий number всегда равен 0, поэтому вы устанавливаете состояние 1 три раза. Вот почему после завершения обработчика событий React повторно отображает компонент с number равным 1, а не 3. Вы также можете визуализировать это, мысленно заменяя переменные состояния их значениями в своем коде. Поскольку number переменная состояния равна 0 для этого рендера, его обработчик событий выглядит так:

<button
  onClick={() => {
    setNumber(0 + 1);
    setNumber(0 + 1);
    setNumber(0 + 1);
  }}
>
  +3
</button>

Для следующего рендера number равен 1, так что обработчик клика этого рендера выглядит так:

<button
  onClick={() => {
    setNumber(1 + 1);
    setNumber(1 + 1);
    setNumber(1 + 1);
  }}
>
  +3
</button>

Вот почему повторное нажатие на кнопку установит счетчик на 2, затем 3 на следующий клик и т.д.

Состояние с течением времени

Попробуйте угадать, какое сообщение будет выведено в alert при нажатии этой кнопки:

import { useState } from 'react';

export default function Counter() {
  const [number, setNumber] = useState(0);

  return (
    <>
      <h1>{number}</h1>
      <button
        onClick={() => {
          setNumber(number + 5);
          alert(number);
        }}
      >
        +5
      </button>
    </>
  );
}

Если вы используете метод замены из предыдущего, вы можете догадаться, что предупреждение покажет 0:

setNumber(0 + 5);
alert(0);

Но что, если положите alert в таймер, чтобы оно срабатывало только после повторного рендеринга компонента? Будет ли он показывать 0 или 5?

import { useState } from 'react';

export default function Counter() {
  const [number, setNumber] = useState(0);

  return (
    <>
      <h1>{number}</h1>
      <button
        onClick={() => {
          setNumber(number + 5);
          setTimeout(() => {
            alert(number);
          }, 3000);
        }}
      >
        +5
      </button>
    </>
  );
}

Если вы используете метод подстановки, вы можете увидеть «снимок» состояния, переданного в alert.

setNumber(0 + 5);
setTimeout(() => {
  alert(0);
}, 3000);

Состояние, хранящееся в React, могло измениться к моменту запуска оповещения, но оно было запланировано с использованием снимка состояния на момент взаимодействия с ним пользователя. Значение переменной состояния никогда не изменяется в процессе рендеринга, даже если код обработчика событий является асинхронным. Внутри onClick этого рендера значение number продолжает оставаться 0 даже после вызова setNumber(number + 5). Его значение было «фиксировано», когда React «сделал снимок» пользовательского интерфейса, вызвав ваш компонент.

Вот пример того, как это делает ваши обработчики событий менее подверженными ошибкам синхронизации. Ниже представлена ​​форма, которая отправляет сообщение с пятисекундной задержкой. Представьте себе этот сценарий:

1. Вы нажимаете кнопку «Отправить», отправляя «Привет» Алисе.
2. Прежде чем закончится пятисекундная задержка, вы измените значение поля «Кому» на «Боб».

Что будет выведено в alert? Будет ли он отображать «Вы поздоровались с Алисой»? Или он будет отображать «Вы поздоровались с Бобом»? Сделайте предположение, основанное на том, что вы знаете:

import { useState } from 'react';

export default function Form() {
  const [to, setTo] = useState('Alice');
  const [message, setMessage] = useState('Hello');

  function handleSubmit(e) {
    e.preventDefault();
    setTimeout(() => {
      alert(`You said ${message} to ${to}`);
    }, 5000);
  }

  return (
    <form onSubmit={handleSubmit}>
      <label>
        To:{' '}
        <select value={to} onChange={(e) => setTo(e.target.value)}>
          <option value="Alice">Alice</option>
          <option value="Bob">Bob</option>
        </select>
      </label>
      <textarea
        placeholder="Message"
        value={message}
        onChange={(e) => setMessage(e.target.value)}
      />
      <button type="submit">Send</button>
    </form>
  );
}

React сохраняет значения состояния «фиксированными» в обработчиках событий одного рендеринга. Вам не нужно беспокоиться о том, изменилось ли состояние во время выполнения кода. Но что, если вы хотите прочитать последнее состояние перед повторным рендерингом? Вы захотите использовать функцию обновления состояния, описанную на следующей странице.

Резюме

• Состояние установки запрашивает новый рендеринг.
• React хранит состояние вне вашего компонента, как на полке.
• Когда вы вызываете useState, React дает вам снимок состояния для этого рендеринга .
• Переменные и обработчики событий не «выживают» при повторном рендеринге. Каждый рендер имеет свои обработчики событий.
• Каждый рендер (и функции внутри него) всегда будет «видеть» снимок состояния, которое React дал этому рендеру.
• Вы можете мысленно заменить состояние в обработчиках событий, подобно тому, как вы думаете об отрендеренном JSX.
• Обработчики событий, созданные в прошлом, имеют значения состояния из рендеринга, в котором они были созданы.

React, благодаря своим мощным возможностям для создания динамических, интерактивных веб-приложений, стал одним из самых популярных и широко используемых JavaScript-фреймворков в последние годы. Senior разработчики, имеющие опыт работы в React, имеют глубокое понимание основных принципов и лучших практик фреймворка, а также инструментов и методов, необходимых для создания масштабируемого, поддерживаемого кода. Независимо от того, являетесь ли вы опытным разработчиком React или только начинаете, понимание этих стратегий может помочь вам вывести свои навыки на новый уровень и создавать эффективные и элегантные приложения. Итак, давайте углубимся и подробнее рассмотрим, как Senior разработчики создают приложения на React.

Основные принципы React

В основе React лежит набор основных принципов. Понимание этих принципов является ключом к созданию масштабируемых, поддерживаемых приложений React. Одним из наиболее фундаментальных принципов React является концепция «однонаправленного потока данных». Это означает, что данные проходят через приложение в одном направлении, от родительских компонентов до дочерних компонентов. Структурируя приложение таким образом, можно создать четкий и предсказуемый поток данных, упрощающий управление кодом и его отладку. Другим основным принципом React является использование «виртуальной модели DOM» (Document Object Model). Виртуальный DOM представляет собой абстракцию собственной модели DOM браузера, которая позволяет React более эффективно обновлять пользовательский интерфейс, сводя к минимуму количество требуемых фактических обновлений DOM. Используя виртуальный DOM, React может обновлять пользовательский интерфейс быстрым и отзывчивым способом, не требуя ненужных повторных отрисовок или обновлений.

Рекомендации по структурированию и организации кода

Создание масштабируемых, поддерживаемых приложений на React требует тщательного планирования и организации. Вот некоторые рекомендации, которые следует иметь в виду:

Компонентная архитектура

Одним из ключевых преимуществ React является его компонентная архитектура. Разбивая приложение на многократно используемые модульные компоненты, можно создать более гибкую и поддерживаемую кодовую базу. Каждый компонент должен нести четкую и конкретную ответственность и должен быть спроектирован таким образом, чтобы быть как можно более автономным.

Разделение ответственности

Другим важным принципом создания поддерживаемых приложений React является разделение ответственности. Это означает разделение кода на отдельные слои, каждый из которых имеет свои собственные обязанности. Например, у вас может быть слой данных, который обрабатывает выборку данных и манипулирование ими, уровень представления, который обрабатывает отрисовку пользовательского интерфейса, и уровень контейнера, который управляет взаимодействием между ними.

Повторное использование кода

Повторное использование кода является еще одной ключевой стратегией создания масштабируемых приложений React. Повторно используя код везде, где это возможно, можно уменьшить дублирование и повысить общую эффективность кодовой базы. Это может включать в себя создание повторно используемых компонентов или абстрагирование общей функциональности в служебные функции или библиотеки.

Масштабируемая структура папок

Наконец, организация кода в масштабируемую структуру папок может помочь вам более эффективно управлять кодовой базой. Это может включать группирование связанных компонентов или модулей в отдельные каталоги или использование соглашения об именовании, которое упрощает поиск определенных файлов или компонентов. В статьях Структура React приложения, Архитектура современного React приложения подробно описаны варианты масштабируемых структур React проектов.

Инструменты и методы оптимизации производительности и масштабируемости

Даже при тщательном планировании и организации создание масштабируемых, производительных приложений React может быть сложной задачей. Вот некоторые инструменты и методы, которые могут помочь вам оптимизировать производительность и масштабируемость вашего приложения.

Рендеринг на стороне сервера

Отрисовка на стороне сервера (SSR) может помочь сократить время начальной загрузки приложения, отрендерив исходный HTML-код на сервере, а не ожидая, пока клиент загрузит и запустит JavaScript. Это может привести к более быстрому взаимодействию с пользователем, особенно в более медленных сетях или устройствах.

Разделение кода

Разделение кода — это метод, который включает в себя разбивку кода на более мелкие, более управляемые куски и загрузку их только тогда, когда они необходимы. Это может помочь сократить время начальной загрузки приложения и повысить общую производительность за счет уменьшения объема ненужного кода, который необходимо загрузить и выполнить.

Мемоизация

Мемоизация — это метод кэширования результатов дорогостоящих вычислений и их повторного использования при повторном предоставлении тех же входных данных. В контексте React это может быть особенно полезно для оптимизации производительности сложных или дорогостоящих компонентов, предотвращая ненужные повторные рендеры или обновления.

Профилирование производительности

Средства профилирования производительности могут помочь вам определить узкие места производительности в вашем приложении и оптимизировать их для повышения производительности. Эти средства могут предоставить подробную информацию о том, как работает ваше приложение, и помочь вам определить области, в которых требуется оптимизация.

Автоматизированное тестирование

Наконец, автоматизированное тестирование является важным инструментом для обеспечения того, чтобы ваше приложение React работало должным образом. Создавая автоматические тесты, которые охватывают все функциональные возможности вашего приложения, вы можете обнаружить потенциальные проблемы на ранней стадии и убедиться, что ваше приложение всегда работает правильно.