Ответ
Оператор строгого равенства (===) сравнивает два значения, не выполняя приведение типов (type coercion). Он возвращает true только если операнды идентичны и по типу, и по значению.
Сравнение с нестрогим равенством (==):
// Нестрогое равенство (==) ПРИВОДИТ ТИПЫ перед сравнением:
console.log(5 == '5'); // true (строка '5' преобразуется в число 5)
console.log(null == undefined); // true (специальное правило)
console.log(0 == false); // true (false преобразуется в число 0)
// Строгое равенство (===) НЕ ПРИВОДИТ ТИПЫ:
console.log(5 === '5'); // false (Number !== String)
console.log(null === undefined); // false (Null !== Undefined)
console.log(0 === false); // false (Number !== Boolean)
console.log(5 === 5); // true (одинаковые тип и значение)Почему === является best practice?
- Предсказуемость: Поведение кода становится более явным и менее подверженным скрытым ошибкам из-за неочевидных преобразований.
- Безопасность: Исключает сценарии, когда, например,
0 == falseили пустая строка'' == falseмогут привести к логическим ошибкам в условиях. - Производительность: Незначительно, но быстрее, так как не требует дополнительного шага приведения типов.
В подавляющем большинстве случаев в современном JavaScript (и, соответственно, в Node.js) следует использовать строгое равенство === и строгое неравенство !==.
Ответ 18+ 🔞
Ага, слушай, вот тебе про операторы сравнения в JavaScript, чтоб ты понимал, как это всё работает, а не как у тебя в голове после пятницы.
Представь, что у тебя есть два друга. Один — оператор строгого равенства (===). Он, блядь, такой принципиальный, как будто у него палка в жопе. Он сравнивает два значения и говорит: «Ребята, вы одинаковые?» — только если они идентичны и по типу, и по значению. Никаких поблажек, никаких «ой, ну ты же почти цифра». Нет. Либо всё, либо нихуя.
А второй друг — оператор нестрогого равенства (==). Это такой распиздяй, который готов на всё, лишь бы не ссориться. Он перед сравнением делает приведение типов, то есть пытается сделать так, чтобы операнды стали одного типа, даже если для этого нужно натянуть сову на глобус. И вот тут начинается пиздец.
Смотри, вот тебе примеры, чтоб ты сам офигел:
// Нестрогое равенство (==) — наш хитрожопый друг
console.log(5 == '5'); // true (строка '5' волшебным образом превращается в число 5, ёпта!)
console.log(null == undefined); // true (тут специальное правило, типа они оба — ничто)
console.log(0 == false); // true (false, блядь, превращается в ноль, и они братаются)
// А теперь строгое равенство (===) — наш принципиальный уёбок
console.log(5 === '5'); // false (Число и Строка — это как хуй и пальто, разные вещи!)
console.log(null === undefined); // false (Нет, ребята, Null и Undefined — это разные типы, идите нахуй)
console.log(0 === false); // false (Ноль — это число, false — это булево, нихуя не одинаково)
console.log(5 === 5); // true (Вот тут всё чисто, оба числа, оба пятерки — красота)Теперь главный вопрос: почему все адекватные разработчики орут, что надо использовать ===? Да потому что, ёбаный в рот, предсказуемость! С == можно так наебнуться, что потом неделю будешь искать, почему у тебя условие не работает. Представь, у тебя в коде if (userInput == 0), а пользователь ввёл пустую строку. И что? '' == 0 — это true! Вот тебе и хиросима, чувак. А с === — сразу false, и ты понимаешь, что пошло не так.
Итог простой, как три копейки:
- Предсказуемость и безопасность:
===не делает этих ебнутых преобразований, которые только мозги пудрят. Ты видишь, что сравниваешь, и получаешь честный результат. Доверия к такому коду — овердохуища. - Производительность: Да, чутка быстрее, потому что не надо тратить время на эти цирки с приведением типов. Мелочь, а приятно.
Поэтому запомни раз и навсегда: в современном JavaScript (и в Node.js, естественно) всегда используй строгое равенство === и строгое неравенство !==. Забудь про == и !=, как про страшный сон. Это не best practice, это, блядь, правило выживания. Иначе однажды твой код превратится в такую пиздопроебибну, что разбираться в ней будет только тот самый «хуй с горы».
