Операторы сравнения

JavaScript простым языком

Сегодня подробнее хочу рассказать об операторах сравнения и где они используются.

Надеюсь, услышав фразу операторы сравнения ты вспомнил хотя бы школьную математику. Если вспомнил, то ты еще не потерян, а вот если нет, придется тебя возвращать к жизни =).

Операторы сравнения в JavaScript ровно такие же, как и в математике, ничего особо нового. Но, я обязан рассказать. Начнём.

Список всех операторов сравнения в JavaScript:

• больше меньше: a > b, b < a

• больше или равно, меньше или равно: a >= b, b <= a

• равно: a == b

• не равно: a != b

Здесь хочу обратить твоё внимание на операторы равно = и не равно !=

Дело в том, что нужно четко понимать, что при проверке на равенство ты всегда должен использовать, как минимум два знака равно (==), а не один. Это нужно делать по одной причине – если ты напишешь один знак (a = b), то JavaScript рассмотрит эту операцию, как присваивание значения переменной b в переменную a, а не как сравнение. Это важно и нужно запомнить раз и навсегда!

А также то, что оператор не равно пишется именно со знаком восклицания (!=), и никак иначе.

Если ты внимательно читаешь, то заметил, что я написал как минимум два знака равно. Наверное, у тебя назрел вопрос, а сколько же их может быть еще? Об этом позже, потерпи =)

Результат сравнения

Как и операторы сложения/вычитания, умножения/деления, которые, как я думаю, не нуждаются в объяснении, операторы сравнения так же возвращают результат. Тип этого значения – Boolean (логический).

Пример:

4 > 1; // (1) - получим логическое значение true
3 < 1; // (2) - получим логическое значение false
3 <= 4; // (3) - получим логическое значение true

Все до предела просто. В примере (1), значение 4, действительно, больше чем значения 1, следовательно, сравнение истинно и является правдой (true). Напомню, что правда/истина в логическом типе равна значению true.

В примере (2), мы получаем логическое значение false, поскольку это сравнение неверно/ложно. Значение 3, на самом деле, больше, чем значение 1.

Пример (3) уже немного интереснее. Здесь уже проверяются 2 условия. Если хотя бы одно из условий истинно, то мы всегда получаем логическое значение true. И здесь получается, что хоть значение 3 и не равно значению 4, но оно меньше, а значит одно из условий было выполнено.

Стоит понимать, что чаще всего приходится сравнивать не только типы Number (числа), но и String (строки), Boolean (логический). Короче говоря, сравнивают все, что не лень =)

'строка' == 'строка'; // получим значение: true
true == false; // получим значение: false  

Также строки можно проверять на > или <. В таком случае, строки будут проверяться посимвольно. Но, так как на практике это применяется крайне редко, я просто приведу самый простой пример:

'а' < 'я'; // получим значение: true 
(т.к., 'я' // в алфавите идет после 'а') 

На самом деле, в данном случае проверка идет не по алфавиту, а по таблице Unicode, которую использует JavaScript, но, в данный момент я не хочу углубляться в эту тему, по той причине, что на практике это практически никогда не используется.

До этого мы сравнивали только одинаковые типы, но что будет, если попытаться сравнить разные типы?

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

Ничего сложного в сравнении разных типов нет. JavaScript будет стараться приводить каждое из сравниваемых значений к числу:

'09' == 9; // получим значение: true ('09' преобразуется 
// в значение 9 типа Number)
'100' < 4; // получим значение: false ('100' преобразуется 
// в значение 100 типа Number)
true == 0; // получим значение: false (true преобразуется 
// в значение 1 типа Number)
false == 0; // получим значение: true (false преобразуется 
// в значение 0 типа Number)

Естественно, если постараться сравнить это:

'строка' > 3;

JavaScript будет пытаться преобразовать значение 'строка' в число, а так как это невозможно – мы получим значение NaN (Not-A-Number) и это выражение всегда будет ложным и возвращать логическое false

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

А теперь вернусь к вопросу, который я задал в самом начале, а именно: Сколько же знаков равно может использоваться при сравнении?

Ответ: 2 или 3.

В чем отличие между 2-я и 3-я знаками?

Когда мы сравниваем значения с помощью ==, то JavaScript пытается привести сравниваемые значения к типу Number (числу), что может привести к неожиданным результатам, если не разбираться в этой теме. Например:

'' == false; // (1) получим значение: true
0 == false; // (2) получим значение: true
1 == true; // (3) получим значение: true

В случае (1), пустая строка приводится к Number и преобразуется в числовое значение 0, и значение falseпреобразуется в числовое значение 0. Поэтому получается, что выражение истинно.

В случае (2), значение false приводится к числовому значению 0 и выражение также становится истинным.

В случае (3), значение true приводится к числовому значению 1 и выражение тоже оказывается верным.

Вроде бы во всех трёх случаях все логично, НО, если подумать, то как в таком случае отличить, например, значение 0 от значения false?

А вот здесь как раз к нам на помощь приходит строгое сравнение: ===.

При строгом сравнении не происходит никаких приведений типов. Пример:

0 === ''; // получим значение: false
1 === true; // получим значение: false
1 === '1'; // получим значение: false
'' === false; // получим значение: false
true === true; // получим значение: true
1 === 1; // получим значение: true

В данном случае, JavaScript сначала проверяет типы сравниваемых значений. Если они не совпадают, то JavaScript прекращает проверку и выдает результат: false

В целом, по операторам сравнения на этом думаю закончить, так как мы рассмотрели все важные моменты.

Данный урок очень важен для понимания. Внимательно перечитай несколько раз те места, которые не до конца понял.