Gernar
Frontend DeveloperHTTP, API и сеть

Интервью-вопрос

Что такое CRUD

CRUD это четыре базовые операции над данными: создать, прочитать, обновить и удалить. Для фронтенда важно не только назвать операции, но и объяснить, как они превращаются в формы, списки, запросы, состояния загрузки и обработку ошибок.

Добавлен
Редакция

Подготовьте короткий ответ и пару деталей на случай уточняющих вопросов.

🐰0
🥚0

Мини-квиз

Проверка перед разбором

Несколько быстрых вопросов перед разбором. Так проще поймать места, которые только кажутся понятными.

Вопрос 1 из 50 правильно

Как лучше объяснить CRUD на интервью?

Вы хотите дать короткий и точный ответ без лишней теории.

Варианты ответа

Разбор

Разобраться, а не зазубрить

Дальше разбираем суть, типичные уточнения и места, где легко сказать лишнее или перепутать термины.

Базовая идея

CRUD это короткое название для четырех действий с данными:

  • Create: создать новую сущность.
  • Read: прочитать одну сущность или список.
  • Update: изменить существующую сущность.
  • Delete: удалить сущность.

На интервью не останавливайтесь только на расшифровке. Сразу добавьте практический контекст. Почти любой экран с данными использует CRUD. Форма создания профиля, таблица пользователей, редактирование задачи, удаление комментария, сохранение черновика в IndexedDB. Все это варианты одной идеи.

Как связать CRUD с REST API

В REST API CRUD часто объясняют через HTTP-методы:

POST   /tasks        # Create, создать задачу
GET    /tasks        # Read, получить список
GET    /tasks/42     # Read, получить одну задачу
PATCH  /tasks/42     # Update, изменить часть задачи
DELETE /tasks/42     # Delete, удалить задачу

Это хорошая базовая схема для ответа. Но важно сказать, что реальный проект живет по контракту API. Иногда создание выглядит не как простой POST /items, а как команда вроде POST /orders/42/cancel. Иногда сервер использует GraphQL mutation, RPC-метод или WebSocket-событие. Смысл CRUD остается, меняется транспорт и форма контракта.

Как узнать CRUD-операцию по задаче в интерфейсе

1Вы создаете новую сущность из формы?
Create. Отправьте данные, дождитесь ответа, сохраните серверный id и покажите состояние успеха или ошибки.
2Вы показываете список или карточку?
Read. Учтите загрузку, пустое состояние, ошибку, кэш и обновление устаревших данных.
3Вы меняете часть существующей сущности?
Update. Проверьте контракт PUT/PATCH, не затирайте поля и обработайте конфликт версий, если API его возвращает.
4Вы удаляете сущность или связь?
Delete. Подтвердите опасное действие, заблокируйте повторный клик и продумайте откат UI при ошибке.

Что важно для фронтенда

Для Frontend Developer сильный ответ начинается там, где вы связываете CRUD с состоянием интерфейса. Недостаточно сказать "я вызову API". Пользователь видит не API, а экран. Кнопка должна блокироваться во время отправки, список должен обновиться, ошибка должна быть понятной и доступной, а удаление не должно превращаться в потерю данных.

Плохой пример. Так делать не стоит:

async function deleteTask(id: string) {
  setTasks((items) => items.filter((task) => task.id !== id));
  await api.deleteTask(id);
}

Проблема в том, что элемент пропадает до подтверждения сервера. Если запрос упадет, UI уже показывает неверное состояние. Если пользователь быстро удалит несколько задач, простой откат всего списка может вернуть не те элементы и перетереть более свежие изменения. Самый безопасный вариант для критичного Delete: менять список только после успешного ответа. Если нужен optimistic UI, добавьте точечный rollback.

async function deleteTask(task: Task) {
  setPendingDeleteIds((ids) => new Set(ids).add(task.id));

  try {
    await api.deleteTask(task.id);
    setTasks((items) => items.filter((item) => item.id !== task.id));
  } catch (error) {
    showError("Не удалось удалить задачу. Попробуйте еще раз.");
    focusTask(task.id);
  } finally {
    setPendingDeleteIds((ids) => {
      const nextIds = new Set(ids);
      nextIds.delete(task.id);
      return nextIds;
    });
  }
}

В кнопке удаления при этом стоит использовать pending-состояние. Отключите повторный клик, покажите загрузку и свяжите текст ошибки с местом, куда вернется фокус. Такой пример показывает практическое понимание. CRUD-операция заканчивается не в момент клика, а когда интерфейс и источник данных снова согласованы.

Что может сломаться в CRUD на фронтенде

CreatePOST

Риск двойной отправки формы и лишнего запроса. Блокируйте кнопку, используйте pending-состояние и не считайте успехом сам факт клика.

ReadGET

Риск показать устаревшие данные или результат старого запроса. Нужны loading, error, empty state, отмена неактуальных запросов и стратегия обновления кэша.

UpdatePUT/PATCH

Риск потерять поля или перезаписать чужие изменения. Сверяйтесь с контрактом и обрабатывайте конфликт состояния.

DeleteDELETE

Риск удалить в UI то, что не удалилось на сервере. Для optimistic UI нужен rollback и понятное сообщение об ошибке.

Update: главная ловушка

Самая частая ловушка в CRUD-вопросе это Update. Вы говорите, что Update это PUT или PATCH, но не объясняете разницу. Лучше ответить так: PUT часто используют для полной замены ресурса, а PATCH для частичного изменения. Но финальное правило задает API-контракт.

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

На практике перед Update проверьте три вещи: какие поля нужно отправить, что сервер вернет в ответе и как обновить локальный кэш. Если есть версия записи, etag или поле updatedAt, учитывайте конфликт изменений, чтобы не перезаписать чужую правку старой копией.

Локальный CRUD без бэкенда

CRUD можно реализовать и без сервера. Например, для списка задач в состоянии React, localStorage или IndexedDB. Это нормально для учебного проекта, демо, черновиков или офлайн-режима.

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

Безопасный порядок действий

Безопасный CRUD-flow
  1. 1Проверить ввод, доступность формы и права действия в интерфейсе.
  2. 2Отправить запрос по контракту API.
  3. 3Дождаться ответа или явно включить optimistic UI.
  4. 4Обновить кэш, список или карточку из надежного источника.
  5. 5Показать ошибку, восстановить фокус и откатить UI, если операция не прошла.
Опасный CRUD-flow
  1. 1Считать клик пользователя успешной операцией.
  2. 2Не блокировать повторную отправку формы.
  3. 3Затирать объект неполным PUT-запросом.
  4. 4Скрывать элемент после Delete без rollback.
  5. 5Показывать общий toast без связи с полем, фокусом или причиной ошибки.

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

Если нужно дать короткий ответ, можно сказать так:

CRUD это Create, Read, Update и Delete, четыре базовые операции над данными. Во фронтенде они обычно проявляются как создание через форму, чтение списков и карточек, редактирование и удаление. В REST API это часто POST, GET, PUT или PATCH и DELETE, но я всегда смотрю контракт и обрабатываю состояния загрузки, ошибки, права и синхронизацию UI с сервером.

Частые ошибки

Где обычно ошибаются

Проверьте формулировки, которые звучат уверенно, но на интервью быстро выдают пробелы.

  1. 1

    Сводить CRUD только к HTTP-методам

    CRUD описывает смысл операций над данными. HTTP-методы это только один из способов выразить этот смысл в REST API. Если сказать, что соответствие всегда строгое, вас легко проверят вопросом про GraphQL, RPC или нестандартный API-контракт.
  2. 2

    Путать PUT и PATCH

    PUT часто трактуют как замену ресурса целиком, а PATCH как частичное изменение. Если отправить неполный объект туда, где сервер ждет полный ресурс, можно затереть поля и получить баг с потерей данных.
  3. 3

    Не думать о состоянии интерфейса

    CRUD на фронтенде это не только вызов API. Вам нужны loading, error, empty state, disabled-кнопки, доступные сообщения об ошибках и обновление кэша. Без этого пользователь может отправить форму дважды, увидеть старый список, не понять ошибку со скринридером или потерять доверие к интерфейсу.
  4. 4

    Верить, что скрытая кнопка защищает данные

    Если пользователь не видит кнопку удаления, это не значит, что он не может вызвать запрос напрямую. Сервер должен проверять права. Фронтенд должен аккуратно показывать состояние доступа и не раскрывать лишние детали в ошибках.
  5. 5

    Удалять из UI без плана отката

    Optimistic Delete может ускорить интерфейс, но только если вы возвращаете элемент при ошибке. Иначе интерфейс покажет одно состояние, сервер сохранит другое, а пользователь решит, что данные пропали.

Follow-up

Что могут спросить дальше

Короткие ответы на вопросы, которыми проверяют, что вы связываете CRUD с API, состоянием интерфейса и безопасностью данных.

Живые ответы

Видео с похожим вопросом

Если найдем публичные интервью с таким вопросом, добавим их сюда. Их удобно смотреть после теории, чтобы свериться с живыми ответами.

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

Содержание