TeoreticQuiz

React

Материал для подготовки к собеседованию (Middle / Senior). Ориентир — современный React (функциональные компоненты и хуки, React 18/19). Термины на английском там, где это принято.

Содержание


Что такое React

React — библиотека (не фреймворк) для построения пользовательских интерфейсов, от Meta. Отвечает за слой представления (view), а роутинг/состояние/запросы подключают отдельными библиотеками.

Ключевые идеи:

  • Декларативность — описываешь, как UI должен выглядеть при данном состоянии, React сам обновляет DOM.
  • Компонентный подход — UI из переиспользуемых компонентов.
  • Однонаправленный поток данных (one-way data flow) — данные текут сверху вниз (props), изменения идут через колбэки/состояние.
  • UI = f(state) — представление это функция от состояния; меняется состояние → React перерисовывает.

Современный React пишут на функциональных компонентах с хуками (классовые компоненты — legacy, но встречаются).

function Counter() {
  const [count, setCount] = useState(0);
  return <button onClick={() => setCount(count + 1)}>Кликнули {count} раз</button>;
}

JSX

JSX — синтаксическое расширение JavaScript, похожее на HTML. Компилируется (Babel/SWC) в вызовы React.createElement(...) (или jsx() в новом transform), которые создают объекты-элементы (описания UI).

const el = <h1 className="title">Привет, {name}</h1>;
// компилируется примерно в:
const el = React.createElement("h1", { className: "title" }, "Привет, ", name);

Важные особенности JSX:

  • className вместо class, htmlFor вместо for, camelCase для атрибутов (onClick, tabIndex).
  • В {} вставляют любое JS-выражение (не оператор): {user.name}, {items.map(...)}, {cond ? a : b}.
  • Компонент должен возвращать один корневой узел — используют <>...</> (Fragment), чтобы не плодить лишние div.
  • Условный рендер — тернарник или &&: {isOpen && <Modal />}.
  • JSX защищает от XSS — значения в {} экранируются автоматически (сырой HTML только через dangerouslySetInnerHTML).

Компоненты и props

Props — входные данные компонента, передаются сверху вниз и иммутабельны (компонент не должен их менять).

function UserCard({ name, age = 18, children }) {
  return (
    <div>
      <h2>{name}, {age}</h2>
      {children}   {/* всё, что вложено между тегами компонента */}
    </div>
  );
}

// Использование
<UserCard name="Вася" age={30}>
  <p>Дополнительный контент</p>
</UserCard>
  • children — специальный проп: содержимое между открывающим и закрывающим тегами (аналог слотов в Vue).
  • Поднятие состояния (lifting state up) — если двум компонентам нужно общее состояние, его выносят в ближайшего общего родителя и передают вниз через props, а изменения — через колбэки.
  • Односторонний поток данных: данные вниз (props), события вверх (колбэк-функции из props).
// Родитель владеет состоянием, ребёнок сообщает об изменении через колбэк
function Parent() {
  const [text, setText] = useState("");
  return <Child value={text} onChange={setText} />;
}

Virtual DOM и reconciliation

Virtual DOM (VDOM) — лёгкое представление реального DOM в виде объектов JS (дерево React-элементов). Прямые операции с DOM медленные, поэтому React работает с VDOM в памяти.

Как это работает:

  1. Компонент рендерится → создаётся дерево элементов (VDOM).
  2. При изменении состояния/props создаётся новое дерево.
  3. React сравнивает новое дерево со старым — reconciliation (алгоритм согласования) с эвристикой diffing за O(n).
  4. Вычисляется минимальный набор изменений и применяется к реальному DOM (commit).
setState
  → новый VDOM (в памяти, быстро)
  → diff со старым VDOM (reconciliation)
  → commit: точечно обновить реальный DOM

Эвристики diffing: элементы разных типов дают полное пересоздание поддерева; элементы одного типа обновляются на месте; списки сопоставляются по key.


key в списках

При рендере списка каждому элементу нужен key — стабильный уникальный идентификатор. По нему React сопоставляет элементы между рендерами: понимает, какой переиспользовать, какой создать/удалить.

{users.map((u) => <li key={u.id}>{u.name}</li>)}

Антипаттерн — key по индексу (key={index}): при вставке/удалении/сортировке индексы сдвигаются, React путает элементы → баги с состоянием (например, значения в input «перескакивают» между строками, неверные анимации). Индекс допустим только для статичных списков, которые не меняют порядок.


useState

useState хранит локальное состояние функционального компонента. Возвращает пару [значение, сеттер].

const [count, setCount] = useState(0);
const [user, setUser] = useState({ name: "", age: 0 });

setCount(count + 1);
setCount((prev) => prev + 1);   // функциональное обновление — когда новое зависит от старого

Важные моменты:

  • Состояние иммутабельно — нельзя мутировать напрямую (user.age = 5 не вызовет ре-рендер). Создают новый объект/массив:
setUser((prev) => ({ ...prev, age: 5 }));       // объект
setItems((prev) => [...prev, newItem]);          // массив
  • Обновление асинхронно и батчится — в одном обработчике несколько setState собираются в один ре-рендер. Поэтому при зависимости от предыдущего значения используют функциональную форму setCount(prev => prev + 1).
  • Ленивая инициализация — если начальное значение дорого вычислять: useState(() => expensiveInit()) (функция выполнится один раз).
  • Set-функция стабильна — её ссылка не меняется между рендерами (можно не добавлять в зависимости).

Рендеринг: когда и почему компонент перерисовывается

Ключевая тема на собеседовании. Компонент ре-рендерится (вызывается его функция заново), когда:

  1. Изменилось его состояние (useState/useReducer).
  2. Изменились его props (потому что перерендерился родитель).
  3. Перерендерился родитель — по умолчанию React рендерит всё поддерево вниз, даже если props ребёнка не изменились.
  4. Изменилось значение context, который компонент читает.

Важно: «ре-рендер» ≠ «обновление DOM». React вызывает функцию компонента и строит новый VDOM, но в реальный DOM попадают только отличия (после diffing). Лишние ре-рендеры всё равно стоят CPU (пересоздание элементов, diffing).

Как избегают лишних ре-рендеров: React.memo (мемоизация компонента по props), useMemo/useCallback (стабилизация значений/функций), правильная структура состояния (не поднимать состояние выше нужного), композиция через children.


useEffect

useEffect — для побочных эффектов (side effects): запросы к API, подписки, таймеры, ручная работа с DOM, логирование. Выполняется после рендера и коммита в DOM — обычно асинхронно после отрисовки (paint), но если обновление вызвано дискретным вводом (клик, нажатие клавиши), React может выполнить эффект синхронно до paint.

useEffect(() => {
  // эффект
  const timer = setInterval(tick, 1000);

  return () => clearInterval(timer);  // функция очистки (cleanup)
}, [/* зависимости */]);

Массив зависимостей управляет запуском:

  • Нет массива — эффект после каждого рендера.
  • [] (пустой) — один раз при монтировании (и cleanup при размонтировании).
  • [a, b] — при изменении a или b.

Cleanup-функция вызывается перед следующим запуском эффекта и при размонтировании — там отписываются от событий, чистят таймеры, отменяют запросы (иначе утечки памяти).

// Загрузка данных с отменой (защита от race condition)
useEffect(() => {
  const controller = new AbortController();
  fetch(`/api/user/${id}`, { signal: controller.signal })
    .then((r) => r.json())
    .then(setUser)
    .catch((e) => { if (e.name !== "AbortError") console.error(e); });
  return () => controller.abort();
}, [id]);

Частые ошибки: неполный массив зависимостей (устаревшие значения — stale closure); бесконечный цикл (эффект меняет состояние, от которого сам зависит); эффект для того, что можно вычислить при рендере (не нужен useEffect для производных данных). В React 18 в StrictMode эффекты в dev вызываются дважды — чтобы выявить отсутствие cleanup.

useLayoutEffect — как useEffect, но выполняется синхронно после мутаций DOM, до отрисовки (браузер ещё не показал кадр). Нужен для измерения layout / предотвращения «мигания». Использовать редко — блокирует отрисовку.


useRef

useRef хранит мутируемое значение, которое переживает ре-рендеры и не вызывает ре-рендер при изменении.

const inputRef = useRef(null);

// 1) Доступ к DOM-элементу
<input ref={inputRef} />;
inputRef.current.focus();

// 2) Хранение значения между рендерами (таймеры, предыдущее значение)
const renderCount = useRef(0);
renderCount.current++;   // не триггерит ре-рендер

Отличие от useState: изменение ref.current не перерисовывает компонент. Используют для ссылок на DOM, хранения таймеров/подписок, «мгновенных» значений, которые не влияют на отображение. Пробросить ref в дочерний компонент — forwardRef (в React 19 ref можно передавать как обычный проп).


useMemo и useCallback

Оба мемоизируют результат между рендерами, чтобы не пересчитывать/не пересоздавать.

  • useMemo — кэширует значение (результат дорогого вычисления):
const sorted = useMemo(() => bigList.slice().sort(compare), [bigList]);
  • useCallback — кэширует функцию (её ссылку). useCallback(fn, deps) ≡ useMemo(() => fn, deps):
const handleClick = useCallback(() => doSomething(id), [id]);

Зачем: сохранить стабильную ссылку, чтобы:

  • не срабатывали лишние ре-рендеры у дочерних компонентов, обёрнутых в React.memo (им передают эту функцию/значение как проп);
  • не перезапускались эффекты, у которых значение/функция в зависимостях.

Важно: мемоизация не бесплатна (память + сравнение зависимостей). Не оборачивать всё подряд — только там, где вычисление реально дорогое или ссылка нужна для мемоизированного ребёнка/эффекта. (React Compiler — отдельный инструмент сборки (Babel-плагин), не часть React 19 — частично автоматизирует мемоизацию.)


useContext

Context — способ передать данные вглубь дерева без «прокидывания props через все уровни» (prop drilling): тема, текущий пользователь, локаль.

const ThemeContext = createContext("light");

function App() {
  return (
    <ThemeContext.Provider value="dark">
      <Toolbar />
    </ThemeContext.Provider>
  );
}

function Button() {
  const theme = useContext(ThemeContext);  // "dark" — с любой глубины
  return <button className={theme}>OK</button>;
}

Нюанс производительности: при изменении value в Provider перерисовываются все потребители контекста. Поэтому context хорош для редко меняющихся данных (тема, auth), а для часто меняющегося глобального состояния берут стор (Zustand/Redux) или разбивают контекст на части.


useReducer

useReducer — альтернатива useState для сложной логики состояния (много связанных полей, переходы состояний). Похож на Redux в миниатюре: состояние меняется через dispatch(action) и чистую функцию-редьюсер.

function reducer(state, action) {
  switch (action.type) {
    case "increment": return { count: state.count + 1 };
    case "reset":     return { count: 0 };
    default:          return state;
  }
}

function Counter() {
  const [state, dispatch] = useReducer(reducer, { count: 0 });
  return (
    <>
      {state.count}
      <button onClick={() => dispatch({ type: "increment" })}>+</button>
    </>
  );
}

Когда useReducer вместо useState: сложные переходы, следующее состояние зависит от предыдущего, логику удобно тестировать отдельно (редьюсер — чистая функция). Часто сочетают с Context для «локального стора».


Правила хуков

Два строгих правила (их проверяет ESLint-плагин eslint-plugin-react-hooks):

  1. Вызывать хуки только на верхнем уровне компонента/кастомного хука — не внутри условий, циклов, вложенных функций. React опирается на порядок вызова хуков между рендерами (внутренне они хранятся списком по индексу); условный вызов ломает соответствие.
  2. Вызывать хуки только из React-функций — из компонентов или других хуков, не из обычных функций.
// ПЛОХО — условный вызов
if (isReady) { const [x] = useState(0); }

// ХОРОШО — хук наверху, условие внутри
const [x, setX] = useState(0);
if (isReady) { /* ... */ }

Кастомные хуки

Кастомный хук — функция с именем useXxx, инкапсулирующая переиспользуемую логику с хуками. Возвращает то, что нужно компоненту (значения, функции).

function useWindowWidth() {
  const [width, setWidth] = useState(window.innerWidth);
  useEffect(() => {
    const onResize = () => setWidth(window.innerWidth);
    window.addEventListener("resize", onResize);
    return () => window.removeEventListener("resize", onResize);
  }, []);
  return width;
}

// Использование
const width = useWindowWidth();

Кастомные хуки — основной способ переиспользования логики в React (вместо устаревших HOC и render-props). Каждый компонент, использующий хук, получает своё изолированное состояние.


React.memo и оптимизация ре-рендеров

React.memo — обёртка над компонентом: пропускает ре-рендер, если props не изменились (поверхностное сравнение, shallow compare).

const Child = React.memo(function Child({ value, onClick }) {
  return <button onClick={onClick}>{value}</button>;
});

Чтобы React.memo реально помогал, передаваемые пропсы-объекты/функции должны быть стабильными — иначе shallow compare каждый раз видит «новое» значение. Отсюда связка: React.memo + useCallback/useMemo для пропсов.

Приёмы оптимизации:

  • React.memo для «тяжёлых» дочерних компонентов, часто получающих те же props.
  • useMemo/useCallback для стабильных значений/функций-пропсов.
  • Композиция через children — передача JSX как проп: React не перерендерит children, если перерендерился только обёртка.
  • Не поднимать состояние выше, чем нужно (локализовать).
  • Виртуализация длинных списков (react-window / react-virtualized).
  • Профилирование через React DevTools Profiler (найти, что и почему рендерится).

Классовый аналог мемоизации — shouldComponentUpdate / PureComponent.


Управление состоянием

Виды состояния и подходящие инструменты:

  • Локальное состояние компонента — useState/useReducer.
  • Общее для нескольких компонентов — lifting state up + props, или Context для «локально глобального».
  • Глобальное клиентское состояние — библиотеки: Redux Toolkit (предсказуемость, devtools, большие приложения), Zustand (минималистичный, популярный), MobX, Jotai/Recoil (атомарный подход).
  • Серверное состояние (server state) — данные с бэкенда: TanStack Query (React Query) / RTK Query / SWR (см. ниже).

Redux (кратко): единый store, состояние иммутабельно, изменения только через dispatch(action) и чистые редьюсеры; поток однонаправленный. Redux Toolkit убирает бойлерплейт (createSlice, встроенный Immer для «мутабельного» синтаксиса, thunk для асинхронности).

Правило: не тащить всё в глобальный стор. Server state — в React Query, UI-состояние — локально, глобальный стор — только для действительно общего клиентского состояния.


Работа с данными и server state

Загрузка данных с бэкенда — отдельная задача с проблемами: кэширование, дедупликация запросов, инвалидация, повторные попытки, состояния loading/error, race conditions.

«Ручной» подход через useEffect + useState работает, но не решает кэш/инвалидацию:

const [data, setData] = useState(null);
const [loading, setLoading] = useState(true);
useEffect(() => {
  let ignore = false;
  fetch(url).then(r => r.json()).then(d => { if (!ignore) setData(d); }).finally(() => setLoading(false));
  return () => { ignore = true; };  // защита от race condition
}, [url]);

TanStack Query (React Query) — стандарт для server state: кэш, автоматическая инвалидация, повторные попытки, фоновое обновление, дедупликация:

const { data, isLoading, error } = useQuery({
  queryKey: ["user", id],
  queryFn: () => fetch(`/api/user/${id}`).then((r) => r.json()),
});

Почему это лучше ручного useEffect: из коробки кэширование по queryKey, статусы, staleTime, повтор при ошибке, мутации с инвалидацией. Ключевая мысль на собеседовании: отделять серверное состояние от клиентского — для первого есть специализированные инструменты.


Формы

  • Controlled (управляемые) — значение поля хранится в state, поле управляется React (single source of truth):
const [value, setValue] = useState("");
<input value={value} onChange={(e) => setValue(e.target.value)} />;
  • Uncontrolled (неуправляемые) — значение хранит сам DOM, читаем через ref (проще, меньше ре-рендеров):
const inputRef = useRef(null);
<input ref={inputRef} defaultValue="" />;
// при сабмите: inputRef.current.value

Для больших форм с валидацией используют библиотеки (React Hook Form — минимум ре-рендеров через неуправляемые поля, Formik). React Hook Form популярен из-за производительности.


Error Boundaries

Error Boundary — компонент, который ловит ошибки рендера в дочернем дереве и показывает запасной UI (fallback), а не «белый экран». Реализуется классовым компонентом (хуковой версии нет, но есть обёртки типа react-error-boundary).

class ErrorBoundary extends React.Component {
  state = { hasError: false };
  static getDerivedStateFromError() { return { hasError: true }; }
  componentDidCatch(error, info) { logError(error, info); }
  render() {
    return this.state.hasError ? <FallbackUI /> : this.props.children;
  }
}

Не ловит: ошибки в обработчиках событий (там обычный try/catch), асинхронный код, ошибки самого boundary, SSR.


Fiber, Concurrent, Suspense

Fiber — переработанная (с React 16) внутренняя архитектура согласования. Позволяет разбивать работу рендера на маленькие единицы и прерывать/возобновлять её (раньше рендер был синхронным и неделимым). Это основа для конкурентных возможностей.

Concurrent features (React 18) — рендер можно прерывать ради более приоритетных обновлений (ввод пользователя), не блокируя UI:

  • useTransition — пометить обновление как несрочное (можно прервать), чтобы срочные (набор текста) шли плавно:
const [isPending, startTransition] = useTransition();
startTransition(() => setSearchQuery(value)); // тяжёлый ре-рендер не блокирует ввод
  • useDeferredValue — отложенное значение для несрочного рендера.
  • Автоматический батчинг — в React 18 несколько setState батчатся даже в промисах/таймерах (не только в обработчиках событий).

Suspense — декларативное ожидание: показывает fallback, пока «загружается» дочерний компонент (ленивый компонент через React.lazy, данные во фреймворках с поддержкой):

const Heavy = React.lazy(() => import("./Heavy"));

<Suspense fallback={<Spinner />}>
  <Heavy />
</Suspense>;

Code splitting — React.lazy + Suspense грузят компонент по требованию (меньше начальный бандл).


Portals

Portal — способ отрендерить дочерние элементы в другой DOM-узел, вне родителя по дереву DOM, но при этом сохранив позицию в дереве React (контекст, события всплывают по React-дереву, а не по DOM). Нужен для модалок, тултипов, попапов, дропдаунов — чтобы они не обрезались overflow: hidden родителя и не ломались z-index.

import { createPortal } from "react-dom";

function Modal({ children, onClose }) {
  return createPortal(
    <div className="overlay" onClick={onClose}>
      <div className="modal" onClick={(e) => e.stopPropagation()}>
        {children}
      </div>
    </div>,
    document.body    // куда рендерить в реальном DOM (обычно body или #modal-root)
  );
}

Важно: события внутри портала всплывают по дереву React (к родителю-компоненту), а не по DOM — поэтому обработчики родителя срабатывают, хотя визуально портал в body. Это частый вопрос на собеседовании.


Refs: forwardRef и useImperativeHandle

По умолчанию ref нельзя передать в функциональный компонент как обычный проп. forwardRef позволяет «пробросить» ref внутрь компонента к реальному DOM-элементу:

const Input = forwardRef(function Input(props, ref) {
  return <input ref={ref} {...props} />;
});

// родитель получает доступ к DOM input
const inputRef = useRef(null);
<Input ref={inputRef} />;
inputRef.current.focus();

useImperativeHandle — настроить, что именно родитель увидит через ref (вместо всего DOM-узла — свой «императивный API» компонента):

const Video = forwardRef(function Video(props, ref) {
  const videoRef = useRef(null);
  useImperativeHandle(ref, () => ({
    play:  () => videoRef.current.play(),
    pause: () => videoRef.current.pause(),
  }));
  return <video ref={videoRef} src={props.src} />;
});

// родитель: videoRef.current.play(); — только разрешённые методы

Когда использовать: редко, для императивных действий (фокус, проигрывание, прокрутка), которые сложно выразить декларативно через props. Обычно предпочитают props/state; императивный доступ — исключение. (В React 19 ref можно принимать как обычный проп без forwardRef.)


StrictMode

<StrictMode> — обёртка (только для разработки, в проде ничего не делает), которая помогает найти проблемы:

<StrictMode>
  <App />
</StrictMode>

Что делает в dev-режиме:

  • Двойной вызов функций рендера, useState-инициализаторов, редьюсеров и эффектов (useEffect: mount → unmount → mount) — чтобы выявить побочные эффекты без cleanup и небезопасный/нечистый код. Отсюда «почему useEffect срабатывает дважды».
  • Предупреждает об устаревших/небезопасных API.

Двойной вызов — не баг, а специально: если компонент/эффект написан правильно (чистый рендер + cleanup в эффектах), двойной вызов ничего не ломает. В проде вызовы одинарные.


HOC и render props

Старые (до хуков) способы переиспользования логики — их спрашивают «в чём отличие от хуков»:

  • HOC (Higher-Order Component) — функция, принимающая компонент и возвращающая новый, обёрнутый (добавляет пропсы/логику): withAuth(Component), connect(...)(Component) в Redux.
function withLoading(Component) {
  return function (props) {
    if (props.isLoading) return <Spinner />;
    return <Component {...props} />;
  };
}
  • Render props — компонент принимает функцию-проп (обычно children или render), которой отдаёт данные:
<DataFetcher url="/api">
  {(data) => <List items={data} />}
</DataFetcher>

Проблемы обоих: «wrapper hell» (много вложенных обёрток), неявные пропсы, сложнее типизировать. Кастомные хуки заменили их — та же переиспользуемая логика, но без обёрток и с прозрачными зависимостями. HOC ещё встречается в библиотеках (connect, memo — тоже по сути HOC).


Новое в React 19

Ключевые нововведения (полезно упомянуть на собеседовании):

  • Actions — встроенная поддержка асинхронных переходов с состояниями pending/error и оптимистичными обновлениями (упрощают формы и мутации).
  • useActionState — управление состоянием формы/экшена (данные, ошибка, isPending) в одном хуке.
  • useFormStatus — статус родительской <form> (например, pending) в дочерних компонентах (кнопка сама знает, что форма отправляется).
  • useOptimistic — оптимистичное обновление UI до ответа сервера (мгновенный отклик, откат при ошибке).
  • use() — «читать» промис или контекст прямо в рендере (можно условно, в отличие от хуков), интегрируется с Suspense.
  • ref как обычный проп — forwardRef больше не обязателен; ref можно передавать напрямую в функциональный компонент.
  • Метаданные документа (<title>, <meta>) можно рендерить прямо в компонентах; улучшения гидрации и Server Components/Server Actions.

Общая тема React 19 — упростить работу с асинхронностью, формами и данными (то, что раньше делали вручную или библиотеками).


Server Components и Next.js

React Server Components (RSC) — компоненты, которые выполняются на сервере и не отправляют свой JS в браузер (уменьшают бандл, могут напрямую ходить в БД/файлы). Клиентские компоненты помечаются директивой "use client". Активно используются в Next.js App Router.

Рендеринг (в основном в контексте Next.js):

  • CSR — обычное SPA, HTML собирается в браузере (хуже SEO, дольше первый показ).
  • SSR — сервер рендерит HTML на запрос, затем гидрация (React «оживляет» разметку на клиенте). Лучше SEO/TTFB.
  • SSG — страницы генерируются заранее в статический HTML.
  • ISR — инкрементальная регенерация статики.

Next.js — самый популярный метафреймворк над React: файловый роутинг, SSR/SSG/ISR/RSC, серверные экшены, оптимизации (изображения, бандл). На собеседовании ждут понимания CSR/SSR/SSG/гидрации и зачем RSC.


Роутинг

React сам роутинг не включает. Стандарт — React Router.

import { BrowserRouter, Routes, Route, Link, useParams, useNavigate } from "react-router-dom";

<BrowserRouter>
  <Routes>
    <Route path="/" element={<Home />} />
    <Route path="/users/:id" element={<User />} />
    <Route path="/admin" element={<Admin />}>
      <Route path="stats" element={<Stats />} />   {/* вложенный */}
    </Route>
  </Routes>
</BrowserRouter>;

// В компоненте
const { id } = useParams();
const navigate = useNavigate();
navigate("/users/1");

Ключевое: динамические (:id) и вложенные маршруты, Link/NavLink, программная навигация (useNavigate), ленивая загрузка маршрутов через React.lazy, лоадеры данных (в data-режиме роутера). В Next.js — свой файловый роутинг.


Тестирование

  • Jest / Vitest — тест-раннеры.
  • React Testing Library (RTL) — тестирование компонентов «как пользователь»: ищем элементы по тексту/роли, а не по деталям реализации.
import { render, screen, fireEvent } from "@testing-library/react";

test("увеличивает счётчик", () => {
  render(<Counter />);
  fireEvent.click(screen.getByRole("button"));
  expect(screen.getByText(/1/)).toBeInTheDocument();
});

Философия RTL: тестировать поведение, а не внутренности (не проверять state напрямую). E2E — Playwright/Cypress.


Отличия от Vue

Аспект React Vue
Тип библиотека (view) прогрессивный фреймворк
Шаблоны JSX (JS + разметка) HTML-шаблоны (+ опц. JSX)
Реактивность ручная (useState, иммутабельность, ре-рендер функции целиком) автоматическая (Proxy, точечное отслеживание)
Обновление перерисовка функции компонента + diff VDOM пересчёт только зависимых + компиляторные оптимизации
Оптимизация ручная (memo, useMemo, useCallback) во многом автоматически
Состояние Redux/Zustand/Context Pinia
Экосистема сообщество (роутер/стор отдельно) официальная (Router, Pinia, Nuxt)
Мутабельность иммутабельный state можно мутировать reactive напрямую

Кратко: React — гибкость и явность (всё через JS, оптимизации вручную), Vue — больше «из коробки» и автоматическая реактивность.


Вероятные вопросы

React — это фреймворк или библиотека? Библиотека для UI; роутинг/состояние/данные подключают отдельно.

Что такое JSX и во что компилируется? Синтаксис «HTML в JS»; компилируется в React.createElement/jsx(), возвращающие объекты-элементы.

Что такое Virtual DOM и reconciliation? VDOM — представление UI в виде объектов JS. При изменении строится новое дерево, сравнивается со старым (reconciliation/diffing за O(n)), в реальный DOM применяются только отличия.

Когда компонент ре-рендерится? При изменении своего state, изменении props, ре-рендере родителя, изменении читаемого контекста. Ре-рендер ≠ обновление DOM.

Почему state иммутабелен и обновляется через сеттер? React сравнивает ссылки для решения о ре-рендере; прямая мутация не триггерит обновление. Новый объект/массив через spread + функциональный сеттер при зависимости от прошлого значения.

Почему setState «асинхронный»? React батчит обновления в одном цикле для производительности; используйте setX(prev => ...).

Что делает useEffect и его массив зависимостей? Побочные эффекты после рендера; [] — один раз при монтировании, [deps] — при изменении, без массива — каждый рендер. Cleanup чистит подписки/таймеры.

useEffect vs useLayoutEffect? useEffect — после коммита, обычно асинхронно после отрисовки (после дискретного ввода может выполниться до paint); useLayoutEffect — синхронно после мутаций DOM до отрисовки (для измерений/предотвращения мигания).

Зачем useRef? Мутируемое значение, переживающее рендеры и не вызывающее ре-рендер: доступ к DOM, таймеры, предыдущие значения.

useMemo vs useCallback? useMemo кэширует значение, useCallback — функцию (ссылку). Нужны для стабильных пропсов у React.memo-детей и зависимостей эффектов. Не злоупотреблять.

Что делает React.memo? Пропускает ре-рендер, если props не изменились (shallow compare). Работает в связке со стабильными пропсами (useCallback/useMemo).

useState vs useReducer? useReducer — для сложной логики состояния/переходов, тестируемый чистый редьюсер, dispatch(action). useState — для простого локального состояния.

Правила хуков? Только на верхнем уровне (не в условиях/циклах) и только из React-функций — React опирается на порядок вызова хуков.

Зачем нужен key и почему не индекс? Для сопоставления элементов при обновлении списка. Индекс ломается при вставке/удалении/сортировке → баги состояния; нужен стабильный id.

Как избежать лишних ре-рендеров? React.memo + стабильные пропсы, useMemo/useCallback, локализация состояния, композиция через children, виртуализация списков, профилирование в DevTools.

Что такое кастомный хук? Функция useXxx с переиспользуемой логикой на хуках; у каждого использования своё изолированное состояние. Замена HOC/render-props.

Как передать данные вглубь без prop drilling? Context (createContext + useContext); для часто меняющегося глобального состояния — стор.

Как работать с серверными данными? Отделять server state (React Query/SWR/RTK Query — кэш, инвалидация, статусы) от клиентского; ручной useEffect не решает кэш/гонки.

Controlled vs uncontrolled компоненты? Controlled — значение в state (React управляет); uncontrolled — значение в DOM, читается через ref. Для больших форм — React Hook Form.

Что такое Error Boundary? Классовый компонент, ловящий ошибки рендера в поддереве и показывающий fallback. Не ловит ошибки в обработчиках/async.

Что такое Fiber и concurrent-возможности? Fiber — прерываемая архитектура рендера. Concurrent (React 18): useTransition/useDeferredValue для несрочных обновлений, автоматический батчинг, Suspense.

Что такое Suspense и code splitting? Suspense показывает fallback во время загрузки; React.lazy + Suspense грузят компонент по требованию, уменьшая бандл.

Что такое Server Components и гидрация? RSC выполняются на сервере, не шлют свой JS в браузер. Гидрация — «оживление» серверного HTML на клиенте (SSR). Метафреймворк — Next.js.

Чем React отличается от Vue? React — библиотека, JSX, ручная реактивность и оптимизация; Vue — фреймворк, HTML-шаблоны, автоматическая реактивность (Proxy) и компиляторные оптимизации.

Что такое Portal и зачем? Рендер детей в другой DOM-узел (обычно body) через createPortal, сохраняя позицию в дереве React. Для модалок/тултипов (обойти overflow/z-index). События всплывают по React-дереву, не по DOM.

Зачем forwardRef и useImperativeHandle? forwardRef пробрасывает ref внутрь компонента к DOM; useImperativeHandle задаёт, какой API родитель увидит через ref (например, play/pause). В React 19 ref — обычный проп, forwardRef не нужен.

Почему useEffect срабатывает дважды? Это StrictMode в dev: специально монтирует→размонтирует→монтирует, чтобы выявить эффекты без cleanup. В проде — один раз. Правильный эффект с cleanup от этого не ломается.

HOC/render props vs хуки? HOC — функция, оборачивающая компонент; render props — функция-проп с данными. Оба ведут к «wrapper hell» и неявным пропсам. Кастомные хуки заменили их — та же логика без обёрток.

Что нового в React 19? Actions и useActionState/useFormStatus (формы/мутации с pending/error), useOptimistic (оптимистичный UI), use() (чтение промиса/контекста в рендере), ref как обычный проп, метаданные документа в компонентах.