ТОП 10 вопросов на собеседовании ReactJS

2 года назад·6 мин. на чтение

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

Вопросы на собеседовании на позицию Фронтенд разработчика могут быть самые разные. Обычно интервьюер имеет утвержденный список вопросов, стандартный для собеседований в конкретную компанию. Но может задать и дополнительные вопросы. Это могут быть вопросы, связанные с его крайней задачей, или ему захотелось узнать ваше мнение. Или это может быть стандартный вопрос, чтобы узнать действительно ли вы знаете React? и примерно определить на каком уровне. Могут быть вопросы о third-party библиотеках - redux, mobx, saga, thunk. Может быть что-то и про JavaScript. Очевидно, что интервью для junior/midddle/senior будут различаться. Практически любой вопрос можно задать кандидату любого уровня, а вот ответ может отличаться по глубине, по деталям, более опытный может привести примеры corner case’ов и т.д. React развивается. Сейчас вряд ли будут спрашивать много про классовые компоненты. Если только это не легаси проект. Либо могут быть специфичные вопросы, которые только немного касаются темы классовых компонентов.

Что вызывает обновление компонента?

Обновление компонента вызывают изменение состояния и изменение пропсов. В классовых компонентах еще есть forceUpdate (следует использовать только в крайних случаях). Изменение состояния не будет приводить к обновлениям, если новое значение состояния не изменилось. Если мутировать состояние напрямую это тоже не приведет к повторному рендеру В функциональных компонентах встроенного аналога функции forceUpdate нет. Но можно написать свой.
const [ignored, forceUpdate] = useReducer(x => x + 1, 0);

function handleClick() {
  forceUpdate();
}
Когда родительский компонент рендерится, дочерние компоненты рекурсивно тоже будут ререндериться. Скорее всего некоторые компоненты в этой цепочке вернут тот же самый результат, т.е. не изменятся. Поэтому они не будут перерисованы в DOM. Но React все равно должен сделать рендер, чтобы определить эти различия, сравнить и определить нужна перерисовка или нет.

Virtual DOM

Виртуальный DOM (VDOM) — это подход для при котором "виртуальное" представление пользовательского интерфейса хранится в памяти. И этот виртуальный DOM синхронизируется с "настоящим" DOM. В React для этого используется библиотеки (react-dom). Сам этот процесс называется согласованием (reconciliation). Также React использует внутренние объекты, называемые "волокнами" (fibers), чтобы хранить дополнительную информацию о дереве компонентов. Их также можно считать частью реализации "виртуального DOM" в React. Fiber - это JS объект который содержит информацию о компоненте его входные параметры и результат.

setState синхронный или асинхронный?

setState - асинхронный. setState говорит React запустить следующую итерацию рендера. Однако React также может оптимизировать это процесс и несколько вызовов setState - приведут к одному рендеру.

Что такое JSX

JSX - это дополнение к синтаксису JS, который позволяет писать HTML в React компонентах. JSX — синтаксический сахар для функции React.createElement(component, props, ...children). Этот JSX-код:
return <Component />
…конвертируется в:
return React.createElement(SomeComponent, {a: 42, b: "testing"}, "Text Here")
…и результатом будет объект:
{
  type: SomeComponent,
  props: {a: 42, b: "testing"},
  children: ["Text Here"]
}
За правильный парсинг и дальнейшую обработку отвечает babel. Если название типа элемента начинается с маленькой буквы, он ссылается на встроенный компонент, например, <div> или <span>, что в результате приведет к тому, что в React.createElement будет передана строка 'div' или 'span'. Типы, начинающиеся с заглавной буквы, такие как <SomeComponent />, компилируются в React.createElement(SomeComponent) и соответствуют компоненту, который был объявлен или импортирован в JavaScript-файле. React можно использовать без JSX. Это особенно удобно, когда нет необходимости настраивать транспиляцию в процессе сборки.

В чем разница memo и useMemo?

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

Pure Components (Чистые компоненты)

Компонент является чистым, если он гарантированно возвращает один и тот же результат при одинаковых пропсах и состоянии. Для чего нужны чистые компоненты и чем они лучше? Чистые компоненты имеют улучшенную производительность за счет поверхностного сравнения пропсов и состояния.

Для классовых компонентов

shouldComponentUpdate - необязательный метод жизненного цикла. Если этот метод возвращает false, React пропустит рендеринг компонента. Он может содержать любую логику сравнения пропосв и состояния с их предыдущими значениями. React.PureComponent может быть использован вместо Component + shouldComponentUpdate.

Для функциональных и для классовых компонентов

React.memo() - компонент высшего порядка. В качестве первого аргумента получает компонент и возвращает новый компонент. По умолчанию сравнение происходит поверхностное. Однако, вторым аргументом можно передать свой кастомный компаратор - функцию сравнения (arePropsEqual()) Поверхностное сравнение происходит при помощи оператора ===.

Вопросы о стэйт менеджерах

Отличия mobx и react

  • Redux использует JS-объект в качестве структуры данных для хранения данных состояния. И отслеживание изменений происходит явно вручную. MobX использует observables, и чтобы следить за изменениями используются неявные подписки.
  • Redux использует чистые функции - очевидные изменения состояния. В MobX сложнее отследить изменения и сложнее дебажить.
  • В Mobx меньше бойлерплейт кода.
  • В Mobx может быть больше одного стора, в Redux один большой стор.
  • и т.д.

Особенности использования Context API + useReducer вместо Redux

Безусловно, useReducer() позволяет обрабатывать обновления состояния с помощью редьюсеров без необходимости использования хранилища Redux, а useContext() позволяет передавать значения через дерево React без необходимости передавать их вниз через каждый уровень компонентов в качестве пропсов. Однако, как и в случае с самим Context API, хук useReducer() не имеет дополнительных возможностей, которые предоставляет Redux. Нет ни отладки с перемещением во времени, ни middleware, ни специальных DevTools Extension, позволяющего увидеть, как состояние менялось с течением времени.

Что такое Компонент высшего порядка (Higher-Order Component, HOC)?

Функция, которая получает компонент в качестве аргумента и возвращают модифицированный компонент - называется компонентом высшего порядка. Она применяется для повторного использования логики (помогает следовать принципу DRY). Хорошо подходит для инжектирования зависимостей. HOC - работает как фабрика компонентов. HOC может принимать конфигурации в качестве аргументов и возвращать компонент или семейство компонентов. Через HOC можно скрыть источник данных для компонентов, которые выглядят одинаково, однако обращаются к разным источникам данных.

Когда бы вы использовали классовый компонент вместо функционального?

Можно сформулировать этот вопрос иначе: "Что можно сделать с помощью хуков, а что нельзя?" Основные методы жизненного цикла можно имплементировать при помощи хуков. Однако пока есть функциональность, которую можно имплементировать только с помощью классовых компонентов, в будущем конечно это может измениться. Но пока не существует хуков, реализующих методы жизненного цикла getSnapshotBeforeUpdate, getDerivedStateFromError и componentDidCatch. В документации сказано, что разработчики планируют их добавить. getSnapshotBeforeUpdate вызывается прямо перед добавлением в DOM. На этом этапе некоторая информация из DOM уже доступна (например, положение прокрутки) getDerivedStateFromError вызывается после возникновения ошибки у компонента-потомка. Он получает ошибку в качестве параметра и возвращает значение для обновления состояния. Вызывается во время этапа рендера, поэтому здесь запрещены любые побочные эффекты. Можно использовать для рендеринга запасного UI в случае отлова ошибки. componentDidCatch вызывается после возникновения ошибки у компонента-потомка. Вызывается во время этапа фиксации, поэтому здесь можно использовать побочные эффекты. Можно использовать для логирования информации об отловленной ошибке.

Lazy loading, code splitting

Lazy loading - ленивая загрузка, для того чтобы загружать очередной бандл по требованию. Эта оптимизация полезна т.к. не все части приложения могут пригодится сразу же. Таким образом мы можем ускорить загрузку сайта за счет меньшего размера бандла. Бандлы - это результат работы работы сборщиков проекта (Webpack, Rollup). Сама сборка - это процесс выявления импортированных файлов и объединения их в один файл (часто называемый "bundle" или "бандл"). Этот бандл после подключения на веб-страницу загружает приложение. Однако нужно следить за размером бандла - любая подключенная библиотека добавляет лишний килобайты. И загрузка может занять слишком много времени. При помощи сборщиков проекта можно создавать несколько бандлов и загружать их по мере необходимости. Общий размер кода не уменьшится (он будет разделен на несколько частей) - однако начальная загрузка будет быстрее.
  • React.lazy
const OtherComponent = React.lazy(() => import('./OtherComponent'))
Она автоматически загрузит бандл, содержащий OtherComponent, когда этот компонент будет впервые отрендерен. React.lazy принимает функцию, которая должна вызвать динамический import(). Результатом возвращённого Promise является модуль, который экспортирует по умолчанию React-компонент (export default).
  • Suspense
Компонент с ленивой загрузкой должен рендериться внутри компонента Suspense, который позволяет нам показать запасное содержимое (например, индикатор загрузки) пока происходит загрузка ленивого компонента.
  • Предохранители (error boundary)
Если какой-то модуль не загружается (например, из-за сбоя сети), это вызовет ошибку. Можно обрабатывать эти ошибки для улучшения пользовательского опыта с помощью предохранителей.

Как работает браузер?

Это один из самых популярных вопросов на собседовании на роль middle/senior разработчика. Обо всех шагах, которые совершает браузер при переходе на страницу вы можете найти в этом посте. Также по теме собеседований рекомендую прочитать:

Собеседование ReactJS - вопросы и ответы

2 года назад·6 мин. на чтение

В‌ ‌этой ‌статье рассмотрим 10 вопросов, которые могут встретиться на собеседовании по ReactJS на позицию React или frontend разработчика.

Подписывайтесь на наш Boosty и задавайте ваши вопросы через форму. Я запишу видео-ответы или статьи, где вы сможете получить быстрый ответ на интересующие именно вас вопросы. Если вы начинающий фронтенд-разработчик, это лучшая возможность получить ответ на вопрос, который вы стеснялись задать коллегам. А еще на Boosty вас уже ожидают эксклюзивные статьи и видео на актуальные темы. Итак, теперь рассмотрим вопросы с собеседований:

Управляемые и неуправляемые компоненты

Элемент называется управляемым, если его значение контролирует React. Эта тема связана с такими HTML элементами как input, textarea, select. Обычно эти элементы сами управляют своим состоянием и сами обновляются когда пользователь вводит данные. Это неуправляемые компоненты - они хранят свои данные прямо в DOM. Чтобы прочитать их значения, используются рефы. Для того чтобы сделать управляемый компонент, нужно чтобы значение этих элементов хранилось именно в состоянии React компонента, т.е. управлялось через setState/useState, таким образом состояние React-компонента становится единственным источником правды для этих элементов.
// Управляемый компонент
import React, { useState } from 'react'

export function ControlledInput() {
  const [name, setName] = useState('')

  function handleNameChange(event) {
    setName(event.target.value)
  }

  function handleSubmit(event) {
    event.preventDefault()
    console.log(name)
  }

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Name:
        <input type="text" value={name} onChange={handleNameChange} />
      </label>
      <button type="submit">Submit</button>
    </form>
  )
}
// Неуправляемый компонент
import React, { useRef } from 'react'

export function UncontrolledInput() {
  const nameInput = useRef()

  function handleSubmit(event) {
    event.preventDefault()
    console.log(nameInput.current.value)
  }

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Name:
        <input type="text" ref={nameInput} defaultValue="" />
      </label>
      <button type="submit">Submit</button>
    </form>
  )
}
Исходный код

Что такое контекст в React (React Context)?

Контекст позволяет передавать данные через дерево компонентов без необходимости передавать пропсы на промежуточных уровнях. Обычно данные в React-приложении передаются от родителя к дочернему компоненту через пропсы (Как передавать данные между компонентами в ReactJS). Но когда компонентов много или множество компонентов должны быть изменяемы в зависимости от темы - то передавать пропсы для такого случая очень сложно. Для решения этой проблемы можно использовать контекст. Контекст предоставляет способ делиться такими данными между компонентами без необходимости явно передавать пропсы через каждый уровень дерева компонентов. Создаем контекст.
// context.js
import { createContext } from 'react'

export const Context = createContext()
Оборачиваем пользователей этого контекста в тег <Context.Provider /> и передаем внего значения через проп value.
// Component.js
import { useState } from 'react'
import { Context } from './context'

import Parent from './Parent'

export const Component = () => {
  const [name, setName] = useState()

  return (
    <Context.Provider value={{ name, setName }}>
      <Parent />
    </Context.Provider>
  )
}
В компоненте Parent вызываем функцию setName из контекста.
// Parent.js
import { useContext } from 'react'

import { Context } from './context'
import Child from './Child'

export const Parent = () => {
  const { setName } = useContext(Context)

  const handleNameChange = (event) => {
    setName(event.target.value)
  }

  return (
    <>
      <input
        type="text"
        onChange={handleNameChange}
      />

      <Child />
    </>
  )
}
В компоненте Child читаем из контекста значение name.
// Child.js
import { useContext } from 'react'
import { Context } from './context'

export const Child = () => {
  const { name } = useContext(Context)

  return (
    <span>Name is: {name || '<Not set>'}</span>
  )
}

Что такое порталы в React?

Порталы позволяют рендерить дочерние элементы в DOM-узел, который находится вне DOM-иерархии родительского компонента. Порталы особенно спасают когда в родительском компоненте заданы стили overflow: hidden или z-index, и нужно, чтобы дочерний элемент визуально выходил за рамки своего контейнера. Это диалоги, модальные окна или всплывающие подсказки.

Что такое refs в React и в чем их важность?

Рефы дают возможность получить доступ к DOM-узлам или React-компонентам. Ситуации, в которых использование рефов является оправданным:
  • Управление фокусом, выделение текста или воспроизведение медиа;
  • Императивный вызов анимаций;
  • Интеграция со сторонними DOM-библиотекам;
  • и др.
В рефах можно хранить любое значение, не обязательно ссылку на элемент. Изменение поля current не приводит к реренденру компонента.
import React, { useRef } from 'react'

export function UncontrolledInput() {
  const nameInput = useRef()

  function handleSubmit(event) {
    event.preventDefault()
    console.log(nameInput.current.value)
  }

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" ref={nameInput} defaultValue="" />
      <button type="submit">Submit</button>
    </form>
  )
}

Что такое key в React и в чем их важность?

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

Render props

Render prop относится к возможность разделять код между компонентами с помощью пропа, значение которого является функцией. Render prop — функция, которая сообщает компоненту, что необходимо рендерить.
// Example.jsx
import React, { useState } from "react";
import Button from "react-bootstrap/Button";

import { CartIcon } from "./CartIcon/CartIcon";

const renderBadge = (count) => {
  return (
      <div>{count}</div>
  );
};

export const Example = () => {
  const [cart, setCart] = useState([]);

  const handleClick = () => {
    console.log("Cart Item clicked");
  };

  return (
    <CartIcon
      renderBadge={() => renderBadge(cart.length)}
      onClick={handleClick}
    />
  );
};
// CartIcon.jsx
import React from "react";
import { MdShoppingCart } from "react-icons/md";

export const CartIcon = ({ renderBadge = () => null, onClick }) => {
  return (
    <div onClick={onClick}>
      <div>{renderBadge()}</div>
      <MdShoppingCart />
    </div>
  );
};
Исходный код

Что такое Redux?

Redux - это стэйт менеджер для JS приложений. Он может работать не только в React приложениях. Он хранит состояние в дереве объектов внутри единого стора. Единственная возможность изменить состояние - отправить action. Action - это объект, который описывает действие (он отвечает на вопрос: "Что я хочу изменить в состоянии?"). Далее action попадает в reducer, где описано, как состояние должно быть изменено. (reducer отвечает на вопрос: "Как я хочу изменить стэйт?").

Как реализовать сайд эффекты в Redux

Сайд эффект - это действие, которые должно произойти на диспатчинг экшена, помимо после сохранения в стор, например, логирование в консоль или отправка запроса на сервер. Основной способ сделать сайд эффект - вызвать его в middleware. Можно написать свой middleware, а можно использовать сторонние библиотеки, например, redux thunk - для синхронных и простых асинхронных действий или redux saga - для сложных асинхронных действий. Можно вызывать сайд эффекты в action сreator'ах. Однако, это не самый лучший способ, т.к. можно задиспатчить действие и без вызова action creator, тогда сайд эффект не сработает.

React - реактивен?

Начнем с того, что React-компоненты это функции, которые мы не вызываем на прямую. Эти функции в некоторые моменты возвращают описание того что нужно рендерить. Эти функции вызывает сам React в те самые "некоторые" моменты. И React может отложить этот вызов. React рекурсивно обходит дерево компонентов и может применять оптимизации - и задерживать рендеры чтобы избежать потерю кадров. React в первую это UI фреймворк, и для того чтобы избежать тормозов такие меры оправданы. Т.к. данные могут поступать быстрее чем скорость обновления кадров - есть смысл объединять обновления в пакеты и обновлять пакетами. Поэтому React это скорее «Планировщик», и реактивность не провалятся в React в чистом виде.

Что такое синтетические события в React?

SyntheticEvent это обёртка над нативными событиями. SyntheticEvent является частью системы событий React. Ваши обработчики событий получают экземпляр SyntheticEvent, это кроссбраузерная обёртка над нативным экземпляром события. У неё такой же интерфейс, как и у нативного события, включая методы stopPropagation() и preventDefault(). Эта обёртка помогает событиям работать одинаково во всех браузерах. Еcли всё-таки нужно получить нативное браузерное событие, следует обратиться к атрибуту nativeEvent. Синтетические события отличаются от нативных событий браузера и непосредственно не связаны с ними.

Как работает браузер?

Обо всех шагах, которые совершает браузер при переходе на страницу вы можете найти в этом посте.

Задачи на написание кода

Подробный разбор одной из задач с реального собеседования вы можете найти на Boosty. Там вы можете найти как неоптимальный вариант решения, так и оптимальный. С описанием сложности каждого варианта решения в нотации Big "O" notaion. Также по теме собеседований рекомендую прочитать: