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

В этом разделе мы познакомимся с операторами сравнения и с логическими значениями, которые такие операторы возвращают.

Многие операторы сравнения знакомы нам со школы:

• Больше/меньше: a > b, a < b.
• Больше/меньше или равно: a >= b, a <= b.
• Равно a == b.
  Для сравнения используется два символа равенства '='. Один символ a = b означал бы присваивание.
• «Не равно». В школе он пишется как ≠, в JavaScript - знак равенства с восклицательным знаком перед ним !=.

Логические значения

Как и другие операторы, сравнение возвращает значение. Это значение имеет специальный логический тип.

Существует всего два логических значения:

• true - имеет смысл «да», «верно», «истина».
• false - означает «нет», «неверно», «ложь».

Например:

alert( 2 > 1 ); // true, верно
alert( 2 == 1 ); // false, неверно
alert( 2 != 1 ); // true

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

var a = true; // присвоили явно
var b = 3 > 4; // false

alert( b ); // false

alert( a == b ); // (true == false) неверно, результат false

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

Строки сравниваются побуквенно:

alert( 'Б' > 'А' ); // true

Буквы сравниваются в алфавитном порядке. Какая буква в алфавите позже - та и больше.

Сравнение осуществляется как в телефонной книжке или в словаре. Сначала сравниваются первые буквы, потом вторые, и так далее, пока одна не будет больше другой.

Больше - та строка, которая в телефонной книге была бы на большей странице. Например:

alert( 'Вася' > 'Ваня' ); // true, как и в словаре, 'Вася' после 'Ваня'

При этом любая буква больше отсутствия буквы:

alert( 'Привет' > 'Прив' ); // true, так как 'е' больше чем "ничего".

Такое сравнение называется лексикографическим.

alert( "2" > "14" ); // true

alert( +"2" > +"14" ); // false, т.к. + перед строкой приводит её к числу

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

При сравнении значения преобразуются к числу, кроме случая когда оба значения — строки.

Например:

alert( '2' > 1 ); // true
alert( '01' == 1 ); //true
alert( false == 0 ); // true, false становится 0, а true 1.

Тема преобразований типов будет продолжена далее, в главе Преобразование типов, toString и valueOf. Мы откладываем её на будущее, чтобы пока узнать побольше о типах данных JavaScript.

Строгое равенство

Обычное равенство не может отличить 0 от false:

alert(0 == false); // true, т.к. false преобразуется к 0

Что же делать, если все же нужно отличить 0 от false?

Для проверки равенства без преобразования типов используются операторы строгого равенства === (тройное равно) и !==.

Они сравнивают без приведения типов. Если тип разный, то такие значения всегда неравны (строго):

alert(0 === false); // false, т.к. типы различны

Специальные значения

Проблемы со специальными значениями возможны, когда к переменной применяется операция сравнения > < <= >=, а у неё может быть как численное значение, так и null/undefined.

При этом программисты, пришедшие из других языков, зачастую ошибочно считают, что null/undefined эквивалентны нулю, но это не так.

alert(null > 0); // false
alert(null == 0); // false

alert(null >= 0); // *!*true*/!*

alert( undefined == null ); // true

alert(undefined > 0); // false (1)
alert(undefined < 0); // false (2)
alert(undefined == 0); // false (3)

Итого

• В JavaScript есть логические значения true (истина) и false (ложь). Операторы сравнения возвращают их.
• Строки сравниваются побуквенно.
• Значения разных типов приводятся к числу при сравнении, за исключением строгого равенства === (!==).

Специальные значения null/undefined не эквивалентны нулю при сравнениях:

• Операторы > < >= <= преобразуют всё к числу: null -> 0, undefined -> NaN.

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

• Проверка равенства считает, что undefined == null, но эти значения не равны ничему другому.

  Зачастую различать эти значения не надо, так что можно для проверки на null/undefined использовать оператор ==.