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

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

Операторы сравнения позволяют сравнивать два значения между собой и, если условие выполнено, возвращают true, а если нет — false.

Выражения сравнения всегда возвращают логические значения, которые широко применяются в инструкциях if, while или for для управления ходом исполнения программы.

Полный список операторов сравнения в JavaScript приведен в следующей таблице:

Равенство (==) и неравенство (!=)

Оба оператора принимают операнды любого типа и, если операнды равны, оператор равенства == возвращает true, а оператор неравенства != возвращает – false.

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

При преобразовании типов операторы равенства == и неравенства != руководствуется следующими правилами:

• Если какой-либо операнд число или булево значение, то операнды преобразуются в числа, при этом true преобразуется в 1, а false преобразуется в 0.
• Если какой-либо операнд строка – второй преобразуются в строку.
• Если одно из значений представляет собой объект, а другое – число или строку, то объект преобразуется в элементарный тип.

При сравнении операндов также применяются свои правила:

• Если одно из значений равно null, а другое – undefined, то они равны.
• Значения null и undefined не преобразуются для сравнения ни в какие другие значения.
• Значение NaN считается не равным никакому другому значению, включая само себя. При его наличии оператор равенства всегда возвращает false, а оператор неравенства – true.
• Если оба операнда являются объектами, то они сравниваются, чтобы выяснить, один ли это объект. Если да, возвращается true, иначе – false.

Примеры:

Строгое равенство (===) и строгое неравенство (!==)

Операторы строгих равенства и неравенства, известные также как операторы идентичности === и неидентичности !==, делают то же самое, что и обычные операторы равенства и неравенства, но не преобразуют типы операндов перед их сравнением.

Оператор идентичности === возвращает true, только если операнды равны без преобразования:

• Если оба операнда имеют примитивные типы и содержат одинаковые значения, они считаются равными.
• Два операнда считаются равными, если оба ссылаются на один и тот же объект. Если же они ссылаются на разные объекты, они не равны, даже если эти объекты имеют идентичные свойства.
• Оператор идентичности считает значение NaN не равным никакому другому значению, включая само себя. При его наличии оператор идентичности всегда возвращает false.

В противоположность оператору идентичности === оператор неидентичности !== возвращает true, если без преобразования операнды не равны.

Операторы отношений: (>), (<), (>=), (<=)

Как работают операторы отношений «больше» >, «меньше» <, «больше или равно» >= и «меньше или равно» <= нам известно ещё из школьной математики. Каждый из этих операторов возвращает логическое значение (true или false).

Оператор больше > возвращает true, если значение левого операнда больше, чем значение правого операнда, в противном случае он возвращает false:

alert(7 > 5); // true
alert(5 > 7); // false

Оператор меньше < возвращает true, если значение левого операнда меньше, чем значение правого операнда, в противном случае он возвращает false:

alert(7 < 5); // true
alert(5 < 7); // false

Оператор больше или равно >= возвращает true, если значение левого операнда больше или равно, чем значение правого операнда, в противном случае он возвращает false:

alert(7 >= 5); // true
alert(5 >= 5); // true

Оператор меньше или равно <= возвращает true, если значение левого операнда меньше или равно, чем значение правого операнда, в противном случае он возвращает false:

alert(5 <= 7); // true
alert(5 <= 5); // true

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

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

Теперь разберем, как происходит сравнение каждого символа. Каждый символ переводится в числовое значение, согласно кодировке Unicode, и суть сравнения символов сводиться к сравнению двух чисел. Например, десятичные (Dec) значения символов кирилицы лежат в диапазоне от 1024 до 1280.

Пример:

var str1 = "Апельсин";
var str2 = "абрикос";

Начинаем сравнивать первые символы: str1[0] (буква "А") и str2[0] (буква "а").

В JavaScript, как и в других языках програмирования, есть метод для получения цифрового кода из символа:

str.charCodeAt(pos);

Метод возвращает код символа расположенного на позиции pos в строке str. Отсчет позиций символов в строке начинается с нуля.

Если бы первые символы строк были равны, то дальше сравнивались бы следующие символы попарно.

В этом примере строка "Апельсин" считается меньше, чем строка "абрикос", потому что буква "А" имеет код 1040, а буква "а" – 1072. Причина в том, что коды прописных букв всегда меньше, чем строчных.

Чтобы правильно сравнить строки по алфавиту, необходимо перед сравнением преобразовать оба операнда в один регистр (например, в нижний):

После преобразования в нижний регистр слово "апельсин" становится больше, чем слово "абрикос", потому что вторая буква "п" имеет код 1087, а вторая буква "б" переменной str2 – 1073.

Не менее интересная ситуация складывается при сравнении чисел, предствленных в строковой форме, например:

В примере выше "15" < "5", потому что числа, представленные в виде строк, сравниваются как строки. Строковые операнды, как вы уже знаете, сравниваются по кодам знаков (код знака "1" – 49, код знака "5" – 53 ).

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

В этом примере строка "15" преобразуется в число 15, а затем производится сравнение полученных чисел.

В случае, когда строку невозможно преобразовать в число, она преобразуется в NaN. Как правило, в результате любой операции сравнения с операндом NaN получается false:

Итоги

• Операторы сравнения сравнивают значения операндов и возвращают логическое значение – true или false в зависимости от результатов проверки.
• При сравнении операнды, имеющие значения разных типов, приводятся к числовому значению, за исключением сравнения на идентичность === и неидентичность !==.
• При сравнении строк, сравнение происходит побуквенно: каждый символ переводится в числовое значение, согласно кодировке Unicode, и суть сравнения символов сводиться к сравнению двух чисел.
• Код буквы в нижнем регистре всегда больше, чем код буквы в верхнем регистре.
• Код цифры находящейся в строке всегда меньше кода буквенного символа в любом регистре.
• Как правило, код буквы, расположенной в алфавитном порядке раньше имеет меньшее значение, чем код буквы (в том же регистре), расположенной в алфавитном порядке после неё.
• Операторы сравнения считают значение NaN не равным никакому другому значению, включая само себя.
• Значения null и undefined НЕ СТРОГО равны == друг другу.
• При преобразовании в число null становится 0, а undefined становится NaN.

Задачи