Операторы сравнения в JavaScript — это те операторы, которые используются для сравнения двух числовых значений, строк, объектов или двух величин.
Операторы сравнения определяют взаимосвязь между собой путем сравнения операндов (или значений). Следовательно, мы также знаем операторы сравнения как операторы отношения в Java.
Например, чтобы узнать, какое число больше, сравнивая возраст двух человек, сравнивая цену двух товаров и т.д. Мы можем выполнять эти виды сравнений с помощью операторов сравнения (относительных).
Для оператора сравнения требуются два операнда. Результатом всех операторов сравнения является логическое значение, либо true, либо false.
Операторы сравнения в JavaScript в основном используются для создания условий в операторах принятия решений или циклах, чтобы выполнять действия только при выполнении определенного условия.
Например:
if(condition_is_true)
statement to be executed;
// We can implement this statement in the JavaScript program like this:
if(x > y)
document.write(x);
Типы операторов сравнения в JavaScript
JavaScript поддерживает восемь типов операторов отношения или сравнения. Они перечислены в таблице ниже:
| Оператор сравнения | Описание |
|---|---|
== (Равно) | Этот оператор оценивает, равны значения левого и правого операндов или нет. Если значения по обе стороны от оператора равны друг другу, оператор equal (==) возвращает true. |
!= (Не равно) | Этот оператор оценивает, что левый операнд не равен правой части. Если значения с обеих сторон оператора не равны друг другу, оператор not equal возвращает true. |
> (Больше) | Этот оператор вычисляет, что значение левого операнда больше значения правого операнда. Если значение в левой части оператора больше значения в правой части, оператор greater than (>) возвращает true. |
< (Меньше) | Этот оператор проверяет, является ли значение левого операнда меньшим значения правого операнда. Если значение в левой части operator меньше значения в правой части, результат становится истинным. |
>= (Больше или равно) | Этот оператор проверяет, что значение левого операнда больше или равно значению правого операнда. Если значение в левой части оператора больше или равно значению в правой части, то оператор возвращает true. |
<= (Меньше или равно) | Этот оператор вычисляет, что значение левого операнда меньше или равно значению правого операнда. Если это так, оператор возвращает true. |
=== (Строго равные или идентичные) | Этот оператор строго проверяет, равны ли левое и правое значения и имеют ли они один и тот же тип данных. Если значения с обеих сторон равны и имеют один и тот же тип данных, оператор strict равен (===) возвращает true. |
!== (Строго не равны или не идентичны) | Этот оператор строго проверяет, не равны ли левое и правое значения и не относятся ли они к одному и тому же типу данных. Если значения с обеих сторон не равны или не относятся к одному и тому же типу данных, оператор strict не равен (!==) возвращает true. |
Вышеупомянутые восемь операторов обеспечивают основу для сравнения данных в JavaScript. Каждый оператор всегда представляет собой комбинацию двух констант, переменных, выражений или их сочетания.
Давайте рассмотрим пример программы, основанной на концепциях всех операторов сравнения.
Пример 1:
<script>
let x = 10;
let y = 4;
document.write("x = "+x+ " y = " +y, "<br>");
document.write("(x > y): " +(x > y), "<br>");
document.write("(x < y): " +(x < y), "<br>");
document.write("(x >= y): " +(x >= y), "<br>");
document.write("(x <= y): " +(x <= y), "<br>");
document.write("(x!= y): " +(x!= y));
</script>
Вывод: x = 10 y = 4 (x > y): true (x < y): false (x>= y): true (x <= y): false (x!= y): true
Давайте создадим программу на JavaScript, в которой мы будем сравнивать число со строкой. В таком случае интерпретатор JavaScript автоматически преобразует строку в число.
Пример 2:
<script>
let x = 5;
let y = "5";
document.write("x = "+x+ " y = " +y, "<br>");
document.write("(x > y): " +(x > y), "<br>");
document.write("(x < y): " +(x < y), "<br>");
document.write("(x >= y): " +(x >= y), "<br>");
document.write("(x <= y): " +(x <= y), "<br>");
document.write("(x!= y): " +(x!= y), "<br>");
document.write("(x == y): " +(x == y), "<br>");
document.write("(x === y): " +(x ===y));
</script>
Вывод: x = 5 y = 5 (x > y): false (x < y): false (x>= y): true (x <= y): true (x!= y): false (x == y): true (x === y): false
В предыдущей программе значение 5 == «5» равно true, потому что строка «5» автоматически преобразуется в число. Тогда как значение 5 === «5» равно false, потому что оба операнда разного типа.
Давайте создадим программу на JavaScript, в которой мы будем сравнивать логическое значение с числом. Когда один из операндов является логическим, он автоматически преобразуется в 1 для true и 0 для false.
Пример 3:
<script>
let x = 0;
let y = false;
document.write("x = "+x+ " y = " +y, "<br>");
document.write("(x > y): " +(x > y), "<br>");
document.write("(x < y): " +(x < y), "<br>");
document.write("(x >= y): " +(x >= y), "<br>");
document.write("(x <= y): " +(x <= y), "<br>");
document.write("(x!= y): " +(x!= y), "<br>");
document.write("(x == y): " +(x == y), "<br>");
document.write("(x === y): " +(x ===y));
</script>
Вывод: x = 0 y = false (x > y): false (x < y): false (x>= y): true (x >= y): true (x!= y): false (x == y): true // потому что false эквивалентно 0. (x === y): false // потому что оба операнда разного типа.
Примечание: Операторы строгого равенства === и!== используются, когда операнды имеют один и тот же тип.
Попробуйте сами
Пример 4:
<script>
let x = 0;
let y = true;
document.write("x = "+x+ " y = " +y, "<br>");
document.write("(x > y): " +(x > y), "<br>");
document.write("(x < y): " +(x < y), "<br>");
document.write("(x >= y): " +(x >= y), "<br>");
document.write("(x <= y): " +(x <= y), "<br>");
document.write("(x!= y): " +(x!= y), "<br>");
document.write("(x == y): " +(x == y), "<br>");
document.write("(x === y): " +(x ===y));
</script>
Операторы сравнения и преобразование данных
Мы также можем иметь два операнда разных типов данных в одном выражении сравнения. В этом случае JavaScript всегда пытается преобразовать каждый операнд в число перед запуском сравнения. Давайте разберемся в различных случаях на примерах.
Случай 1: Если один операнд является строкой, а другой — числом, JavaScript пытается преобразовать строку в число. Например:
Пример 5:
<script>
var num1 = 12;
var num2 = "12";
var result = num1 == num2;
document.write("Result: " +result);
</script>
Вывод: Результат: true
В этой программе строка «12» преобразуется в число 12. Следовательно, сравнение num1 == num2 возвращает true.
Случай 2: Если строка не может быть преобразована в число, сравнение всегда возвращает false. Например:
Пример 6:
<script>
var num1 = 12;
var num2 = "String";
var result = num1 == num2;
document.write("Result: " +result);
</script>
Вывод: Результат: false
Случай 3: Если один операнд является логическим, а другой — числом в выражении, JavaScript преобразует логическое значение в число следующим образом:
- true: это логическое значение преобразуется в 1.
- false: это логическое значение преобразуется в 0.
Например, в приведенной ниже программе логическое значение true преобразуется в число 1. Следовательно, сравнение num1 == num2 возвращает true.
Пример 7:
<script>
var num1 = 1;
var num2 = true;
var result = num1 == num2;
document.write("Result: " +result);
</script>
Вывод: Результат: true
Случай 4: Если одно значение является логическим, а другое — строкой, JavaScript пытается преобразовать логическое значение в число и преобразует строку в число. Например:
Пример 8:
<script>
var num1 = false;
var num2 = "0";
var result = num1 == num2;
document.write("Result: " +result);
</script>
Вывод: Результат: true
В предыдущей программе логическое значение false преобразуется в число 0, а строка «0» также преобразуется в число 0. Следовательно, сравнение num1 == num2 возвращает true.
Оператор строгого равенства (тождества) в JavaScript
Оператор строгого равенства (===) был введен в версии JavaScript 1.5. Он возвращает true, если два операнда должны иметь один и тот же тип данных и должны быть равны без какого-либо преобразования данных.
Синтаксис оператора строгого равенства следующий:
A === B // Here, A and B are two operands.
Например, оператор 5 === «5» вернет значение false, потому что значение слева — number, а значение справа — string. Здесь значения имеют другой тип данных.
Если мы сравним две строки с помощью оператора строгого равенства, оператор строгого равенства вернет true только в том случае, если они имеют одинаковую последовательность символов и одинаковую длину. Например, оператор «ABc» === «ABc» вернет true.
Если мы сравним два логических значения, они будут строго равны, если либо оба они истинны, либо оба они ложны. Давайте рассмотрим пример программы, основанной на операторе строгого равенства.
Пример 9:
<script>
var p, q, result;
p = 5;
q = 5;
result = p === q;
document.write(result, "<br>");
p = 10;
q = "10";
result = p === q;
document.write(result, "<br>");
p = 'ABCd'
q = 'ABCD'
result = p === q;
document.write(result);
</script>
Вывод: true false false
Попробуйте сами
Пример 10:
<script>
var p, q, result;
p = "Love you";
q = "Love You";
result = p === q;
document.write(result);
</script>
Пример 11:
<script>
var p, q, result;
p = (10+10);
q = "20";
result = p === q;
document.write(result);
</script>
Оператор неидентичности/строгого неравенства в JavaScript
Оператор неидентификации (!==) был добавлен в версии JavaScript 1.5. Он выполняет функцию, противоположную оператору строгого равенства. Он возвращает true в любом из следующих случаев без какого-либо преобразования данных:
- Два операнда не равны.
- Два операнда не относятся к одному и тому же типу данных.
Синтаксис неидентичного оператора или оператора строгого неравенства следующий:
A!== B
Рассмотрим следующий пример программы с неидентичным оператором.
Пример 12:
<script>
var p, q, result;
p = (10+10);
q = "20";
result = p!== q;
document.write(result);
</script>
Вывод: true
В этой программе операнды p и q относятся к разным типам данных. Следовательно, он вернет true.
Попробуйте сами
Пример 13:
<script>
var p, q, result;
p = true;
q = 1;
result = p!== q;
document.write(result);
</script>
Пример 14:
<script>
var p, q, result;
p = "Love";
q = "love";
result = p!== q;
document.write(result);
</script>
Сравнение строк в JavaScript
Если оба операнда являются строками в выражении, они сравниваются как строки. Интерпретатор JavaScript сравнивает коды ASCII для каждого символа в обеих строках, такие как первый символ каждой строки, второй символ каждой строки и так далее.
Заглавная буква A представлена в ASCII числом 65, B — 66, C — 67 и так далее. Принимая во внимание, что строчная буква a представлена в ASCII-коде 97, b — 98, c — 99 и так далее.
Имейте в виду, что сравнение строк выполняется строго посимвольно, используя числовое значение каждой буквы ASCII-кода.
Давайте рассмотрим несколько важных примеров программ, основанных на сравнении строк в JavaScript.
Пример 15:
<script>
var p, q, result;
p = "A";
q = "B";
result = p > q;
document.write(result);
</script>
Вывод: false
Пример 16:
<script>
var string1 = "Apple";
var string2 = "Banana";
var result = string1 < string2;
document.write(result);
</script>
Вывод: true
Пример 17:
<script>
var string1 = "add" < "ab";
var string2 = "ad" < "ab";
var result = string1 == string2;
document.write(result);
</script>
Вывод: true
Попробуйте сами
Пример 18:
<script>
var string1 = "Dhan";
var string2 = "Dhanbad";
var result1 = string1 > string2;
document.write(result1, "<br>");
string1 = "Dhan ";
string2 = "Dhanbad";
var result2 = string1 < string2;
document.write(result2);
</script>
В этом руководстве вы изучили восемь типов операторов сравнения или отношений в JavaScript и их функции на различных примерах программ. Надеюсь, что вы поняли все основные моменты, связанные с операторами отношения, и отработали все примеры программ. В следующем руководстве мы изучим логические операторы в JavaScript на различных примерах программ.
Спасибо за чтение!!!
