Операторы сравнения и логические значения

Операторы сравнения, к которым относится не только "больше" "меньше", но и "равно" и "строго равно", возвращают логические значения true или false.

Сравнение строк

Операторы сравнения стараются привести переменную к числу. При этом буквы приводятся к их номеру в кодировке ASCII

Для перевода символов в эту кодировку используется функция .charCodeAt()

    "a".charCodeAt(); // 97
    "A".charCodeAt(); // 65
    "а".charCodeAt(); // 1072 - удивлены? секрет прост: в первой строке а в латинской раскладке, в третьей - в кириллической

При использовании функции .charCodeAt() нужно помнить, что она применима только к строкам, поэтому аргумент должен обязательно быть в кавычках

Если первые символы равны, сравниваются вторые, третьи и т.д, как если бы эти слова были расположены в словаре

Ну, ок. А если строка содержит число? Например что получится при сравнении строк "123" и "4"?
Здесь js ведёт себя довольно тупо и по-прежнему сравнивает номера символов в кодировке  ASCII

И так как

    "4".charCodeAt(); // 49
    "4".charCodeAt(); // 52

В результате получаем

    "123" < "4" // true 

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

     +"123" < +"4" // false

На всякий случай проверим приоритет операторов: унарный плюс - 19, знак меньше - 11. То есть вначале строка преобразуется к числу, а потом числа будут сравниваться.

Сравнение разных типов

Сравнение, как и остальные операторы (кроме бинарного сложения) старается привести переменную к числу

То есть при сравнении строки с числом вначале строка приводится к числу, а уже потом они сравниваются:

    "123" < 4 // false, так как 123 не меньше 4
 

Сравнение с null и undefined

Значения null и undefined равны == друг другу и не равны чему бы то ни было ещё, кроме самих себя

  null == undefined   // true

При преобразовании в число null становится 0, а undefined становится NaN.

Сравнение null с 0


  null == 0;  // false
  null > 0;  // false
  null >= 0;  // true

Здесь сработало предыдущее правило. Вообще сравнение ( ==, >=, <= ) приводит величину к числу. То есть по идее null должен был превратиться в ноль. Но так как в спецификации сказано. что null и undefined равны == друг другу и не равны чему бы то ни было ещё, то первое выражение, где null == 0; тоже ложно.

Несравненный NaN

Ошибка вычисления NaN не равна вообще ничему, даже самой себе.

    NaN === NaN;  // false

Логика в этом есть: не факт, что разные NaN получены в результате одной и той же ошибки
"Все счастливые семьи похожи друг на друга, каждая несчастливая семья несчастлива по-своему" - каждый NaN уникален и непохож на другие.

Но при этом появляется проблема - как же всё-таки выявить этот NaN, если сравнить его с чем-то не получится.

Способы проверки на NaN

1. Функция isNaN

    var a = "one" - 1; // NaN
    isNaN(a);  // true


2. Метод Object.is(), который появился в ES6

         var a = "one" - 1; // NaN
    Object.is(a, NaN);  // true


Несравненный undefined

Значение undefined тоже нельзя сравнивать:

         undefined > 0; // false 
    undefined < 0; // false 
    undefined == 0; // false

Object.is() работает и здесь:

         var a; // undefined
    Object.is(a, undefined);  // true 



Но можно и проще

     undefined === undefined;  // true