React
Материал для подготовки к собеседованию (Middle / Senior). Ориентир — современный React (функциональные компоненты и хуки, React 18/19). Термины на английском там, где это принято.
Содержание
- Что такое React
- JSX
- Компоненты и props
- Virtual DOM и reconciliation
- key в списках
- useState
- Рендеринг: когда и почему компонент перерисовывается
- useEffect
- useRef
- useMemo и useCallback
- useContext
- useReducer
- Правила хуков
- Кастомные хуки
- React.memo и оптимизация ре-рендеров
- Управление состоянием
- Работа с данными и server state
- Формы
- Error Boundaries
- Fiber, Concurrent, Suspense
- Portals
- Refs: forwardRef и useImperativeHandle
- StrictMode
- HOC и render props
- Новое в React 19
- Server Components и Next.js
- Роутинг
- Тестирование
- Отличия от Vue
- Вероятные вопросы
Что такое 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 в памяти.
Как это работает:
- Компонент рендерится → создаётся дерево элементов (VDOM).
- При изменении состояния/props создаётся новое дерево.
- React сравнивает новое дерево со старым — reconciliation (алгоритм согласования) с эвристикой diffing за O(n).
- Вычисляется минимальный набор изменений и применяется к реальному 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-функция стабильна — её ссылка не меняется между рендерами (можно не добавлять в зависимости).
Рендеринг: когда и почему компонент перерисовывается
Ключевая тема на собеседовании. Компонент ре-рендерится (вызывается его функция заново), когда:
- Изменилось его состояние (
useState/useReducer). - Изменились его props (потому что перерендерился родитель).
- Перерендерился родитель — по умолчанию React рендерит всё поддерево вниз, даже если props ребёнка не изменились.
- Изменилось значение 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):
- Вызывать хуки только на верхнем уровне компонента/кастомного хука — не внутри условий, циклов, вложенных функций. React опирается на порядок вызова хуков между рендерами (внутренне они хранятся списком по индексу); условный вызов ломает соответствие.
- Вызывать хуки только из 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 как обычный проп, метаданные документа в компонентах.