Чему будет равно !1

Ответ короткий: !1 равно false.

Оператор ! в JavaScript работает не как арифметическая операция. Он берет любое значение, приводит его к boolean по правилам truthy и falsy, а потом возвращает противоположный boolean.

Для 1 шаги такие:

Boolean(1); // true
!1; // false

На интервью можно сказать так: число 1 truthy, логическое НЕ инвертирует true, результат будет false.

Вопрос маленький, но он проверяет не запоминание одного примера, а понимание приведения типов. Если вы отвечаете только "false" и останавливаетесь, ответ формально верный, но слабый. Лучше добавить одну фразу про truthy/falsy и одну фразу про инверсию.

Хороший короткий ответ:

!1 вернет false. Сначала 1 приводится к boolean как true, потому что это truthy-значение. Потом оператор ! инвертирует результат.

Этого достаточно для базового вопроса. Дальше можно показать практический нюанс: !value не означает "значение отсутствует". Он означает "значение falsy".

В JavaScript falsy-значений немного: false, 0, -0, 0n, пустая строка, null, undefined и NaN. Все остальные значения truthy.

Поэтому !value может быть удобной короткой проверкой. Но он же может стать источником бага.

function renderPrice(price) {
  // Плохо, если 0 это валидная цена
  if (!price) {
    return "Цена не указана";
  }

  return `${price} ₽`;
}

Если price равен 0, функция вернет "Цена не указана". Это неверно, если нулевая цена допустима. Безопаснее проверить именно отсутствие значения:

function renderPrice(price) {
  if (price == null) {
    return "Цена не указана";
  }

  return `${price} ₽`;
}

Здесь price == null намеренно ловит только null и undefined. Если в вашей команде запрещен ==, можно написать явно: price === null || price === undefined.

! инвертирует результат, а !! часто используют для явного приведения к boolean без изменения итогового смысла.

!1; // false
!!1; // true
Boolean(1); // true

В условиях if дополнительное !! обычно не нужно. Условие и так оценивает значение по truthy/falsy-правилам.

if (user) {
  // достаточно
}

if (!!user) {
  // работает, но чаще лишний шум
}

Для явного boolean-пропса или значения в состоянии !! может быть уместен, если вы хотите сохранить именно признак наличия.

Пустой объект и пустой массив являются truthy. Это часто сбивает с толку, потому что в обычной речи пустой звучит как ложный. В JavaScript это не так.

!{}; // false
![]; // false
Boolean({}); // true
Boolean([]); // true

Поэтому нельзя проверять пустоту массива так:

// Плохо: условие не сработает для пустого массива
if (!items) {
  showEmptyState();
}

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

if (items.length === 0) {
  showEmptyState();
}

А если массив может еще не прийти из API, разделяйте состояния: загрузка, ошибка, отсутствие данных и пустой список. Иначе UI начнет путать "данные еще не загружены" и "данные загружены, но список пуст".

Во frontend-коде проблема часто появляется не в выражении !1, а в слишком широкой проверке состояния.

function CartSummary({ items, total }) {
  if (!items) {
    return <Spinner />;
  }

  if (!total) {
    return <p>Корзина пуста</p>;
  }

  return <p>Итого: {total} ₽</p>;
}

Здесь есть два риска. Пустой массив [] не попадет в !items, потому что массив truthy. А total = 0 попадет в !total, хотя нулевая сумма может быть корректной для скидки или бесплатного заказа. В результате пользователь увидит неверный экран.

Безопаснее назвать состояния явно:

function CartSummary({ items, total, isLoading }) {
  if (isLoading) {
    return <Spinner />;
  }

  if (items.length === 0) {
    return <p>Корзина пуста</p>;
  }

  return <p>Итого: {total} ₽</p>;
}

Такая проверка не делает лишних запросов и не чинит race condition сама по себе. Но она убирает частый UI-баг: компонент больше не угадывает состояние по falsy-значению там, где нужен конкретный признак.

На интервью лучше не уходить в длинную лекцию. Дайте результат, объясните механизм и сразу покажите, что понимаете риск в коде.

Можно ответить так:

!1 равно false. Оператор ! приводит значение к boolean и инвертирует его. 1 это truthy, значит Boolean(1) будет true, а после инверсии получится false. В коде я аккуратно использую !value, потому что он ловит все falsy-значения, включая 0 и пустую строку.

Такой ответ показывает не только знание результата, но и понимание последствий для frontend-кода.