Сравнения на языке Javascript

Javascript

Операции сравнения величин хорошо известны изучающим JavaScript из школьного курса алгебры. Однако в языках программирования операторы имеют несколько иную запись, чем в математике. Кроме того, при работе с операторами нужно быть готовым к некоторым неожиданным эффектам и уметь их предотвращать.

Операторы сравнения, используемые в JavaScript

Запись привычных операций сравнения в языке выглядит так:

  1. «Больше»: a > b.
  2. «Больше или равно»: a >= b.
  3. «Меньше»: a < b.
  4. «Меньше или равно»: a <= b.
  5. «Равно»: a == b. Для выражения этого отношения в JS используется именно двойное написание знака. Привычная запись a = b не выражает равенство, а показывает, что переменной a присваивается значение b.
  6. «Не равно»: a != b. Здесь тоже имеет место отличие от привычного алгебраического написания со знаком ≠.

В результате выполнения операций данного типа возвращается переменная логического типа со значением true (в случае, если результат сравнения верен) или false (при ложном результате). Выглядеть это может так:

  • alert( 5 > 3 ); — возвращается true;
  • alert( 5 == 3); — возвращается false;
  • alert( 5 != 3); — результат true.

Полученное в результате сравнения значение может присваиваться переменной:

let comparing = 6 > 3;
alert( comparing );

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

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

Этот процесс производится посимвольно, при этом вместо традиционного алфавита задействуется кодировка Unicode. Это влияет на то, что строчное и заглавное написание одной и той же буквы (например, п и П) не считаются равными друг другу. Большей считается строчная буква (п > П), так как в используемой JS таблице кодировки ее код больше. При сравнении разных букв русского или латинского алфавита большей будет та, чья позиция в алфавите больше.

В целом же применяемый при сравнении алгоритм выглядит так:

  1. Сначала сопоставляются начальные символы строчек. Если они не равны друг другу, большей считается строка, первый символ которой больше, и процесс завершается.
  2. Если первые символы идентичны, производится переход к сравнению вторых символов. Если они не равны, большей будет строка, второй символ которой больше.
  3. Алгоритм продолжается до тех пор, пока одна из строк не закончится (в этом случае большей окажется та из них, которая содержит больше символов) или пока символы на N-ной позиции не окажутся различными между собой (тогда большей будет та строка, где соответствующий символ больше).

Ниже приводятся примеры сравнения строчек, содержащих буквы и слова:

alert( ‘Л’ > ‘А’);

В результате будет выводиться true, так как позиция буквы Л в алфавите больше, чем у А, которая имеет наименьшую возможную (первую) позицию.

alert( ‘Соки’ > ‘Совы’ );

Здесь также получится значение true, при этом прохождение алгоритма будет выглядеть так: С равна С, о равна о, к больше чем в. На этом прохождение заканчивается, так как у строк обнаружилась неодинаковая буква.

alert( ‘Стол’ > ‘Столовый’);

А здесь уже отобразится значение false. На деле, вторая строка будет больше. Сравнение выглядит так: С = С, т = т, о = о, л = л, а буква «о» больше, чем отсутствие символа (более короткая строка закончилась).
Если сравнивать числа, представленные в форме строчек, высока вероятность получить математически некорректные выражения, например:

alert( ‘14’ < ‘4’ ); -> результат true.

Этот результат, конечно, не является математически правильным и связан с тем, что при представлении обоих чисел в виде строк их сравнивают по строковому алгоритму, основанному на кодах знаков. Если код первого символа левой строки меньше, чем правой (а для единицы он меньше, чем для четверки), вся строка считается меньше!

Устранить это явление можно, представив хотя бы один из сравниваемых операндов в числовой форме. В этом случае в нее преобразуется и второй, и будет получено:

alert( ‘14’ < 4 ); -> результат false.

Если превратить строчку в число не получается, она переходит в состояние Not-a-Number. Сравнение NaN с другим операндом обычно выдает значение false, например:

  • alert( ‘b’ < 4 ); -> результат false;
  • alert( NaN < 4 ); -> результат false.

Как сравниваются значения различных типов

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

alert( ‘3’ > 2 );
alert( ’02’ == 2 );

В обоих этих случаях в результате будет выдаваться true. В первом случае строчка ‘3’ превращается в число 3, во втором ‘02’ становится двойкой. Логические значения преобразуются привычным образом: true – в единицу, а false – в нуль. В записи это можно представить так:

alert( true == 1 );
alert( false == 0 );

В обоих случаях будут возвращены значения true. Из-за особенностей преобразования Javascript разных типов переменных возможны неожиданные результаты вычислений. Например, ситуация, когда пара операндов равны между собой, при этом имеют разный статус в качестве логических значений: одно истинно, а другое ложно:

let x = 0;
alert( Boolean(x) );

let y = «0»;
alert( Boolean(y) );
alert(x == y); //

В первом случае результат вывода будет false, во втором – true, в третьем (при сравнении) – также true. При сравнении операндов задействуется числовое преобразование, из-за чего «0» превращается в 0. При булевском преобразовании используются другие правила.

В случае, когда один из сравниваемых операндов является булевской переменной, его преобразуют в единицу, если он истинен, и в +0 – если ложен. При сравнении объекта с числом или строчкой язык программирования предпринимает попытку преобразования объекта в такую же форму (или в элементарное значение). Для этого задействуются методы toString и valueOf. Когда трансформировать объект не получается, выдается ошибка выполнения операции.

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

Эта операция выполняется в некоторых из тех случаев, когда применение традиционного сравнения создает трудности. Один из примеров – невозможность отличить нуль и пустую строчку от ложной булевской переменной:

alert( 0 == false );
alert( » == false );

В обоих этих случаях компилятором будет выдаваться true. Возникает эта ошибка из-за того, что оператор == преобразует операнды различных видов в числовой формат. В частности, и пустая строчка, и булевский false трансформируются в нуль. В связи с этим встает вопрос, как отличить нуль от ложной булевской переменной.
Для этого и используется строгое сравнение. Его оператор выглядит, как три математических знака равенства, написанных в одну строчку: ===.

Отличительная особенность оператора – способность к оценке равенства без приведения разных операндов к одному виду. Если сравниваемые x и y принадлежат к разным типам переменных, использование оператора === всегда дает оценку false. Например:

alert( 0 === false );

В результате проверки будет выведено false: операнды относятся к разным типам.

Существует также оператор строгого неравенства !==. Его использование минимизирует вероятность ошибок при сравнении, поэтому его часто предпочитают более лаконичному !=. Как и оператор ===, !== производит сравнения без преобразования типов.

Примеры могут выглядеть так:

  • 5 !== 5 (возвращается false);
  • 5 !== ‘5’; (возвращается false: переменные принадлежат к разным типам);
  • 6 !== 5 (возвращается true).

Как сравнивать undefined и null с иными типами значений

Эти операнды ведут себя при сравнении специфически. Можно выделить несколько случаев, в зависимости от используемого оператора.

Строгое равенство выдает, что эти операнды – разные. Это связано с принадлежностью к разным типам:

alert( null === undefined ); — будет выведено false.

При использовании нестрогого равенства undefined и null будут считаться идентичными, но при этом они не будут образовывать равенство с какими-либо иными значениями:

alert( null == undefined ); — будет выводиться true.

Применение операторов сравнения, взятых из алгебры (>, >=, <, <=) данные значения превращаются в числовую форму: null – в нуль, а undefined становится Not-a-Number. Из-за этого при выполнении операций возможны специфические явления. Например, при сравнении 0 и null имеем:

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

В первых двух случаях будет выдаваться ложь, в последнем – истина. Алгебраически верными результаты не будут, ведь если операнд больше или равен 0, хотя бы одно из первых двух сравнений должно выдавать true. Но оба выдают false.

Такое явление связано с разницей в работе оператора == и алгебраических «больше» и «меньше». Последние трансформируют null в числовую форму, за счет чего и получается, что null >= 0 выдает true, а null > 0 – false.

Оцените статью
Образовательный портал WELCOME4U.RU
Добавить комментарий

Adblock
detector