Какой оператор сравнения использовать в JavaScript: == или ===?

Основное различие: сравнение значений vs сравнение значений и типов

Оператор == (нестрогое равенство) сравнивает значения после приведения типов. Оператор === (строгое равенство) сравнивает значения без приведения типов — если типы разные, сразу возвращает false.

Как работает == (с приведением типов)

Алгоритм == пытается привести операнды к одному типу перед сравнением. Основные правила:

• Строка и число — строка преобразуется в число: "5" → 5
• Логическое значение и число — true → 1, false → 0
• null и undefined — равны друг другу, но не равны ничему другому
• Объект и примитив — объект преобразуется в примитив через valueOf или toString

Примеры:

console.log(5 == "5");        // true (строка "5" стала числом 5)
console.log(0 == false);      // true (false стал 0)
console.log("" == 0);         // true (пустая строка → 0)
console.log(null == undefined); // true (специальное правило)
console.log([] == false);     // true (пустой массив → "" → 0, false → 0)

Как работает === (без приведения типов)

Оператор === сначала проверяет типы. Если типы разные — false. Если типы совпадают, сравнивает значения:

console.log(5 === "5");        // false (разные типы: number vs string)
console.log(0 === false);      // false (number vs boolean)
console.log(null === undefined); // false (null vs undefined)
console.log(5 === 5);          // true (одинаковые типы и значения)
console.log("hello" === "hello"); // true

Когда что использовать?

Правило большого пальца: всегда используйте ===, если вы не уверены на 100%, что нужно приведение типов. Это делает код предсказуемым и избегает скрытых ошибок.

Однако есть редкие случаи, когда == уместен:

• Проверка на null/undefined одновременно:

  // Вместо:
  if (x === null || x === undefined) { ... }
  // Можно:
  if (x == null) { ... }  // true только для null и undefined

• Сравнение с числами из пользовательского ввода (если вы уверены в данных):

  const userInput = "42"; // из формы
  if (userInput == 42) { ... } // работает, но лучше Number(userInput) === 42

Почему === считается лучшей практикой?

1. Предсказуемость — вы всегда знаете, что сравниваются значения без неявных преобразований
2. Безопасность — меньше шансов пропустить баг из-за неожиданного приведения типов
3. Читаемость — код явно показывает ваше намерение
4. Инструменты анализа кода — линтеры (например, ESLint) часто запрещают == по умолчанию

Итог: используйте === в 99% случаев. == оставьте только для явной проверки на null/undefined или когда вы точно знаете, что делаете. Если сомневаетесь — пишите ===.

// Плохо:
if (value == true) { ... }  // true для 1, "1", [1] и многих других

// Хорошо:
if (value === true) { ... } // только если value === true
// Или ещё лучше — используйте приведение к булю:
if (value) { ... }          // проверка на "истинность"
if (!value) { ... }         // проверка на "ложность"