re:re:actable
Урок 094 минуты чтения

Reconciliation и diffing-алгоритм: как React решает, что обновить

На этой странице
Кратко

Reconciliation — процесс, в котором React сравнивает новое дерево элементов с предыдущим и решает, какие компоненты сохранить (с их состоянием), обновить или пересоздать и какие изменения внести в DOM. Точное сравнение двух произвольных деревьев стоит O(n³), поэтому React использует эвристический diffing-алгоритм за O(n) на трёх правилах: разный тип на той же позиции → поддерево пересоздаётся (состояние теряется); тот же тип → обновляются props/атрибуты, состояние сохраняется; дети списка сопоставляются по key. Идентичность компонента определяется позицией в дереве + типом + key. Отсюда практические следствия: не объявлять компоненты внутри компонентов, использовать стабильные ключи и сбрасывать состояние сменой key.

Вопрос

Что такое reconciliation и diffing-алгоритм? Как React определяет, что обновить, а что пересоздать?

Где reconciliation в цикле обновления

setState → Render phase                         → Commit phase
           ├─ вызвать компоненты                  └─ применить список изменений к DOM,
           ├─ получить новое дерево элементов        запустить эффекты
           └─ RECONCILIATION: сравнить со старым,
              составить список изменений

Правило 1: разный тип — разные деревья

function Page({ isAdmin }) {
  return isAdmin ? <AdminPanel /> : <UserPanel />;
}
было:  <UserPanel>  (state: открытая вкладка "профиль")
стало: <AdminPanel>
→ тип отличается → UserPanel размонтирован (state потерян, cleanup эффектов),
  AdminPanel смонтирован с нуля

То же для DOM-тегов: <div> → <section> пересоздаёт всё содержимое, включая дочерние компоненты.

Правило 2: тот же тип — обновление

function Profile({ editing }) {
  return editing
    ? <input defaultValue="Анна" />
    : <input disabled defaultValue="Анна" />;
}

Тег тот же (input) на той же позиции → React меняет только атрибут disabled. Введённый пользователем текст сохраняется, потому что DOM-узел тот же.

Для компонентов: тот же тип → экземпляр (и его state) сохраняется, компонент рендерится с новыми props.

Правило 3: списки — по key

Без key (по индексу):              С key:
было: [Анна, Борис]                было: [a:Анна, b:Борис]
стало: [Вера, Анна, Борис]         стало: [v:Вера, a:Анна, b:Борис]
  0: Анна → Вера   (изменить)        v — новый → вставить в начало
  1: Борис → Анна  (изменить)        a, b — те же → не трогать
  2: — → Борис     (создать)
  3 операции + state «съезжает»      1 операция, state на месте

Позиция в дереве = идентичность

// Одинаковый тип и позиция → React считает это ТЕМ ЖЕ счётчиком
{isPlayerA ? <Counter person="Анна" /> : <Counter person="Борис" />}
// Переключение игрока сохранит счёт — state не сбросится!
 
// Решение 1: разные позиции
{isPlayerA && <Counter person="Анна" />}
{!isPlayerA && <Counter person="Борис" />}
 
// Решение 2: разные key — разные компоненты для React
{isPlayerA ? <Counter key="anna" person="Анна" /> : <Counter key="boris" person="Борис" />}

Сброс состояния через key

function ChatPage({ contactId }) {
  // Новый собеседник → новый key → форма с черновиком создаётся заново
  return <MessageForm key={contactId} contactId={contactId} />;
}

Это правильная замена эффекту «очистить поле при смене contactId».

Ловушка: компонент внутри компонента

function Parent() {
  const [text, setText] = useState("");
 
  // ✗ Каждый рендер создаёт НОВУЮ функцию Input → новый тип для React
  function Input() {
    return <input value={text} onChange={(e) => setText(e.target.value)} />;
  }
 
  return <Input />; // после каждого символа input пересоздаётся → теряется фокус
}
// ✓ Объявлять компоненты на верхнем уровне модуля
function Input({ value, onChange }) {
  return <input value={value} onChange={onChange} />;
}
 
function Parent() {
  const [text, setText] = useState("");
  return <Input value={text} onChange={(e) => setText(e.target.value)} />;
}

Кто вообще будет сравниваться

Причина ререндераЧто происходит
Изменился state компонентаРендерится он и всё поддерево
Изменился контекст, который он читаетРендерится потребитель
Отрендерился родительРендерятся дети (если не memo и не тот же элемент из children)
memo и props поверхностно равныПоддерево пропускается

React сравнивает результат рендера, а не DOM: если JSX не изменился, в DOM ничего не попадает.

Что важно помнить

  • Идентичность = тип + позиция + key.
  • Разный тип → пересоздание и потеря state; тот же тип → обновление.
  • Списки — стабильные key из данных.
  • Смена key — штатный способ сбросить состояние.
  • Не объявлять компоненты внутри компонентов.
  • Reconciliation идёт в render-фазе (может прерываться в concurrent-режиме), изменения DOM — в синхронном commit.

Мини-шпаргалка

  • Reconciliation = сравнение старого и нового дерева, O(n).
  • Разный тип → пересоздать. Тот же тип → обновить.
  • Списки → по key.
  • Смена key → сброс state.
  • Компоненты — только на верхнем уровне модуля.

Документация

Дочитали до конца?
Отметьте урок — прогресс сохранится в браузере.

Поиск

Поиск по урокам