You don't know js(up & going)

_____________________________________________________________
var a = "42";
var b = 42;
a == b;
// true
a === b;
// false
_____________________________________________________________
В сравнении `a == b` JS замечает, что типы не совпадают, поэтому он делает
упорядоченный ряд шагов, чтобы привести одно или оба значения к другим
типам, пока типы не совпадут, а затем уже может быть проверено простое
равенство значений.
Если подумать, то есть два возможных пути, когда `a == b` может стать `true`
через приведение. Либо сравнение может закончится на `42 == 42`, либо на
`"42" == "42"`. Так какое же из них?
Ответ: `"42"` становится `42`, чтобы сделать сравнение `42 == 42`. В таком
простом примере не так уж важно по какому пути пойдет сравнение, в конце
результат будет один и тот же. Есть более сложные случаи, где важно не только
каков конечный результат сравнения, но и *как* вы к нему пришли.
Сравнение `a === b` выдает `false`, так как приведение не разрешено, поэтому
простое сравнение значений, очевидно, не завершится успехом. Многие
разработчики чувствуют, что операция `===` — более предсказуема, поэтому
они советуют всегда использовать эту форму и держаться подальше от `==`. Мне
кажется, такая точка зрения очень недальновидна. Я верю, что операция `==` —
мощный инструмент, который поможет вашей программе, *если вы уделите
время на изучение того, как это работает.*
Мы не собираемся рассматривать все скучные мельчайшие подробности того,
как работает приведение в сравнениях `==`. Многие из них очень разумные, но
есть несколько важных тупиковых ситуаций, с которыми надо быть осторожнее.
Чтобы посмотреть точные правила, загляните в раздел 11.9.3 спецификации ES5
(http://www.ecma-international.org/ecma-262/5.1/): вы будете удивлены тем,
насколько этот механизм прямолинейный, по сравнению со всей этой негативной
шумихой вокруг него.
Чтобы свести целое множество деталей к нескольким простым выводам и
помочь вам узнать, использовать `==` или `===` в различных ситуациях, вот мои
простые правила:
●
Если одно из значений (т.е. сторона) в сравнении может быть значением
`true` или `false`, избегайте `==` и используйте `===`.

---

●
Если одно из значений в сравнении может быть одним из этих особых
значений (`0`, `""` или `[]` — пустой массив), избегайте `==` и
используйте `===`.
●
Во *всех* остальных случаях вы можете безопасно использовать `==`. Это
не только безопасно, но во многих случаях это упрощает ваш код путем
повышения читаемости.
Эти правила сводятся к тому, что требуют от вас критически оценивать свой код
и думать о том, какого вида значения могут исходить из переменных,
проверяемых на равенство. Если вы уверены насчет значений, и сравнение `==`
— безопасно, то используйте его! Если вы не уверены насчет значений,
используйте `===`. Это просто.
Форма не-равно `! ` идет в паре с `==`, а форма `!
` — в паре с `===`. Все
правила и утверждения, которые мы только что обсудили также применимы для
этих сравнений на не равно.
Вам следует обратить особое внимание на правила сравнения `==` и `===`,
когда вы сравниваете два непримитивных значения, таких как `object` (включая
`function` и `array`). Так как эти значения на самом деле хранятся по ссылке, оба
сравнения `==` и `===` просто проверяет равны ли ссылки, но ничего не
сделают касаемо самих значений.
Например, `массив` по умолчанию приводится к `строке` простым
присоединением всех значений с запятыми (`,`) между ними. Можно было бы
подумать, что эти два `массива` с одинаковым содержимым будут равны по
`==`, но это не так: