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

Reading time ~6 minutes

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

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

  • больше
    1
    >
    
  • меньше
    1
    <
    
  • больше или равно
    1
    >=
    
  • меньше или равно
    1
    <=
    
  • равно
    1
    ==
    
  • неравно
    1
    !=
    

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

  • 1
    true
    
    - да, верно, истина
  • 1
    false
    
    - нет, неверно, ложь

Логические значения можно присваивать переменным явно:

  var a = true; // true

Можно присвоить переменной логическое значение как результат операции (сравнения):

  var m = 6 >= 8 // false

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

Строки сравниваются побуквенно, слева-направо. Берутся две строки и начинается сравнение. Берется первый символ первой строки и сравнивается с первым символом второй строки. Если они равны, то берутся второй символ первой строки и сравнивается со вторым символом второй строки.

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

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

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

Вывод, какой символ больше или меньше, производится на основании численных значений этих символов. Буквы нижнего регистра имеют большее численное значение, нежели буквы верхнего регистра. Буква

1
А
имеет меньшее численное значение, нежели буква
1
Б
. Отсутствие символа всегда считается меньше, чем присутствие символа.

Ниже приведены примеры (как же без них?), иллюстрирующие сравнение строк.

Первый символ первой строки больше первого символа второй строки, дальнейшее сравнение прекращается и делается вывод, что первая строка больше второй строки:

  console.log("Банан" > "Аят"); // true

В этом примере сравнение идет последовательно (символ в символ) вплоть до третьего по порядку символа, на котором сравнение прерывается, так как символ “c” по числовому значению больше символа “н”. На основании этого делается вывод, что первая строка “Вася” больше второй строки “Ваня”:

  console.log( "Вася" > "Ваня" ); // true

Любая буква (символ) больше отсутствия буквы. Например, первая строка больше второй, так как буква “е” в первой строке больше отсутствия таковой во второй строке:

  console.log( "Привет" > "Прив" ); // true

Интересный пример сравнения связан обработкой введенных пользователем данных. Все данные, вводимые пользователем на странице, являются строковым типом. Поэтому сравнивать их, не выполнив предварительное преобразование типов, нельзя. Например:

  console.log( "4" > "15" ); // true

… с точки зрения JavaScript будет верным

1
true
, так как строка “4” больше строки “15” (первый символ “4” больше первого символа “1”). Однако, в данном случае пользователем введены два числа 4 и 15, а не строки. Поэтому их необходимо привести к числовому типу и уже тогда сравнивать:

  console.log( +"4" > +"15" ); // false

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

Если производится сравнение данных различного типа, то JavaScript производит автоматическое (правильно такое преобразование называется неявным преобразованием) преобразование всех данных к числовому типу. И тогда производится сравнение чисел.

Строковый тип “34” приводится к числовому типу (числу) 34 и производится сравнение между числом 34 и числом 33:

  console.log( "34" > 33 ); // true

Булев тип

1
false
приводится к числовому типу 0 (
1
true == 1
,
1
false == 0
) и производится сравнение двух (одинаковых в данном случае) чисел 0:

  console.log( false == 0 ); // true
  console.log( true == 0 ); // false

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

Для этой цели используется оператор строгого равенства (

1
===
) и строгого неравенства (
1
!==
). То есть, к обычным операторам равенства (
1
==
) и неравентсва (
1
!=
) добавляется еще один символ (
1
=
).

Если тип разный, то операция сравнения всегда возвращает значение

1
false
:

  console.log( "example" === 34 ); // false

Строгое сравнение предпочтительно, если мы хотим быть уверены, что «сюрпризов» не будет.

Вывод: любые сравнения с

1
undefined/null
, кроме точного
1
===
, следует делать с осторожностью. Желательно не использовать сравнения
1
>=
1
>
1
<
1
<=
с ними, во избежание ошибок в коде.

Итог

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

Данная статья является пересказом соответствующего материала с ресурса learn.javascript.ru и не претендует на оригинальность.

MongoDB - создание документа

![MongoDB]({{site.url}}/images/uploads/2017/05/mongodb-logo.jpg "MongoDB")Приступили к самому основному - операциям создания, чтения, изм...… Continue reading

MongoDB - документы

Published on May 23, 2017