From c058fa0fb22dc40ef0225b21a97578cddd0aaffa Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:51:05 +0100 Subject: unslug ru: move --- .../index.html | 286 +++++++++++++++++++++ 1 file changed, 286 insertions(+) create mode 100644 files/ru/conflicting/web/javascript/reference/operators_69135a8d5772f8b6e45265523df05d89/index.html (limited to 'files/ru/conflicting/web/javascript/reference/operators_69135a8d5772f8b6e45265523df05d89') diff --git a/files/ru/conflicting/web/javascript/reference/operators_69135a8d5772f8b6e45265523df05d89/index.html b/files/ru/conflicting/web/javascript/reference/operators_69135a8d5772f8b6e45265523df05d89/index.html new file mode 100644 index 0000000000..ee0565dc94 --- /dev/null +++ b/files/ru/conflicting/web/javascript/reference/operators_69135a8d5772f8b6e45265523df05d89/index.html @@ -0,0 +1,286 @@ +--- +title: Операторы сравнения +slug: Web/JavaScript/Reference/Operators/Операторы_сравнения +tags: + - JavaScript + - Операторы +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators +--- +
{{jsSidebar("Operators")}}
+ +

В JavaScript имеются как строгие сравнения, так и сравнения с преобразованием типа операндов. Строгие сравнения (к примеру, ===) истинны только в том случае, если типы сравниваемых значений являются одинаковыми (к примеру: string-string, number-number). Однако, чаще используются сравнения с преобразованием типов (к примеру, ==). Такой тип сравнения, перед тем как непосредственно выполнить сравнение, приводит операнды к одному типу. В случае же абстрактного реляционного сравнения, операнды сперва преобразуются в примитивы, затем приводятся к одному типу, и только после этого сравниваются.

+ +

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

+ +

Особенности сравнений:

+ + + +

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

+ +

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

+ +

Равно (==)

+ +

Оператор равно сначала приводит операнды к одному типу, и затем применяет строгое сравнение. Если оба операнда являются объектами, то JavaScript сравнивает внутренние ссылки, которые равны в том случае, если они ссылаются на один и тот же объект в памяти.

+ +

Синтаксис

+ +
x == y
+
+ +

Примеры

+ +
 1  ==  1      // истина
+"1" ==  1      // истина
+ 1  == '1'     // истина
+ 3  ==  5      // ложь
+ 0  == false   // истина
+"foo" == "bar" // ложь
+
+ +

Не равно (!=)

+ +

Оператор не равно возвращает true в том случае, если операнды не равны.Он аналогичен оператору равенства, перед сравнением приводит операнды к одному типу. В случае если оба операнда являются объектами,  JavaScript сравнивает внутренние ссылки, которые не равны в том случае, если относятся к разным объектам в памяти.

+ +

Синтаксис

+ +
x != y
+ +

Примеры

+ +
1 !=   2       // истина
+1 !=  "1"      // ложь
+1 !=  '1'      // ложь
+1 !=  true     // ложь
+0 !=  false    // ложь
+"foo" != "bar" // истина
+
+ +

Строго равно (===)

+ +

Оператор возвращает истину в том случае, если операнды строго равны (см. выше). В отличие от оператора равно, данный оператор не приводит операнды к одному типу.

+ +

Синтаксис

+ +
x === y
+ +

Примеры

+ +
3 === 3   // истина
+3 === '3' // ложь
+'foo' === 'foo' // истина
+
+ +

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

+ +

Оператор строго не равно возвращает истину в том случае, если операнды не равны, или их типы отличаются друг от друга.

+ +

Синтаксис

+ +
x !== y
+ +

Примеры

+ +
3 !== '3' // истина
+4 !== 3   // истина
+
+ +

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

+ +

Больше (>)

+ +

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

+ +

Синтаксис

+ +
x > y
+ +

Примеры

+ +
4 > 3 // истина
+1 > 5 // ложь
+
+ +

Больше или равно (>=)

+ +

Оператор больше или равно, возвращает истину в том случае, если значение операнда слева больше или равно значению операнда справа.

+ +

Синтаксис

+ +
 x >= y
+ +

Примеры

+ +
4 >= 3 // истина
+3 >= 3 // истина
+
+ +

Меньше(<)

+ +

Оператор меньше, возвращает истину в том случае, если значение операнда слева меньше, чем значение операнда справа.

+ +

Синтаксис

+ +
 x < y
+ +

Примеры

+ +
3 < 4 // истина
+5 < 2 // ложь
+
+ +

Меньше или равно (<=)

+ +

Оператор меньше или равно, возвращает истину в том случае, если значение операнда слева меньше, или равно значению операнда справа.

+ +

Синтаксис

+ +
 x <= y
+ +

Примеры

+ +
3 <= 4 // истина
+3 <= 3 // истина
+
+ +

Использование операторов равенства

+ +

Стандартные операции равенства с преобразованием типов (== и !=) используют Абстрактный Алгоритм Эквивалентного Сравнения для сравнения двух операндов. Если у операндов различные типы, то JavaScript пытается привести их к одному типу, перед тем как сравнивать их. К примеру, в выражении 5 == '5', строка справа конвертируется в число, и только потом сравнивается.

+ +

Операторы строгого равентсва (=== и !==) используют Строгий Алгоритм Эквивалентного Сравнения, и предназначены для сравнения операндов одного типа. Если операнды имеют разные типы, то результат операции сравнения всегда будет ложью. К примеру, выражение 5 !== '5' будет истинным.

+ +

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

+ +

Когда происходит преобразование типов (т.е в случаях использования нестрогого сравнения), JavaScript преобразует типы String, Number, Boolean и Object, следующим образом:

+ + + +
Внимание: Объекты String имеют тип Object, а не String. Такие объекты используются редко, так что следующий код может вас сильно удивить.
+ +
// Истина, так как оба операнда имеют тип String
+'foo' === 'foo'
+
+var a = new String('foo');
+var b = new String('foo');
+
+// Ложь, так как операнды являются объектами, внутренние ссылки которых, ссылаются на разные объекты в памяти
+a == b
+
+// Ложь, так как операнды являются объектами, внутренние ссылки которых, ссылаются на разные объекты в памяти
+a === b
+
+// Истина, так как объект a (String) будет преобразован в строку 'foo', перед сопоставлением
+a == 'foo'
+ +

Спецификации

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES1')}}{{Spec2('ES1')}}Появление в спецификации. Выполняется в JavaScript 1.0
{{SpecName('ES3')}}{{Spec2('ES3')}}Добавлены операторы === и !==. Выполняется в JavaScript 1.3
{{SpecName('ES5.1', '#sec-11.8')}}{{Spec2('ES5.1')}}Определено в нескольких секциях спецификации: Относительные операторы, Операторы равенства
{{SpecName('ES6', '#sec-relational-operators')}}{{Spec2('ES6')}}Определено в нескольких секциях спецификации: Относительные операторы, Операторы равенства
{{SpecName('ESDraft', '#sec-relational-operators')}}{{Spec2('ESDraft')}}Определено в нескольких секциях спецификации: Относительные операторы, Операторы равенства
+ +

Поддержка браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
ChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}} +

{{CompatVersionUnknown}}

+
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
AndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +


+ Смотрите также

+ + -- cgit v1.2.3-54-g00ecf