From 074785cea106179cb3305637055ab0a009ca74f2 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:52 -0500 Subject: initial commit --- .../reference/operators/addition/index.html | 80 +++ .../operators/addition_assignment/index.html | 75 +++ .../operators/arithmetic_operators/index.html | 290 ++++++++++ .../operators/array_comprehensions/index.html | 241 ++++++++ .../operators/assignment_operators/index.html | 430 ++++++++++++++ .../reference/operators/async_function/index.html | 147 +++++ .../reference/operators/await/index.html | 157 ++++++ .../reference/operators/bitwise_and/index.html | 111 ++++ .../operators/bitwise_operators/index.html | 625 +++++++++++++++++++++ .../reference/operators/class/index.html | 152 +++++ .../reference/operators/decrement/index.html | 80 +++ .../reference/operators/delete/index.html | 127 +++++ .../operators/destructuring_assignment/index.html | 339 +++++++++++ .../operators/expression_closures/index.html | 118 ++++ .../reference/operators/function/index.html | 143 +++++ .../reference/operators/function_star_/index.html | 149 +++++ .../operators/generator_comprehensions/index.html | 229 ++++++++ .../javascript/reference/operators/in/index.html | 136 +++++ .../web/javascript/reference/operators/index.html | 291 ++++++++++ .../reference/operators/instanceof/index.html | 165 ++++++ .../reference/operators/new.target/index.html | 137 +++++ .../javascript/reference/operators/new/index.html | 217 +++++++ .../nullish_coalescing_operator/index.html | 144 +++++ .../operators/object_initializer/index.html | 431 ++++++++++++++ .../operators/operator_precedence/index.html | 322 +++++++++++ .../operators/optional_chaining/index.html | 176 ++++++ .../operators/property_accessors/index.html | 203 +++++++ .../reference/operators/spread_syntax/index.html | 249 ++++++++ .../reference/operators/super/index.html | 186 ++++++ .../javascript/reference/operators/this/index.html | 412 ++++++++++++++ .../reference/operators/typeof/index.html | 242 ++++++++ .../javascript/reference/operators/void/index.html | 150 +++++ .../reference/operators/yield/index.html | 94 ++++ .../reference/operators/yield_star_/index.html | 227 ++++++++ .../index.html" | 91 +++ .../index.html" | 77 +++ .../index.html" | 299 ++++++++++ .../index.html" | 103 ++++ .../index.html" | 285 ++++++++++ .../index.html" | 66 +++ .../index.html" | 169 ++++++ 41 files changed, 8365 insertions(+) create mode 100644 files/ru/web/javascript/reference/operators/addition/index.html create mode 100644 files/ru/web/javascript/reference/operators/addition_assignment/index.html create mode 100644 files/ru/web/javascript/reference/operators/arithmetic_operators/index.html create mode 100644 files/ru/web/javascript/reference/operators/array_comprehensions/index.html create mode 100644 files/ru/web/javascript/reference/operators/assignment_operators/index.html create mode 100644 files/ru/web/javascript/reference/operators/async_function/index.html create mode 100644 files/ru/web/javascript/reference/operators/await/index.html create mode 100644 files/ru/web/javascript/reference/operators/bitwise_and/index.html create mode 100644 files/ru/web/javascript/reference/operators/bitwise_operators/index.html create mode 100644 files/ru/web/javascript/reference/operators/class/index.html create mode 100644 files/ru/web/javascript/reference/operators/decrement/index.html create mode 100644 files/ru/web/javascript/reference/operators/delete/index.html create mode 100644 files/ru/web/javascript/reference/operators/destructuring_assignment/index.html create mode 100644 files/ru/web/javascript/reference/operators/expression_closures/index.html create mode 100644 files/ru/web/javascript/reference/operators/function/index.html create mode 100644 files/ru/web/javascript/reference/operators/function_star_/index.html create mode 100644 files/ru/web/javascript/reference/operators/generator_comprehensions/index.html create mode 100644 files/ru/web/javascript/reference/operators/in/index.html create mode 100644 files/ru/web/javascript/reference/operators/index.html create mode 100644 files/ru/web/javascript/reference/operators/instanceof/index.html create mode 100644 files/ru/web/javascript/reference/operators/new.target/index.html create mode 100644 files/ru/web/javascript/reference/operators/new/index.html create mode 100644 files/ru/web/javascript/reference/operators/nullish_coalescing_operator/index.html create mode 100644 files/ru/web/javascript/reference/operators/object_initializer/index.html create mode 100644 files/ru/web/javascript/reference/operators/operator_precedence/index.html create mode 100644 files/ru/web/javascript/reference/operators/optional_chaining/index.html create mode 100644 files/ru/web/javascript/reference/operators/property_accessors/index.html create mode 100644 files/ru/web/javascript/reference/operators/spread_syntax/index.html create mode 100644 files/ru/web/javascript/reference/operators/super/index.html create mode 100644 files/ru/web/javascript/reference/operators/this/index.html create mode 100644 files/ru/web/javascript/reference/operators/typeof/index.html create mode 100644 files/ru/web/javascript/reference/operators/void/index.html create mode 100644 files/ru/web/javascript/reference/operators/yield/index.html create mode 100644 files/ru/web/javascript/reference/operators/yield_star_/index.html create mode 100644 "files/ru/web/javascript/reference/operators/\320\263\321\200\321\203\320\277\320\277\320\270\321\200\320\276\320\262\320\272\320\260/index.html" create mode 100644 "files/ru/web/javascript/reference/operators/\320\272\320\276\320\275\320\262\320\265\320\271\320\265\321\200\320\275\321\213\320\271_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200/index.html" create mode 100644 "files/ru/web/javascript/reference/operators/\320\273\320\276\320\263\320\270\321\207\320\265\321\201\320\272\320\270\320\265_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200\321\213/index.html" create mode 100644 "files/ru/web/javascript/reference/operators/\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200_\320\267\320\260\320\277\321\217\321\202\320\260\321\217/index.html" create mode 100644 "files/ru/web/javascript/reference/operators/\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200\321\213_\321\201\321\200\320\260\320\262\320\275\320\265\320\275\320\270\321\217/index.html" create mode 100644 "files/ru/web/javascript/reference/operators/\320\277\321\200\320\270\321\201\320\262\320\260\320\270\320\262\320\260\320\275\320\270\320\265/index.html" create mode 100644 "files/ru/web/javascript/reference/operators/\321\203\321\201\320\273\320\276\320\262\320\275\321\213\320\271_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200/index.html" (limited to 'files/ru/web/javascript/reference/operators') diff --git a/files/ru/web/javascript/reference/operators/addition/index.html b/files/ru/web/javascript/reference/operators/addition/index.html new file mode 100644 index 0000000000..94efb4b63e --- /dev/null +++ b/files/ru/web/javascript/reference/operators/addition/index.html @@ -0,0 +1,80 @@ +--- +title: Сложение (+) +slug: Web/JavaScript/Reference/Operators/Addition +tags: + - JavaScript + - Оператор +translation_of: Web/JavaScript/Reference/Operators/Addition +--- +
{{jsSidebar("Operators")}}
+ +

Оператор сложения (+) создает сумму числовых операндов или конкатенацию строк.

+ +
{{EmbedInteractiveExample("pages/js/expressions-addition.html")}}
+ +
+ + + +

Синтаксис

+ +
Оператор: x + y
+
+ +

Примеры

+ +

Сложение чисел

+ +
// Number + Number -> addition
+1 + 2 // 3
+
+// Boolean + Number -> addition
+true + 1 // 2
+
+// Boolean + Boolean -> addition
+false + false // 0
+
+ +

Сложение строк

+ +
// String + String -> concatenation
+'foo' + 'bar' // "foobar"
+
+// Number + String -> concatenation
+5 + 'foo' // "5foo"
+
+// String + Boolean -> concatenation
+'foo' + false // "foofalse"
+ +

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

+ + + + + + + + + + +
Спецификации
{{SpecName('ESDraft', '#sec-addition-operator-plus', 'Addition operator')}}
+ +

Совместимость с браузерами

+ + + +

{{Compat("javascript.operators.addition")}}

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/addition_assignment/index.html b/files/ru/web/javascript/reference/operators/addition_assignment/index.html new file mode 100644 index 0000000000..dfabe25e2e --- /dev/null +++ b/files/ru/web/javascript/reference/operators/addition_assignment/index.html @@ -0,0 +1,75 @@ +--- +title: Сложение с присваиванием (+=) +slug: Web/JavaScript/Reference/Operators/Addition_assignment +tags: + - JavaScript + - Оператор +translation_of: Web/JavaScript/Reference/Operators/Addition_assignment +--- +
{{jsSidebar("Operators")}}
+ +

Оператор сложения с присваиванием (+=) добавляет значение правого операнда к переменной и присваивает переменной результат. Типы двух операндов определяют поведение оператора сложения с присваиванием. Добавление или конкатенация возможны.

+ +
{{EmbedInteractiveExample("pages/js/expressions-addition-assignment.html")}}
+ +
+ + + +

Синтаксис

+ +
Оператор: x += y
+Значение: x  = x + y
+ +

Примеры

+ +

Использование сложения с присваиванием

+ +
// Assuming the following variables
+//  foo = 'foo'
+//  bar = 5
+//  baz = true
+
+// Number + Number -> addition
+bar += 2 // 7
+
+// Boolean + Number -> addition
+baz += 1 // 2
+
+// Boolean + Boolean -> addition
+baz += false // 1
+
+// Number + String -> concatenation
+bar += 'foo' // "5foo"
+
+// String + Boolean -> concatenation
+foo += false // "foofalse"
+
+// String + String -> concatenation
+foo += 'bar' // "foobar"
+ +

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

+ + + + + + + + + + +
Спецификации
{{SpecName('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}
+ +

Совместимость с браузерами

+ + + +

{{Compat("javascript.operators.addition_assignment")}}

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/arithmetic_operators/index.html b/files/ru/web/javascript/reference/operators/arithmetic_operators/index.html new file mode 100644 index 0000000000..16c83fcba5 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/arithmetic_operators/index.html @@ -0,0 +1,290 @@ +--- +title: Арифметические операции +slug: Web/JavaScript/Reference/Operators/Arithmetic_Operators +tags: + - JavaScript + - Операторы +translation_of: Web/JavaScript/Reference/Operators +--- +
+
{{jsSidebar("Operators")}}
+
+ +

Арифметические операции принимают в качестве операндов числовые значения (это может быть и литерал и переменная) и возвращают результат в виде одного числового значения. Стандартными арифметическими операциями являются сложение (+), вычитание (-), умножение (*) и деление (/).

+ +

Сложение (+)

+ +

Оператор сложения возвращает сумму числовых операндов или объединяет строки.

+ +

Синтаксис

+ +
Operator: x + y
+
+ +

Примеры

+ +
// Number + Number -> сложение
+1 + 2 // 3
+
+// Boolean + Number -> сложение
+true + 1 // 2
+
+// Boolean + Boolean -> сложение
+false + false // 0
+
+// Number + String -> конкатенация
+5 + "foo" // "5foo"
+
+// String + Boolean -> конкатенация
+"foo" + false // "foofalse"
+
+// String + String -> конкатенация
+"foo" + "bar" // "foobar"
+
+ +

Вычитание (-)

+ +

Оператор вычитания вычитает один операнд из другого и возвращает разницу.

+ +

Синтаксис

+ +
Operator: x - y
+
+ +

Примеры

+ +
5 - 3 // 2
+3 - 5 // -2
+"foo" - 3 // NaN
+ +

Деление (/)

+ +

Оператор деления производит деление его операндов, где левый операнд - делимый, а правый - делитель.

+ +

Синтаксис

+ +
Operator: x / y
+
+ +

Примеры

+ +
1 / 2      // возвращает 0.5 в JavaScript
+1 / 2      // возвращает 0 в Java
+// (так числа не с плавающими точками)
+
+1.0 / 2.0  // возвращает 0.5 и в JavaScript и в Java
+
+2.0 / 0    // возвращает Infinity в JavaScript
+2.0 / 0.0  // тоже возвращает Infinity
+2.0 / -0.0 // возвращает -Infinity в JavaScript
+ +

Умножение (*)

+ +

Оператор умножения возвращает произведение операндов.

+ +

Синтаксис

+ +
Operator: x * y
+
+ +

Примеры

+ +
2 * 2 // 4
+-2 * 2 // -4
+Infinity * 0 // NaN
+Infinity * Infinity // Infinity
+"foo" * 2 // NaN
+
+ +

Остаток от деления (%)

+ +

Оператор возвращает целый остаток от деления левого операнда на правый. Возвращаемое значение всегда получает знак делимого, а не делителя.  Он использует встроенную функцию modulo, для получения результата, которая является целочисленным остатком деления var1 на var2 — например— var1 modulo var2. Есть предложение добавить оператор modulo в будущие версии ECMAScript, с той разницей, что оператор будет брать знак делителя, а не делимого.

+ +

Синтаксис

+ +
Оператор: var1 % var2
+
+ +

Примеры

+ +
12 % 5 // 2
+-1 % 2 // -1
+NaN % 2 // NaN
+1 % 2 // 1
+2 % 3 // 2
+-4 % 2 // -0
+5.5 % 2 // 1.5
+ +

Возведение в степень (**)

+ +

Оператор возведения в степень возвращает результат первого операнда в степень. это, var1var2, в предыдущем выражении, где var1 и var2 - переменные. Он право ассоциативен. a ** b ** c равно a ** (b ** c).

+ +

Синтаксис

+ +
Оператор: var1 ** var2
+ +

Замечания

+ +

Во многих языках, таких как PHP и Python и других, есть оператор возведения возведения в степень (обычно ^ или **), оператор определён имеющим приоритет выше, чем у унарных операторов, таких как унарный + и унарный -, но есть несколько исключений. Например, в Bash оператор ** создан имеющим приоритет ниже, чем у унарных операторов. В JavaScript невозможно написать двухсмысленное выражение, т.е. вы не можете ставить унарный оператор (+/-/~/!/delete/void/typeof) непосредственно перед базовым числом.

+ +
-2 ** 2;
+// 4 в Bash, -4 в других языках.
+// Это некорректно в JavaScript, т.е. операция двухсмыслена.
+
+
+-(2 ** 2);
+// -4 в JavaScript, намерения автора однозначны.
+ +

Примеры

+ +
2 ** 3 // 8
+3 ** 2 // 9
+3 ** 2.5 // 15.588457268119896
+10 ** -1 // 0.1
+NaN ** 2 // NaN
+
+2 ** 3 ** 2 // 512
+2 ** (3 ** 2) // 512
+(2 ** 3) ** 2 // 64
+ +

Изменим знак результата возведения в степень:

+ +
-(2 ** 2) // -4
+ +

Насильная установка основания как отрицательного числа:

+ +
(-2) ** 2 // 4
+ +

Инкремент (++)

+ +

Оператор инкремента увеличивает на единицу(инкрементирует) операнд и возвращает значение.

+ + + +

Синтаксис

+ +
Оператор: x++ или ++x
+
+ +

Примеры

+ +
// Постфиксный
+var x = 3;
+y = x++; // y = 3, x = 4
+
+// Префиксный
+var a = 2;
+b = ++a; // a = 3, b = 3
+
+ +

+ +

Декремент (--)

+ +

Операция декремента уменьшает на 1 (отнимает единицу) свой операнд и возвращает значение.

+ + + +

Синтаксис

+ +
Оператор: x-- или --x
+
+ +

Примеры

+ +
// Постфиксный
+var x = 3;
+y = x--; // y = 3, x = 2
+
+// Префиксный
+var a = 2;
+b = --a; // a = 1, b = 1
+
+ +

Унарный минус (-)

+ +

Унарный минус ставится перед своим операндом и возвращает его математическое отрицание.

+ +

Синтаксис

+ +
Оператор: -x
+
+ +

Примеры

+ +
var x = 3;
+y = -x; // y = -3, x = 3
+
+ +

Унарный плюс (+)

+ +

Оператор унарный плюс предшедствует своему операнду и оценивает его, пытается преобразовать его в число, если он им не является. Хотя, унарное отрицание (-) также конвертирует не числа, унарный плюс - быстрейший и предпочитаемый способ конвертирования чего-либо в число потому, что он не выполняет каких-либо операций с числом. Он может конвертировать строковые представления целых и чисел с плавающей точкой, а также нестроковые значения true, false и null. Поддерживаются числа в десятичном и шестнадцатиричном (с префиксом "0x") формате. Отрицательные числа тоже поддерживаются (но не 16-ричные). Если он не может вычислить конкретное значение, выполнится как NaN.

+ +

Синтаксис

+ +
Оператор: +x
+
+ +

Примеры

+ +
+3     // 3
++"3"   // 3
++true  // 1
++false // 0
++null  // 0
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусПримечание
{{SpecName('ES1')}}{{Spec2('ES1')}}Изначальное определение
{{SpecName('ES5.1', '#sec-11.3')}}{{Spec2('ES5.1')}}Определено в нескольких секциях специфии: Additive operators, Multiplicative operators, Postfix expressions, Unary operators.
{{SpecName('ES6', '#sec-postfix-expressions')}}{{Spec2('ES6')}}Определено в нескольких секциях специфии: Additive operators, Multiplicative operators, Postfix expressions, Unary operators.
{{SpecName('ES7', '#sec-postfix-expressions')}}{{Spec2('ES7')}}Добавлен Оператор возведения в степень.
{{SpecName('ESDraft', '#sec-postfix-expressions')}}{{Spec2('ESDraft')}}
+ +

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

+ + + +

{{Compat("javascript.operators.arithmetic")}}

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/array_comprehensions/index.html b/files/ru/web/javascript/reference/operators/array_comprehensions/index.html new file mode 100644 index 0000000000..c2bed1585e --- /dev/null +++ b/files/ru/web/javascript/reference/operators/array_comprehensions/index.html @@ -0,0 +1,241 @@ +--- +title: Упрощенный синтаксис создания массивов +slug: Web/JavaScript/Reference/Operators/Array_comprehensions +translation_of: Archive/Web/JavaScript/Array_comprehensions +--- +
Non-standard. Do not use!
+Сокращенный синтаксис создания массивов не стандартен. В будущем используйте {{jsxref("Array.prototype.map")}}, {{jsxref("Array.prototype.filter")}}, {{jsxref("Functions/Arrow_functions", "Стрелочные функции", "", 1)}} и {{jsxref("Operators/Spread_operator", "spread syntax", "", 1)}}.
+ +
{{jsSidebar("Operators")}}
+ +

Синтаксис array comprehension - это JavaScript-выражение, которое позволяет быстро создавать новый массив из существующего. Аналогичные сокращения существуют во многих других языках программирования.

+ +

Ниже показаны различия со старым синтаксисом Array Comprehension в SpiderMonkey, основанном на черновиках для ECMAScript 4.

+ +

Синтаксис

+ +
[for (x of итерируемый_объект) x]
+[for (x of итерируемый_объект) if (условие) x]
+[for (x of итерируемый_объект) for (y of итерируемый_объект) x + y]
+
+ +

Описание

+ +

Внутри сокращения допустимо использование двух видов компонентов:

+ + + +

Итерация for-of всегда является первым компонентом. Допустимо использование нескольких for-of итераций или условных операторов if.

+ +

Сокращённый синтаксис создания массивов был предложен к стандартизации в ECMAScript 2016, он предоставлял удобный сокращения для создания новых массивов из других массивов. Сокращения могут быть использованы вместо вызовов {{jsxref("Array.prototype.map", "map()")}} и {{jsxref("Array.prototype.filter", "filter()")}} или их комбинаций.

+ +

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

+ +
var numbers = [1, 2, 3, 4];
+var doubled = [for (i of numbers) i * 2];
+console.log(doubled); // logs 2,4,6,8
+ +

Это эквивалентно следующей операции с {{jsxref("Array.prototype.map", "map()")}}:

+ +
var doubled = numbers.map(i => i * 2);
+ +

Сокращённый синтаксис может быть использован также для выбора элементов по определённому условию. Вывод четных чисел:

+ +
var numbers = [1, 2, 3, 21, 22, 30];
+var evens = [for (i of numbers) if (i % 2 === 0) i];
+console.log(evens); // logs 2,22,30
+ +

{{jsxref("Array.prototype.filter", "filter()")}} может использоваться для той же цели:

+ +
var evens = numbers.filter(i => i % 2 === 0);
+ +

Стили операторов {{jsxref("Array.prototype.map", "map()")}} и {{jsxref("Array.prototype.filter", "filter()")}} можно одновременно использовать в одном сокращённом выражении. Далее фильтруются только четные числа, а затем создаётся массив с их удвоенным значением:

+ +
var numbers = [1, 2, 3, 21, 22, 30];
+var doubledEvens = [for (i of numbers) if (i % 2 === 0) i * 2];
+console.log(doubledEvens); // logs 4,44,60
+ +

Квадратные скобки обозначают неявный блок. Новый переменные (такие как  "i" в примере выше) трактуются, как если бы они объявлялись с использованием {{jsxref("Statements/let","let")}}. Это значит, что эти переменные недоступны извне.

+ +

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

+ +

Даже строки могут подаваться на вход; можно делать то же, что с filter и map (но с массивоподобными объектами):

+ +
var str = 'abcdef';
+var consonantsOnlyStr = [for (c of str) if (!(/[aeiouAEIOU]/).test(c)) c].join(''); // 'bcdf'
+var interpolatedZeros = [for (c of str) c + '0' ].join(''); // 'a0b0c0d0e0f0'
+ +

Для предупреждения конвертации в число (в данном конкретном примере) использвалась функция {{jsxref("Array.prototype.join", "join()")}}.

+ +

Примеры

+ +

Простые сокращения

+ +
[for (i of [ 1, 2, 3 ]) i*i ];
+// [ 1, 4, 9 ]
+
+var abc = [ "A", "B", "C" ];
+[for (letters of abc) letters.toLowerCase()];
+// [ "a", "b", "c" ]
+ +

Сокращения с условным оператором "if"

+ +
var years = [ 1954, 1974, 1990, 2006, 2010, 2014 ];
+[for (year of years) if (year > 2000) year];
+// [ 2006, 2010, 2014 ]
+[for (year of years) if (year > 2000) if(year < 2010) year];
+// [ 2006], the same as below:
+[for (year of years) if (year > 2000 && year < 2010) year];
+// [ 2006]
+
+ +

Сокращения в сравнении с map и filter

+ +

Простой способ понять синтаксис Array Comprehension - это сравнить его с методами Array {{jsxref("Array.map", "map")}} и {{jsxref("Array.filter", "filter")}}:

+ +
var numbers = [ 1, 2, 3 ];
+
+numbers.map(function (i) { return i * i });
+numbers.map(i => i*i);
+[for (i of numbers) i*i ];
+// all are [ 1, 4, 9 ]
+
+numbers.filter(function (i) { return i < 3 });
+numbers.filter(i => i < 3);
+[for (i of numbers) if (i < 3) i];
+// all are [ 1, 2 ]
+
+ +

Сокращения с двумя массивами

+ +

Использование двух итераторов for-of для работы с двумя массивами:

+ +
var numbers = [ 1, 2, 3 ];
+var letters = [ "a", "b", "c" ];
+
+var cross = [for (i of numbers) for (j of letters) i+j];
+// [ "1a", "1b", "1c", "2a", "2b", "2c", "3a", "3b", "3c" ]
+
+var grid = [for (i of numbers) [for (j of letters) i+j]];
+// [
+//  ["1a", "1b", "1c"],
+//  ["2a", "2b", "2c"],
+//  ["3a", "3b", "3c"]
+// ]
+
+[for (i of numbers) if (i > 1) for (j of letters) if(j > "a") i+j]
+// ["2b", "2c", "3b", "3c"], the same as below:
+
+[for (i of numbers) for (j of letters) if (i > 1) if(j > "a") i+j]
+// ["2b", "2c", "3b", "3c"]
+
+[for (i of numbers) if (i > 1) [for (j of letters) if(j > "a") i+j]]
+// [["2b", "2c"], ["3b", "3c"]], not the same as below:
+
+[for (i of numbers) [for (j of letters) if (i > 1) if(j > "a") i+j]]
+// [[], ["2b", "2c"], ["3b", "3c"]]
+
+ +

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

+ +

Изначально было в черновике ECMAScript 2015, но исключено в ревизии 27 (Август 2014). Смотрите старые ревизии ES2015 для уточнения семантики.

+ +

Совместимость с браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatNo}}{{ CompatGeckoDesktop("30") }}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatNo}}{{CompatNo}}{{ CompatGeckoMobile("30") }}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Специфика работы SpiderMonkey

+ + + +

Отличия от старой версии JS1.7/JS1.8

+ +
Сокращения из JS1.7/JS1.8 были исключены из движка Gecko, начиная с версии 46 ({{bug(1220564)}}).
+ +

Старый синтаксис (не используйте его больше!):

+ +
[X for (Y in Z)]
+[X for each (Y in Z)]
+[X for (Y of Z)]
+ +

Различия:

+ + + +

Смотрите Bug 1220564, comment 42 для внесения предложений по коду.

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/assignment_operators/index.html b/files/ru/web/javascript/reference/operators/assignment_operators/index.html new file mode 100644 index 0000000000..aa1d42facf --- /dev/null +++ b/files/ru/web/javascript/reference/operators/assignment_operators/index.html @@ -0,0 +1,430 @@ +--- +title: Операторы присваивания +slug: Web/JavaScript/Reference/Operators/Assignment_Operators +tags: + - JavaScript + - Оператор +translation_of: Web/JavaScript/Reference/Operators#Assignment_operators +--- +
{{jsSidebar("Operators")}}
+ +

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

+ +

Описание

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ИмяСокращенный операторСмысл
Присваиваниеx = yx = y
Присваивание со сложениемx += yx = x + y
Присваивание с вычитаниемx -= yx = x - y
Присваивание с умножениемx *= yx = x * y
Присваивание с делениемx /= yx = x / y
Присваивание по модулюx %= yx = x % y
Присваивание с левым сдвигомx <<= yx = x << y
Присваивание с правым сдвигомx >>= yx = x >> y
Присваивание с беззнаковым сдвигом вправоx >>>= yx = x >>> y
Присваивание с побитовым ANDx &= yx = x & y
Присваивание с побитовым XORx ^= yx = x ^ y
Присваивание с побитовым ORx |= yx = x | y
+ +

Присваивание

+ +

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

+ +

Синтаксис

+ +
Оператор: x = y
+
+ +

Примеры

+ +
// Например, следующие переменные:
+//  x = 5
+//  y = 10
+//  z = 25
+
+x = y     // x - 10
+x = y = z // x, y и z все равны 25
+
+ +

Присваивание со сложением

+ +

Оператор добавочного присваивания, добавляет значение правого операнда к значению левого, и сохраняет результат в переменную левого операнда. Типы значений обоих операндов, определяют поведение оператора добавочного присваивания. Возможны сложение и конкатенация. Смотрите {{jsxref("Operators/Arithmetic_Operators", "addition operator", "#Addition", 1)}} для подробностей.

+ +

Синтаксис

+ +
Оператор: x += y
+Значение: x = x + y
+
+ +

Примеры

+ +
// Например, следующие переменные:
+//  foo = "foo"
+//  bar = 5
+//  baz = true
+
+// Результат исполнения каждого нижеприведенного примера
+// представлен в изоляции от предыдущих примеров (как если
+// бы значения переменных foo, bar, baz возвращались на
+// первоначальные)
+
+// Number + Number -> сложение
+bar += 2 // 7
+
+// Boolean + Number -> сложение
+baz += 1 // 2
+
+// Boolean + Boolean -> сложение
+baz += false // 1
+
+// Number + String -> конкатенация
+bar += "foo" // "5foo"
+
+// String + Boolean -> конкатенация
+foo += false // "foofalse"
+
+// String + String -> конкатенация
+foo += "bar" // "foobar"
+
+ +

Присваивание с вычитанием

+ +

Оператор вычитаемого присваивания вычитает значение правого операнда из значения левого, и присваивает результат переменной левого операнда. Смотрите {{jsxref("Operators/Arithmetic_Operators", "subtraction operator", "#Subtraction", 1)}} для подробностей.

+ +

Синтаксис

+ +
Оператор: x -= y
+Значение:  x  = x - y
+
+ +

Примеры

+ +
// Например, следующие переменные:
+//  bar = 5
+
+bar -= 2     // 3
+bar -= "foo" // NaN
+
+ +

Присваивание с умножением

+ +

The multiplication assignment operator multiplies a variable by the value of the right operand and assigns the result to the variable. See the {{jsxref("Operators/Arithmetic_Operators", "multiplication operator", "#Multiplication", 1)}} for more details.

+ +

Синтаксис

+ +
Оператор: x *= y
+Значение:  x  = x * y
+
+ +

Примеры

+ +
// Assuming the following variable
+//  bar = 5
+
+bar *= 2     // 10
+bar *= "foo" // NaN
+
+ +

Присваивание с делением

+ +

The division assignment operator divides a variable by the value of the right operand and assigns the result to the variable. See the {{jsxref("Operators/Arithmetic_Operators", "division operator", "#Division", 1)}} for more details.

+ +

Синтаксис

+ +
Оператор: x /= y
+Значение:  x  = x / y
+
+ +

Примеры

+ +
// Assuming the following variable
+//  bar = 5
+
+bar /= 2     // 2.5
+bar /= "foo" // NaN
+bar /= 0     // Infinity
+
+ +

Присваивание по модулю

+ +

The remainder assignment operator divides a variable by the value of the right operand and assigns the remainder to the variable. See the {{jsxref("Operators/Arithmetic_Operators", "remainder operator", "#Remainder", 1)}} for more details.

+ +

Синтаксис

+ +
Оператор: x %= y
+Значение:  x  = x % y
+
+ +

Примеры

+ +
// Assuming the following variable
+// bar = 5
+
+bar %= 2     // 1
+bar %= "foo" // NaN
+bar %= 0     // NaN
+
+ +

Присваивание с левым сдвигом

+ +

The left shift assignment operator moves the specified amount of bits to the left and assigns the result to the variable. See the {{jsxref("Operators/Bitwise_Operators", "left shift operator", "#Left_shift", 1)}} for more details.

+ +

Синтаксис

+ +
Оператор: x <<= y
+Значение:  x   = x << y
+
+ +

Примеры

+ +
var bar = 5; //  (00000000000000000000000000000101)
+bar <<= 2; // 20 (00000000000000000000000000010100)
+
+ +

Присваивание с правым сдвигом

+ +

The right shift assignment operator moves the specified amount of bits to the right and assigns the result to the variable. See the {{jsxref("Operators/Bitwise_Operators", "right shift operator", "#Right_shift", 1)}} for more details.

+ +

Синтаксис

+ +
Оператор: x >>= y
+Значение:  x   = x >> y
+
+ +

Примеры

+ +
var bar = 5; //   (00000000000000000000000000000101)
+bar >>= 2;   // 1 (00000000000000000000000000000001)
+
+var bar -5; //    (-00000000000000000000000000000101)
+bar >>= 2;  // -2 (-00000000000000000000000000000010)
+
+ +

Присваивание с беззнаковым сдвигом вправо

+ +

The unsigned right shift assignment operator moves the specified amount of bits to the right and assigns the result to the variable. See the {{jsxref("Operators/Bitwise_Operators", " unsigned right shift operator", "#Unsigned_right_shift", 1)}} for more details.

+ +

Синтаксис

+ +
Оператор: x >>>= y
+Значение:  x    = x >>> y
+
+ +

Примеры

+ +
var bar = 5; //   (00000000000000000000000000000101)
+bar >>>= 2;  // 1 (00000000000000000000000000000001)
+
+var bar = -5; // (-00000000000000000000000000000101)
+bar >>>= 2; // 1073741822 (00111111111111111111111111111110)
+ +

Присваивание с побитовым AND

+ +

The bitwise AND assignment operator uses the binary representation of both operands, does a bitwise AND operation on them and assigns the result to the variable. See the {{jsxref("Operators/Bitwise_Operators", "bitwise AND operator", "#Bitwise_AND", 1)}} for more details.

+ +

Синтаксис

+ +
Оператор: x &= y
+Значение:  x  = x & y
+
+ +

Примеры

+ +
var bar = 5;
+// 5:     00000000000000000000000000000101
+// 2:     00000000000000000000000000000010
+bar &= 2; // 0
+
+ +

Присваивание с побитовым XOR

+ +

Побитовый оператор присваивания XOR использует двоичное представление обоих операндов, выполняет побитовую XOR-операцию и присваивает результат переменной. Для получения более подробной информации см. {{jsxref("Operators/Bitwise_Operators", "Побитовый оператор XOR", "#Bitwise_XOR", 1)}}.

+ +

Синтаксис

+ +
Оператор: x ^= y
+Значение:  x  = x ^ y
+
+ +

Примеры

+ +
var bar = 5;
+bar ^= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+
+ +

Присваиванием с побитовым OR

+ +

Побитовый оператор присваивания OR использует двоичное (бинарное) представление обоих операндов, выполняет побитовое ИЛИ для них и присваивает результат переменной. Дополнительную информацию см. {{jsxref("Operators/Bitwise_Operators", "Побитовый оператор OR", "#Bitwise_OR", 1)}}.

+ +

Синтаксис

+ +
Оператор: x |= y
+Значение:  x  = x | y
+
+ +

Примеры

+ +
var bar = 5;
+bar |= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+
+ +

Примеры

+ +

Левый операнд с другим оператором присваивания

+ +

В необычных ситуациях оператор присваивания, например, x += y не идентичен выражению, x = x + y. Когда левый операнд оператора присваивания содержит оператор присваивания, левый операнд оценивается только один раз. Например:

+ +
a[i++] += 5         // i оценивается только один раз
+a[i++] = a[i++] + 5 // i оценивается дважды
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
ECMAScript 1-е издание.СтандартИзначальное определение.
{{SpecName('ES5.1', '#sec-11.13', 'Операторы присваивания')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-assignment-operators', 'Операторы присваивания')}}{{Spec2('ES6')}} 
+ +

Совместимость с браузерами

+ +

{{ 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() }}
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/async_function/index.html b/files/ru/web/javascript/reference/operators/async_function/index.html new file mode 100644 index 0000000000..9b9c72aba1 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/async_function/index.html @@ -0,0 +1,147 @@ +--- +title: async function expression +slug: Web/JavaScript/Reference/Operators/async_function +translation_of: Web/JavaScript/Reference/Operators/async_function +--- +
{{jsSidebar("Operators")}}
+ +

Ключевое слово async function исползуется для определения асинхронной функции внутри выражений.

+ +

Вы также можете определить асинхронные функции при помощи инструкции async function.

+ +

Синтаксис

+ +
async function [name]([param1[, param2[, ..., paramN]]]) {
+   statements
+}
+ +

Согласно спецификации ES2015, вы также можете использовать стрелочные функции.

+ +

Параметры

+ +
+
name
+
Имя функции. Этот параметр может быть опущен, в этом случае говорят об анонимной функции. Имя используется только в теле функции.
+
paramN
+
Имя аргумента, передаваемого функции.
+
statements
+
Инструкции, составляющие тело функции.
+
+ +

Описание

+ +

Выражение async function очень похоже, и имеет почти тот же синтаксис, что и {{jsxref('Statements/async_function', 'async function statement')}}. Главное отличие между выражениями async function и объявлениями async function заключается в имени функции, которое может быть опущено в выражении async function для создания анонимной функции. Выражение async function можно использовать в виде {{Glossary("IIFE")}} (Immediately Invoked Function Expression), и оно будет запущено сразу после объявления. См. также главу о функциях.

+ +

Примеры

+ +

Простой пример

+ +
function resolveAfter2Seconds(x) {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve(x);
+    }, 2000);
+  });
+};
+
+(async function(x) { // выражение асинхронной функции в виде IIFE
+  var a = resolveAfter2Seconds(20);
+  var b = resolveAfter2Seconds(30);
+  return x + await a + await b;
+})(10).then(v => {
+  console.log(v);  // выведет 60 после 2 секунд.
+});
+
+var add = async function(x) { // назначение выражения асинхронной функции переменной
+  var a = await resolveAfter2Seconds(20);
+  var b = await resolveAfter2Seconds(30);
+  return x + a + b;
+};
+
+add(10).then(v => {
+  console.log(v);  // выведет 60 после 4 секунд.
+});
+
+ +

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

+ + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ESDraft', '#sec-async-function-definitions', 'async function')}}{{Spec2('ESDraft')}}Initial definition in ES2017.
+ +

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

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet Explorer EdgeOperaSafari (WebKit)
Basic support{{CompatChrome(55)}}{{CompatGeckoDesktop("52.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatOpera(42)}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile("52.0")}}{{CompatUnknown}}{{CompatOpera(42)}}{{CompatUnknown}}{{CompatChrome(55)}}
+
+ +

Смотри также

+ + diff --git a/files/ru/web/javascript/reference/operators/await/index.html b/files/ru/web/javascript/reference/operators/await/index.html new file mode 100644 index 0000000000..ecce9884c5 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/await/index.html @@ -0,0 +1,157 @@ +--- +title: await +slug: Web/JavaScript/Reference/Operators/await +translation_of: Web/JavaScript/Reference/Operators/await +--- +
{{jsSidebar("Operators")}}
+ +

Оператор await используется для ожидания окончания {{jsxref("Promise")}}. Может быть использован только внутри {{jsxref("Statements/async_function", "async function")}}.

+ +

Синтаксис

+ +
[rv] = await expression;
+ +
+
expression
+
{{jsxref("Promise")}} или любое другое значение для ожидания разрешения.
+
rv
+
+

Возвращает полученное из Promise значение, либо само значение, если оно не является Promise.

+
+
+ +

Описание

+ +

Оператор await заставляет функцию, объявленную с использованием оператора async, ждать выполнения Promise и продолжать выполнение после возвращения Promise значения. Впоследствии возвращает полученное из  Promise значение. Если типом значения, к которому был применен оператор await, является не Promise, то значение приводится к успешно выполненному Promise.

+ +

Если Promise отклоняется, то await генерирует исключение с отклонённым значением.

+ +

Примеры

+ +

await ожидает разрешения Promise и возвращает полученное значение.

+ +
function resolveAfter2Seconds(x) {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve(x);
+    }, 2000);
+  });
+}
+
+async function f1() {
+  var x = await resolveAfter2Seconds(10);
+  console.log(x); // 10
+}
+f1();
+
+ +

Если типом значения является не Promise, значение преобразуется к успешно выполненному Promise.

+ +
async function f2() {
+  var y = await 20;
+  console.log(y); // 20
+}
+f2();
+
+ +

Если Promise отклонен, то выбрасывается исключение с переданным значением.

+ +
async function f3() {
+  try {
+    var z = await Promise.reject(30);
+  } catch(e) {
+    console.log(e); // 30
+  }
+}
+f3();
+ +

Обработка отклонённого Promise без try/catch блока.

+ +
var response = await promisedFunction().catch((err) => { console.log(err); });
+// response получит значение undefined, если Promise будет отклонён
+
+ +

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

+ + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ESDraft', '#sec-async-function-definitions', 'async functions')}}{{Spec2('ESDraft')}}Initial definition in ES2017.
+ +

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

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Basic support{{CompatChrome(55)}}{{CompatVersionUnknown}}{{CompatGeckoDesktop("52.0")}}{{CompatUnknown}}{{CompatOpera(42)}}10.1
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewEdgeFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("52.0")}}{{CompatUnknown}}{{CompatOpera(42)}}10.1{{CompatChrome(55)}}
+
+ +

See also

+ + diff --git a/files/ru/web/javascript/reference/operators/bitwise_and/index.html b/files/ru/web/javascript/reference/operators/bitwise_and/index.html new file mode 100644 index 0000000000..ce232c1463 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/bitwise_and/index.html @@ -0,0 +1,111 @@ +--- +title: Bitwise AND (&) +slug: Web/JavaScript/Reference/Operators/Bitwise_AND +tags: + - JavaScript + - Оператор + - По + - Поитовые операторы +translation_of: Web/JavaScript/Reference/Operators/Bitwise_AND +--- +
{{jsSidebar("Operators")}}
+ +

Побитовый опеератор И (&) возвращает 1 в каждой битовой позиции,  для которой соответствующие биты обоих операндов равны 1.

+ +
{{EmbedInteractiveExample("pages/js/expressions-bitwise-and.html")}}
+ + + +

Синтаксис

+ +
a & b
+
+ +

Описание

+ +

Операнды преобразуются в  32-битные целые числа и выражаются серией битов (нулей and единиц). Числа с более чем 32 битами отбрасывают старшие разряды. Например, следующее целое число  с более чем 32 битами будет преобразовано в 32-биитное целое:

+ +
До: 11100110111110100000000000000110000000000001
+После:          10100000000000000110000000000001
+ +

Каждый бит в первом операнде связан с соответствующим битом во втором операнде:первый бит - с первым,второй- со вторым, и т.д.

+ +

Оператор применяется к каждой паре битов, и результат строится побитово.

+ +

Таблица истинности для оператора И:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba И b
000
010
100
111
+ +
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
+
+ +

Побитовоее И для любого числа x с 0 дает 0.

+ +

Примеры

+ +

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

+ +
// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+5 & 2; // 0
+ +

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

+ + + + + + + + + + + + +
Спецификация
{{SpecName('ESDraft', '#prod-BitwiseANDExpression', 'Bitwise AND expression')}}
+ +

Браузерная совместимость

+ + + +

{{Compat("javascript.operators.bitwise_and")}}

+ +

См. также

+ + diff --git a/files/ru/web/javascript/reference/operators/bitwise_operators/index.html b/files/ru/web/javascript/reference/operators/bitwise_operators/index.html new file mode 100644 index 0000000000..e681bdf40b --- /dev/null +++ b/files/ru/web/javascript/reference/operators/bitwise_operators/index.html @@ -0,0 +1,625 @@ +--- +title: Битовые операции +slug: Web/JavaScript/Reference/Operators/Bitwise_Operators +tags: + - JavaScript + - Оператор +translation_of: Web/JavaScript/Reference/Operators +--- +
{{jsSidebar("Operators")}}
+ +

Сводка

+ +

Битовые операции обращаются со своими операндами как с 32-х разрядными последовательностями нулей и единиц, а не как с десятичными, восьмеричными или шестнадцатиричными числами. К примеру десятичное число 9 в двоичном представлении будет выглядеть как 1001. Битовые операции производят свои преобразования именно с двоичным представлением числа, но возвращают стандартные числовые значения языка JavaScript.

+ + + + + + + + + + + + + + + +
Операторы
Реализованы в:JavaScript 1.0
Версия ECMA:ECMA-262
+ +

Следующая таблица содержит сводные данные о битовых операциях в JavaScript:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ОператорИспользованиеОписание
Побитовое Иa & bВозвращает 1 в тех разрядах, которые у обоих операндов были равны 1.
Побитовое ИЛИa | bВозвращает 1 в тех разрядах, которые хотя бы у одного из операндов были равны 1.
Побитовое исключающее ИЛИa ^ bВозвращает 1 в тех позициях, которые только у одного из операндов были равны 1.
Побитовое НЕ~ aИнвертирует биты операнда.
Сдвиг влевоa << bСдвигает двоичное представление числа a на b разрядов влево заполняя освободившиеся справа разряды нулями.
Арифметический сдвиг вправоa >> bСдвигает двоичное представление числа a на b разрядов вправо. Освобождающиеся разряды заполняются  знаковым битом.
Логический сдвиг вправоa >>> bСдвигает двоичное представление числа a на b разрядов вправо. Освобождающиеся разряды заполняются нулями.
+ +

Представление чисел (Signed 32-bit integers)

+ +

Операнды всех битовых операций конвертируются в 32-х битовые целые со знаком представленные в дополнительном коде и с использованием порядка битов от "старшего к младшему". Порядок битов "от старшего к младшему" означает, что наиболее значимый бит (бит с наибольшим значением) находится слева если 32-х разрядное число представлено в виде горизонтальной линии (шкалы). Представление в дополнительном коде  означает, что отрицательное значение числа (например 5 и -5) получается путем инвертирования числа (операция "побитовое НЕ", также известное как "обратный код") и прибавления к нему единицы.

+ +

Возьмем, к примеру, число 314. Представим его в двоичном коде:

+ +
00000000000000000000000100111010
+
+ +

Следующая строка представляет собой его обратный код или ~314:

+ +
11111111111111111111111011000101
+
+ +

Прибавив к нему единицу, мы получаем двоичное представление числа  -314, оно же 314 в дополнительном коде:

+ +
11111111111111111111111011000110
+ +

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

+ +


+ Число 0 есть число, у которого во ввсех битовых позициях записаны нули.

+ +
0 (base 10) = 00000000000000000000000000000000
+ +

Число -1 есть число, у которого во всех битовых позициях записаны единицы.

+ +
-1 (base 10) = 11111111111111111111111111111111
+ +

Число -2147483648 (в шестнадцатиричной системе счисления: -0x80000000) - это вещественное число, которое состоит только из 0, заисключением самого первого слева, который есть 1 (отвечает за знак числа).

+ +
-2147483648 (base 10) = 10000000000000000000000000000000
+ +

Число 2147483648 (в шестнадцатиричной системе счисления: 0x80000000) - это вещественное число, которое состоит только из 1, заисключением самого первого слева, который есть 0 (отвечает за знак числа).

+ +
2147483647 (base 10) = 01111111111111111111111111111111
+ +

-2147483648 и 2147483647 - это самое минимальное и самое максимальное числа, которые можно представить в 32 разрядной ячейке памяти.

+ +

Побитовые логические операции

+ +

Побитовые логические операции работают следующим образом:

+ + + +
До:         11100110111110100000000000000110000000000001
+После:      10100000000000000110000000000001
+
+ + + +

& (Побитовое AND)

+ +

Производит побитовое И над каждой парой битов. Операция a AND b веренет 1 если только и a и b равны 1. Таблица истинности для этой операции выглядит так:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba AND b
000
010
100
111
+ +

Пример:

+ +
     9 (основание 10) = 00000000000000000000000000001001 (основание 2)
+    14 (основание 10) = 00000000000000000000000000001110 (основание 2)
+                   --------------------------------
+14 & 9 (основание 10) = 00000000000000000000000000001000 (осн. 2) = 8 (осн. 10)
+
+ +

Побитовое  AND любого числа x с нулем вернет 0.

+ +

Побитовое  AND любого числа x с числом -1 вернет х.

+ +

| (Побитовое OR)

+ +

Производит побитовое ИЛИ над каждой парой битов. Операция a OR b веренет 1 если a или b равны 1. Таблица истинности для этой операции выглядит так:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba OR b
000
011
101
111
+ +
Пример:
+
+9 (осн. 10) = 00000000000000000000000000001001 (осн. 2)
+14 (осн. 10) = 00000000000000000000000000001110 (осн. 2)
+                   --------------------------------
+14 | 9 (осн. 10) = 00000000000000000000000000001111 (осн. 2) = 15 (осн. 10)
+
+ +

Побитовое OR любого числа x c нулем вернет x.

+ +

Побитовое OR любого числа x с числом -1 вернет -1.

+ +

^ (Побитовое XOR)

+ +

Производит побитовое XOR над каждой парой битов. Операция a XOR b вернет 1 если a  и b различны. Таблица истинности для этой операции выглядит так:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba XOR b
000
011
101
110
+ +

Пример:

+ +
     9 (осн. 10) = 00000000000000000000000000001001 (осн. 2)
+    14 (осн. 10) = 00000000000000000000000000001110 (осн. 2)
+                   --------------------------------
+14 ^ 9 (осн. 10) = 00000000000000000000000000000111 (осн. 2) = 7 (осн. 10)
+
+ +

Побитовое XOR любого числа x c нулем вернет x.

+ +

Побитовое XOR любого числа x c числом -1 вернет ~x.

+ +

~ (Побитовое NOT)

+ +

Производит операцию NOT над каждым битом. NOT a вернет побитово инвертированное значение (обратный код) операнда. Таблица истинности для этой операции выглядит так:

+ + + + + + + + + + + + + + + + +
aNOT a
01
10
+ +

Пример:

+ +
 9 (осн. 10) = 00000000000000000000000000001001 (осн. 2)
+               --------------------------------
+~9 (осн. 10) = 11111111111111111111111111110110 (осн. 2) = -10 (осн. 10)
+
+ +

Побитовое NOT любого числа x вернет -(x + 1). Например, ~5 вернет -6.

+ +

Побитовые операции сдвига

+ +

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

+ +

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

+ +

<< (Сдвиг влево)

+ +

Оператор побитового сдвига влево сдвигает первый операнд на заданное число битов влево. Лишние биты отбрасываются.

+ +

Например, 9 << 2 в результате даст 36:

+ +
     9 (осн. 10): 00000000000000000000000000001001 (осн. 2)
+                  --------------------------------
+9 << 2 (осн. 10): 00000000000000000000000000100100 (осн. 2) = 36 (осн. 10)
+
+
+
+ +

Побитовй сдвиг любого числа x влево на y бит в результате дает  x * 2 ** y.

+ +

>> (Сдвиг вправо с сохранением знака)

+ +

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

+ +

Например, 9 >> 2 в результате даст 2:

+ +
     9 (осн. 10): 00000000000000000000000000001001 (осн. 2)
+                  --------------------------------
+9 >> 2 (осн. 10): 00000000000000000000000000000010 (осн. 2) = 2 (осн. 10)
+
+ +

Аналогично, -9 >> 2 даст в результате  -3, так как знак сохранен:

+ +
     -9 (осн. 10): 11111111111111111111111111110111 (осн. 2)
+                   --------------------------------
+-9 >> 2 (осн. 10): 11111111111111111111111111111101 (осн. 2) = -3 (осн. 10)
+
+ +

>>> (Сдвиг вправо с заполнением нулями)

+ +

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

+ +

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

+ +

Например, 9 >>> 2 дает в результате 2, как и 9 >> 2:

+ +
      9 (осн. 10): 00000000000000000000000000001001 (осн. 2)
+                   --------------------------------
+9 >>> 2 (осн. 10): 00000000000000000000000000000010 (осн. 2) = 2 (осн. 10)
+
+ +

Важно отметить, что для отрицательных результаты будут разными. Например, -9 >>> 2 дает в результате 1073741821, что отличается от результата -9 >> 2 (равно -3):

+ +
      -9 (осн. 10): 11111111111111111111111111110111 (осн. 2)
+                    --------------------------------
+-9 >>> 2 (осн. 10): 00111111111111111111111111111101 (осн. 2) = 1073741821 (осн. 10)
+
+ +

Примеры

+ +

Пример: флаги и битовые маски

+ +

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

+ +

Предположим, существует 4 флага:

+ + + +

Эти флаги представлены последовательностью битов: DCBA. Считается, что флаг установлен (the flag is set), если его значение равно 1. Флаг сброшен (the flag is cleared), если его значение равно 0. Предположим, что переменная flags содержит двоичное значение 0101:

+ +
var flags = 0x5;   // двоичное 0101
+
+ +

Из этого значения следует:

+ + + +

Так как битовые операторы 32-битные, то 0101 в действительности представлено значением 00000000000000000000000000000101, но ведущие нули могут быть опущены, потому, что не содержат значимой информации.

+ +

Битовая маска, это последовательность битов, которая позволяет манипулировать и/или считывать значения флагов. Обычно для каждого флага задаётся "примитивная" битовая маска:

+ +
var FLAG_A = 0x1; // 0001
+var FLAG_B = 0x2; // 0010
+var FLAG_C = 0x4; // 0100
+var FLAG_D = 0x8; // 1000
+
+ +

New bitmasks can be created by using the bitwise logical operators on these primitive bitmasks. For example, the bitmask 1011 can be created by ORing FLAG_A, FLAG_B, and FLAG_D:

+ +
var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011
+
+ +

Individual flag values can be extracted by ANDing them with a bitmask, where each bit with the value of one will "extract" the corresponding flag. The bitmask masks out the non-relevant flags by ANDing with zeros (hence the term "bitmask"). For example, the bitmask 0100 can be used to see if flag C is set:

+ +
// if we own a cat
+if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true
+   // do stuff
+}
+
+ +

A bitmask with multiple set flags acts like an "either/or". For example, the following two are equivalent:

+ +
// if we own a bat or we own a cat
+if ((flags & FLAG_B) || (flags & FLAG_C)) { // (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
+   // do stuff
+}
+
+ +
// if we own a bat or cat
+var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110
+if (flags & mask) { // 0101 & 0110 => 0100 => true
+   // do stuff
+}
+
+ +

Flags can be set by ORing them with a bitmask, where each bit with the value one will set the corresponding flag, if that flag isn't already set. For example, the bitmask 1010 can be used to set flags C and D:

+ +
// yes, we own a cat and a duck
+var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100
+flags |= mask;   // 0101 | 1100 => 1101
+
+ +

Flags can be cleared by ANDing them with a bitmask, where each bit with the value zero will clear the corresponding flag, if it isn't already cleared. This bitmask can be created by NOTing primitive bitmasks. For example, the bitmask 1010 can be used to clear flags A and C:

+ +
// no, we don't neither have an ant problem nor own a cat
+var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010
+flags &= mask;   // 1101 & 1010 => 1000
+
+ +

The mask could also have been created with ~FLAG_A & ~FLAG_C (De Morgan's law):

+ +
// no, we don't have an ant problem, and we don't own a cat
+var mask = ~FLAG_A & ~FLAG_C;
+flags &= mask;   // 1101 & 1010 => 1000
+
+ +

Flags can be toggled by XORing them with a bitmask, where each bit with the value one will toggle the corresponding flag. For example, the bitmask 0110 can be used to toggle flags B and C:

+ +
// if we didn't have a bat, we have one now, and if we did have one, bye-bye bat
+// same thing for cats
+var mask = FLAG_B | FLAG_C;
+flags = flags ^ mask;   // 1100 ^ 0110 => 1010
+
+ +

Finally, the flags can all be flipped with the NOT operator:

+ +
// entering parallel universe...
+flags = ~flags;    // ~1010 => 0101
+
+
+ +

Совместимость с браузерами

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Битовый NOT (~){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Битовый AND (&){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Битовый OR (|){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Битовый XOR (^){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Сдвиг влево (<<){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Сдвиг вправо (>>){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Беззнаковый сдвиг вправо (>>>){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Битовый NOT (~){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Битовый AND (&){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Битовый OR (|){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Битовый XOR (^){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Сдвиг влево (<<){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Сдвиг вправо (>>){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
Беззнаковый сдвиг вправо (>>>){{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/class/index.html b/files/ru/web/javascript/reference/operators/class/index.html new file mode 100644 index 0000000000..ad22c1abc1 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/class/index.html @@ -0,0 +1,152 @@ +--- +title: class expression +slug: Web/JavaScript/Reference/Operators/class +translation_of: Web/JavaScript/Reference/Operators/class +--- +
{{jsSidebar("Operators")}}
+ +
+ +

Class expression это способ определения класса в ECMAScript 2015 (ES6). Схожий с function expressions, class expressions может быть именованным либо не иметь имени. Если он именованный, то его имя доступно только внутри класса. JavaScript классы используют прототипно-ориентированние наследование.

+ +

Синтаксис

+ +
var MyClass = class [className] [extends] {
+  // тело класса
+};
+ +

Описание

+ +

Class expression имеет схожий сиснтаксис с {{jsxref("Statements/class", "class declaration (statement)", "", "true")}}. Однако в class expression можно опустить имя класса ("binding identifier"), что не допустимо с {{jsxref("Statements/class", "class declaration", "", "true")}}. Также class expression позволяет повторно объявить уже существующий класс и это не приведёт к ошибке типа, как при использовании {{jsxref("Statements/class", "class declaration", "", "true")}}. Свойство конструктора является опциональным. Результатом вызова оператора {{jsxref("Operators/typeof", "typeof")}} на классах, сгенерированных при помощи class expression, всегда будет "function".

+ +

Так же, как и при использовании class declaration, тело класса у class expression будет исполняться в {{jsxref("Strict_mode", "строгом режиме", "", 1)}}.

+ +
'use strict';
+var Foo = class {}; // свойство конструктора опционально
+var Foo = class {}; // повторное объявление разрешено
+
+typeof Foo; // возвращает "function"
+typeof class {}; // возвращает "function"
+
+Foo instanceof Object; // true
+Foo instanceof Function; // true
+class Foo {}; // Throws TypeError, doesn't allow re-declaration
+
+ +

Примеры

+ +

Простой class expression

+ +

Простой анонимный class expression, на который можно сослаться с помощью переменной "Foo".

+ +
var Foo = class {
+  constructor() {}
+  bar() {
+    return "Hello World!";
+  }
+};
+
+var instance = new Foo();
+instance.bar(); // "Hello World!"
+Foo.name; // "Foo"
+
+ +

Именованный class expression

+ +

Если вы хотите сослаться на конкретный класс внутри тела класса, вы можете создать именованный class expression. Это имя будет доступно только внутри области видимости самого class expression.

+ +
var Foo = class NamedFoo {
+  constructor() {}
+  whoIsThere() {
+    return NamedFoo.name;
+  }
+}
+var bar = new Foo();
+bar.whoIsThere(); // "NamedFoo"
+NamedFoo.name; // ReferenceError: NamedFoo is not defined
+Foo.name; // "NamedFoo"
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES6', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ES6')}}Первоначальное определение
{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ESDraft')}}
+ +

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

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome(42.0)}}{{CompatGeckoDesktop(45)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatNo}}{{CompatChrome(42.0)}}{{CompatGeckoMobile(45)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatChrome(42.0)}}
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/decrement/index.html b/files/ru/web/javascript/reference/operators/decrement/index.html new file mode 100644 index 0000000000..722d4a5889 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/decrement/index.html @@ -0,0 +1,80 @@ +--- +title: Декремент (--) +slug: Web/JavaScript/Reference/Operators/Decrement +tags: + - Декремент + - Оператор +translation_of: Web/JavaScript/Reference/Operators/Decrement +--- +
{{jsSidebar("Operators")}}
+ +

Оператор декремента (--) уменьшает (вычитает единицу) свой операнд и возвращает значение.

+ +
{{EmbedInteractiveExample("pages/js/expressions-decrement.html")}}
+ +
+ + + +

Синтаксис

+ +
Operator: x-- or --x
+
+ +

Описание

+ +

Если используется постфикс, с оператором после операнда (например, x--), оператор декремента уменьшает и возвращает значение перед уменьшением.

+ +

Если используется префикс, с оператором перед операндом (например, --x), оператор декремента уменьшает и возвращает значение после уменьшения.

+ +

Примеры

+ +

Постфиксный декремент

+ +
let x = 3;
+y = x--;
+
+// y = 3
+// x = 2
+
+ +

Префиксный декремент

+ +
let a = 2;
+b = --a;
+
+// a = 1
+// b = 1
+
+ +

Характеристики

+ +

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

+ + + + + + + +
{{SpecName('ESDraft', '#sec-postfix-decrement-operator', 'Decrement operator')}}
+ +

Совместимость с браузером

+ + + +

{{Compat("javascript.operators.decrement")}}

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/delete/index.html b/files/ru/web/javascript/reference/operators/delete/index.html new file mode 100644 index 0000000000..2edf33b67e --- /dev/null +++ b/files/ru/web/javascript/reference/operators/delete/index.html @@ -0,0 +1,127 @@ +--- +title: delete +slug: Web/JavaScript/Reference/Operators/delete +translation_of: Web/JavaScript/Reference/Operators/delete +--- +
{{jsSidebar("Operators")}}
+ +

Аннотация

+ +

Оператор delete удаляет свойство из объекта.

+ + + + + + + + + + + + + + + + + +
Оператор
Реализован в:JavaScript 1.2
Версия ECMAScript:ECMA-262 1-ый выпуск
+ +

Синтаксис

+ +

delete выражение

+ +

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

+ +
delete object.property
+delete object['property']
+delete object[index]
+delete property // удаляет свойства глобального объекта, или,
+                // используя инструкцию with, свойства объекта, на который ссылается инструкция
+
+ +

Если результат вычисления выражения не является свойством (объекта), delete ничего не делает.

+ +

Параметры

+ +
+
object
+
Имя объекта или выражение, результатом вычисления которого является объект.
+
property
+
Удаляемое свойство.
+
index
+
Целое число, представляющее собой индекс массива, который должен быть удален.
+
+ +

Возвращаемое значение

+ +

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

+ +

Описание

+ +

Если оператор delete успешно выполняет удаление, он полностью удаляет свойство из объекта. Однако, если свойство с таким же именем существует в цепочке прототипов, объект унаследует это свойство из прототипа.

+ +

delete эффективен только применительно к свойствам объектов. Он не оказывает никакого влияния на имена переменных и функций.
+ Присвоение значения свойству без указания объекта (без оператора var) иногда неверно характеризуется, как глобальная переменная, (например x = 5). На самом деле происходит присвоение значения свойству глобального объекта.

+ +

delete не может удалить определенные свойства встроенных объектов (таких как Object, Array, Math и так далее). В спецификации ECMA-262 они обозначены как DontDelete.

+ +
x = 42;         // создает свойство x в глобальном объекте
+var y = 43;     // объявляет новую переменную, y
+myobj = {};
+myobj.h = 4;    // создает свойство h в myobj
+myobj.k = 5;    // создает свойство k в myobj
+
+delete x;       // возвращает true  (x - свойство глобального объекта и может быть удалено)
+delete y;       // возвращает false (delete не влияет на имена переменных)
+delete Math.PI; // возвращает false (delete не влияет на определенные встроенные свойства)
+delete myobj.h; // возвращает true  (свойства, определенные пользователем могут быть удалены)
+
+with(myobj) {
+    delete k;   // возвращает true  (эквивалентно delete myobj.k)
+}
+
+delete myobj;   // возвращает true  (myobj это свойство глобального объекта, не переменная, поэтому может быть удалено)
+ +

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

+ +
function Foo(){}
+Foo.prototype.bar = 42;
+var foo = new Foo();
+delete foo.bar;           // возвращает true, но безрезультатно, так как bar - наследуемое свойство
+alert(foo.bar);           // выводит 42, свойство все еще наследуется
+delete Foo.prototype.bar; // удаляет свойство из прототипа
+alert(foo.bar);           // выводит "undefined", свойство больше не наследуется
+ +

Удаление элементов массива

+ +

Когда с помощью оператора delete удаляется элемент массива, длина массива не меняется. Например, если Вы удалите a{{ mediawiki.external(3) }}, a{{ mediawiki.external(4) }} по прежнему a{{ mediawiki.external(4) }}, а a{{ mediawiki.external(3) }} не определено. Так будет даже если Вы удалите последний элемент массива (delete a{{ mediawiki.external('a.length-1') }}).

+ +

Когда оператор delete удаляет элемент массива, этот элемент больше не существует в массиве. В следующем примере, trees{{ mediawiki.external(3) }} удаляется с помощью delete.

+ +
var trees = ["redwood","bay","cedar","oak","maple"];
+
+delete trees[3];
+if (3 in trees) {
+    // этот участок кода не выполнится
+}
+ +

Если Вы хотите, чтобы элемент массива существовал, но имел значение undefined, используйте значение undefined вместо оператора delete. В следующем примере, trees{{ mediawiki.external(3) }} принимает значение undefined, но элемент массива все еще существует:

+ +
var trees = ["redwood","bay","cedar","oak","maple"];
+trees[3]=undefined;
+if (3 in trees) {
+    // этот участок кода выполнится
+}
+ +

Проблема кроссбраузерности

+ +

Несмотря на то, что стандарт ECMAScript оставляет порядок итерации по свойствам объектов на усмотрение реализующей стороны, может оказаться так, что все основные браузеры поддерживают порядок итерации, основанный на принципе "свойство добавленное в объект раньше идет раньше" (по крайней мере для свойств не находящихся в прототипе). Однако, в случае с Internet Explorer, когда кто-нибудь использует delete с каким-либо свойством, это приводит к некоторым неожиданным результатам, заставляя другие браузеры отказаться от использования простых объектов, таких как литералы объектов, в качестве ассоциативных массивов. В Internet Explorer, когда значение свойства установлено в undefined, после удаления этого свойства, если кто-нибудь позже добавит свойство с таким же именем, оно окажется в своей старой позиции, а не в конце итерационной последовательности, как ожидается.

+ +

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

+ +

Внешние ссылки

+ + diff --git a/files/ru/web/javascript/reference/operators/destructuring_assignment/index.html b/files/ru/web/javascript/reference/operators/destructuring_assignment/index.html new file mode 100644 index 0000000000..29cdd9cd7f --- /dev/null +++ b/files/ru/web/javascript/reference/operators/destructuring_assignment/index.html @@ -0,0 +1,339 @@ +--- +title: Деструктурирующее присваивание +slug: Web/JavaScript/Reference/Operators/Destructuring_assignment +tags: + - JavaScript + - Оператор +translation_of: Web/JavaScript/Reference/Operators/Destructuring_assignment +--- +

Синтаксис деструктурирующего присваивания в выражениях JavaScript позволяет извлекать данные из массивов или объектов при помощи синтаксиса, подобного объявлению массива или литералов в объекте.

+ +

Синтаксис

+ +
var a, b, rest;
+[a, b] = [1, 2];
+console.log(a); // 1
+console.log(b); // 2
+
+[a, b, ...rest] = [1, 2, 3, 4, 5];
+console.log(a); // 1
+console.log(b); // 2
+console.log(rest); // [3, 4, 5]
+
+({a, b} = {a:1, b:2});
+console.log(a); // 1
+console.log(b); // 2
+
+({a, b, ...rest} = {a:1, b:2, c:3, d:4});
+// ES2016 - ещё не реализовано Firefox 47a01
+
+ +

Описание

+ +

Выражения объявления объектов или массивов предоставляют простой способ создания пакета однородных данных. При создании такого пакета вы получаете возможность использовать его любым доступным образом. Также вы можете возвращать его в функциях.

+ +

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

+ +

Данная возможность подобна таковой, присутствующей в языках Perl и Python.

+ +

Разбор массивов

+ +

Простой пример

+ +
var foo = ["one", "two", "three"];
+
+// без деструктурирования
+var one   = foo[0];
+var two   = foo[1];
+var three = foo[2];
+
+// с деструктурированием
+var [one, two, three] = foo;
+ +

Обмен значений переменных

+ +

После выполнения фрагмента кода, значение b будет 1, a будет 3. Без деструктурирующего присваивания, для обмена значений требуется дополнительная временная переменная (или что-то наподобие XOR-обмена).

+ +
var a = 1;
+var b = 3;
+
+[a, b] = [b, a];
+ +

Возврат нескольких значений

+ +

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

+ +
function f() {
+  return [1, 2];
+}
+
+ +

Как вы видите, возвращаемые результаты имеют вид массива, значения которого заключены в квадратные скобки. Вы можете возвращать неограниченное количество результатов таким образом. В следующем примере, f() возвращает [1, 2] как результат:

+ +
var a, b;
+[a, b] = f();
+console.log("A is " + a + " B is " + b);
+
+ +

Оператор [a, b] = f() присваивает результаты функции переменным в квадратных скобках: a будет присвоено 1, b будет присвоено 2.

+ +

Вы также можете использовать результат функции в виде массива:

+ +
var a = f();
+console.log("A is " + a);
+
+ +

В данном случае a будет массивом с элементами 1 и 2.

+ +

Игнорирование некоторых значений

+ +

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

+ +
function f() {
+  return [1, 2, 3];
+}
+
+var [a, , b] = f();
+console.log("A is " + a + " B is " + b);
+
+ +

После выполнения кода, a будет 1, b будет 3. Значение 2 игнорируется. Таким же образом вы можете игнорировать любые (или все) значения. Например:

+ +
[,,] = f();
+
+ +

Получение значений из результата регулярного выражения

+ +

Когда метод exec() регулярного выражения находит совпадение, он возвращает массив, содержащий первый совпадающий фрагмент строки и далее группы, определённые в регулярном выражении. Деструктурирующее присваивание упрощает получение данных из этих групп, игнорируя первый фрагмент:

+ +
var url = "https://developer.mozilla.org/en-US/Web/JavaScript";
+
+var parsedURL = /^(\w+)\:\/\/([^\/]+)\/(.*)$/.exec(url);
+var [, protocol, fullhost, fullpath] = parsedURL;
+
+console.log(protocol); // выведет "https"
+
+ +

Разбор объектов

+ +

Простой пример

+ +
var o = {p: 42, q: true};
+var {p, q} = o;
+
+console.log(p); // 42
+console.log(q); // true
+
+// Объявление новых переменных
+var {p: foo, q: bar} = o;
+
+console.log(foo); // 42
+console.log(bar); // true
+
+ +

Загрузка модулей

+ +

Деструктурирующее присваивание помогает загружать специфичные наборы модулей, как в Add-on SDK:

+ +
const { Loader, main } = require('toolkit/loader');
+
+ +

Вложенный объект и разбор массива

+ +
var metadata = {
+    title: "Scratchpad",
+    translations: [
+       {
+        locale: "de",
+        localization_tags: [ ],
+        last_edit: "2014-04-14T08:43:37",
+        url: "/de/docs/Tools/Scratchpad",
+        title: "JavaScript-Umgebung"
+       }
+    ],
+    url: "/en-US/docs/Tools/Scratchpad"
+};
+
+var { title: englishTitle, translations: [{ title: localeTitle }] } = metadata;
+
+console.log(englishTitle); // "Scratchpad"
+console.log(localeTitle);  // "JavaScript-Umgebung"
+ +

Деструктурирование во время обхода

+ +
var people = [
+  {
+    name: "Mike Smith",
+    family: {
+      mother: "Jane Smith",
+      father: "Harry Smith",
+      sister: "Samantha Smith"
+    },
+    age: 35
+  },
+  {
+    name: "Tom Jones",
+    family: {
+      mother: "Norah Jones",
+      father: "Richard Jones",
+      brother: "Howard Jones"
+    },
+    age: 25
+  }
+];
+
+for (var {name: n, family: { father: f } } of people) {
+  console.log("Name: " + n + ", Father: " + f);
+}
+
+// "Name: Mike Smith, Father: Harry Smith"
+// "Name: Tom Jones, Father: Richard Jones"
+ +

Получение полей объекта-параметра функции

+ +
function userId({id}) {
+  return id;
+}
+
+function whois({displayName, fullName: {firstName: name}}){
+  console.log(displayName + " is " + name);
+}
+
+var user = {
+  id: 42,
+  displayName: "jdoe",
+  fullName: {
+      firstName: "John",
+      lastName: "Doe"
+  }
+};
+
+console.log("userId: " + userId(user)); // "userId: 42"
+whois(user); // "jdoe is John"
+ +

В приведённом примере извлекаются поля id, displayName и firstName из объекта пользователь.

+ +

Деструктурирование вычисляемых имён свойств

+ +

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

+ +
let key = "z";
+let { [key]: foo } = { z: "bar" };
+
+console.log(foo); // "bar"
+
+ +

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

+ + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES2015', '#sec-destructuring-assignment', 'Деструктурирующее присваивание')}}{{Spec2('ES2015')}}Изначальное определение.
+ +

Совместимость с браузерами

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)EdgeInternet ExplorerOperaSafari
Базовая поддержка{{CompatChrome(49.0)}}{{ CompatGeckoDesktop("1.8.1") }}14{{ CompatNo() }}{{ CompatNo() }}7.1
Вычисляемые имена свойств{{CompatChrome(49.0)}}{{ CompatGeckoDesktop("34") }}14{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
Оператор spread{{CompatChrome(49.0)}}{{ CompatGeckoDesktop("34") }}12[1]{{ CompatUnknown() }}{{ CompatUnknown() }}{{ CompatUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{ CompatNo() }}{{ CompatNo() }}{{ CompatGeckoMobile("1.0") }}{{ CompatNo() }}{{ CompatNo() }}iOS 8
Вычисляемые имена свойств{{ CompatNo() }}{{ CompatNo() }}{{ CompatGeckoMobile("34") }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
Оператор spread{{ CompatUnknown() }}{{ CompatUnknown() }}{{ CompatGeckoMobile("34") }}{{ CompatUnknown() }}{{ CompatUnknown() }}{{ CompatUnknown() }}
+
+ +

[1] Необходимо включить "Enable experimental Javascript features" в `about:flags`

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/expression_closures/index.html b/files/ru/web/javascript/reference/operators/expression_closures/index.html new file mode 100644 index 0000000000..9c8f613699 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/expression_closures/index.html @@ -0,0 +1,118 @@ +--- +title: Expression closures +slug: Web/JavaScript/Reference/Operators/Expression_closures +tags: + - Нестандартная + - Функции +translation_of: Archive/Web/JavaScript/Expression_closures +--- +
Не является стандартом. Не используйте данный синтаксис!
+Синтаксис замкнутого выражения является устаревшей возможностью SpiderMonkey и будет удален. Используйте вместо него стрелочные функции.
+ +
{{jsSidebar("Operators")}}
+ +

Замкнутые выражения – это синтаксис для удобной записи коротких и простых функций.

+ +

Синтаксис

+ +
function [name]([param1[, param2[, ..., paramN]]])
+   expression
+
+ +

Параметры

+ +
+
name
+
Имя функции. Может быть пропущено, в таком случае функция будет являться анонимной. Имя функции доступно только в теле функции.
+
paramN
+
Имя аргумента, передаваемого функции. Всего может быть передано вплоть до 255 аргументов.
+
expression
+
Выражение, содержащее тело функции.
+
+ +

Описание

+ +

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

+ +

JavaScript 1.7 и старше:

+ +
function(x) { return x * x; }
+ +

JavaScript 1.8:

+ +
function(x) x * x
+ +

Такой синтаксис позволяет отбросить фигурные скобки и оператор return. Данный подход, кроме краткости записи, иных преимуществ не имеет.

+ +

Примеры использования

+ +

Короткая запись для привязки слушателей событий:

+ +
 document.addEventListener("click", function() false, true);
+
+ +

Использование такой записи для работы с функциями массивов из JavaScript 1.6:

+ +
elems.some(function(elem) elem.type == "text");
+
+ +

Таблица совместимости

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

 

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/function/index.html b/files/ru/web/javascript/reference/operators/function/index.html new file mode 100644 index 0000000000..aefe1d0c2b --- /dev/null +++ b/files/ru/web/javascript/reference/operators/function/index.html @@ -0,0 +1,143 @@ +--- +title: Функциональное выражение +slug: Web/JavaScript/Reference/Operators/function +tags: + - JavaScript + - Оператор + - Функция +translation_of: Web/JavaScript/Reference/Operators/function +--- +
{{jsSidebar("Operators")}}
+ +

Ключевое слово function может использоваться для определения функции внутри выражения.

+ +

Вы можете также определять функции используя конструктор {{jsxref("Function")}} и {{jsxref("Statements/function", "объявление функции")}}.

+ +

Синтаксис

+ +
var myFunction = function [name]([param1[, param2[, ..., paramN]]]) {
+   statements
+};
+ +

С версии ES2015 можно также использовать стрелочные функции.

+ +

Параметры

+ +
+
name
+
Имя функции. Может быть опущено, в таком случае функция является анонимной. Имя функции является локальным для её тела.
+
paramN
+
Имя аргумента, передаваемого в функцию.
+
statements
+
Инструкции, составляющие тело функции.
+
+ +

Описание

+ +

Функциональное выражение и объявление функции очень похожи и имеют почти одинаковый синтаксис. Главным отличием между ними является имя функции, которое в случае функциональных выражений может быть опущено для создания анонимных функций. Функциональное выражение может быть использовано для создания самовызывающейся функции {{Glossary("IIFE")}} (Immediately Invoked Function Expression), которая исполняется сразу же после того, как она была определена. Более подробная информация изложена в разделе о функциях.

+ +

Поднятие функциональных выражений

+ +

Функциональные выражения в JavaScript не {{Glossary("поднятие", "поднимаются (hoisting)")}}, в отличие от {{jsxref("Statements/function", "объявленных функций", "#Поднимание_объявленной_функции")}}. Вы не можете использовать функциональные выражения прежде, чем вы их определили.

+ +
console.log(notHoisted) // undefined
+//Хотя объявленная переменная и поднимается, определение переменной происходит позже
+notHoisted(); // TypeError: notHoisted is not a function
+
+var notHoisted = function() {
+   console.log('bar');
+};
+ +

Именованное функциональное выражение

+ +

Если вы хотите сослаться на текущую функцию внутри тела этой функции, вам необходимо создать именованое функциональное выражение. Данное имя будет локальным только для тела функции (её области видимости). Кроме того, это позволяет избежать использования нестандартного свойства {{jsxref("arguments.callee")}}.

+ +
var math = {
+  'factit': function factorial(n) {
+    console.log(n);
+    if (n <= 1) {
+      return 1;
+    }
+    return n * factorial(n - 1);
+  }
+};
+
+math.factit(3) //3;2;1;
+
+ +

Переменная, которой присвоено функциональное выражение, будет иметь свойство name, содержащее имя функции. Оно не изменится при переприсваивании другой переменной. Для анонимной функции, значением свойства name будет имя переменной (неявное имя). Если же имя задано, то будет использовано имя функции (явное имя). Это же касается стрелочных функций (в их случае там будет записано имя переменной, т.к. они всегда анонимные).

+ +
var foo = function() {}
+foo.name // "foo"
+
+var foo2 = foo
+foo2.name // "foo"
+
+var bar = function baz() {}
+bar.name // "baz"
+
+console.log(foo === foo2); // true
+console.log(typeof baz); // undefined
+console.log(bar === baz); // false (errors because baz == undefined)
+ +

Примеры

+ +

Следующий пример демонстрирует создание безымянной (анонимной) функции и присвоение её переменной x. Функция возвращает квадрат переданного значения:

+ +
var x = function (y) {
+   return y * y;
+};
+
+ +

Преимущественно анонимные функции используются как {{Glossary("функция обратного вызова", "функции обратного вызова", 1)}}.

+ +
button.addEventListener('click', function(event) {
+    console.log('button is clicked!')
+});
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-13', 'Function definition')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-13', 'Function definition')}}{{Spec2('ES3')}}Изначальное определение. Реализовано в JavaScript 1.5.
+ +

Совместимость с браузерами

+ +

{{Compat("javascript.operators.function")}}

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/function_star_/index.html b/files/ru/web/javascript/reference/operators/function_star_/index.html new file mode 100644 index 0000000000..c924d55dfe --- /dev/null +++ b/files/ru/web/javascript/reference/operators/function_star_/index.html @@ -0,0 +1,149 @@ +--- +title: function* expression +slug: Web/JavaScript/Reference/Operators/function* +tags: + - ECMAScript6 + - JavaScript + - Итератор + - Оператор + - Функция +translation_of: Web/JavaScript/Reference/Operators/function* +--- +
{{jsSidebar("Operators")}}
+ +

Ключевое слово function* может использоваться для объявления функции-генератора внутри выражения.

+ +

Синтаксис

+ +
function* [имя]([параметр1[, параметр2[, ..., параметрN]]]) {
+   инструкции
+}
+ +

Параметры

+ +
+
имя
+
Имя функции. Может быть опущено, в этом случае функция будет анонимной. Имя локально для тела функции.
+
параметрN
+
Имя аргумента, передаваемого в функцию. Фунция может иметь до 255 аргументов.
+
инструкции
+
Инструкции, составляющие тело функции.
+
+ +

Описание

+ +

Выражение function*  очень похоже на обявление {{jsxref('Statements/function*', 'function*')}}, и имеет почти такой же синтаксис. Основная разница между выражением function* и объявлением function* – в имени функции, которое может быть опущено в выражениях function* для создания анонимных функций. Смотрите главу о функциях для получения более подробной информации.

+ +

Примеры

+ +

В следующем примере определяется безымянная функция-генератор и присваивается переменной x. Функция возвращает квадрат своего аргумента:

+ +
var x = function*(y) {
+   yield y * y;
+};
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES6', '#', 'function*')}}{{Spec2('ES6')}}Изначальное определение.
{{SpecName('ESDraft', '#', 'function*')}}{{Spec2('ESDraft')}}
+ +

Совместимость с браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
ХарактеристикаChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatVersionUnknown}}{{CompatGeckoDesktop("26.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
yield*{{CompatVersionUnknown}}{{CompatGeckoDesktop("27.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ХарактеристикаAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("26.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
yield*{{CompatUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("27.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/generator_comprehensions/index.html b/files/ru/web/javascript/reference/operators/generator_comprehensions/index.html new file mode 100644 index 0000000000..fb04526d8a --- /dev/null +++ b/files/ru/web/javascript/reference/operators/generator_comprehensions/index.html @@ -0,0 +1,229 @@ +--- +title: Упрощенный синтаксис создания функций-генераторов +slug: Web/JavaScript/Reference/Operators/Generator_comprehensions +tags: + - Итераторы +translation_of: Archive/Web/JavaScript/Generator_comprehensions +--- +
Не в стандарте. Не используйте!
+Включения генераторов - нестандартная возможность, и вряд ли когда-либо появится в ECMAScript. В будущем попробуйте использовать {{jsxref("Statements/function*", "generator", "", 1)}}.
+ +
{{jsSidebar("Operators")}}
+ +
Синтаксис включений генераторов - это выражение, которое позволяет быстро создать новую функцию-генератор из существующего итератора. Включения присутствуют во множестве языков программирования.
+ +
 
+ +
Ниже показаны отличия от старого синтаксиса генераторных выражений в SpiderMonkey, основанных на предложениях к стандарту ECMAScript 4.
+ +
 
+ +

Синтаксис

+ +
(for (x of iterable) x)
+(for (x of iterable) if (condition) x)
+(for (x of iterable) for (y of iterable) x + y)
+
+ +

Описание

+ +

Внутри включений генераторов допустимы два типа компонентов:

+ + + +

Конструкция for-of всегда идёт первой. Таких конструкций может быть несколько.

+ +

Существенный недостаток {{jsxref("Operators/Array_comprehensions","включений массивов","","true")}} - это то, что они создают полносью новый массив в памяти. Даже когда исходный массив небольшой, накладные расходы получаются весьма заметными, а уж когда входные данные - это большой массив или дорогой (или бесконечный) генератор, создание нового массива может быть трудной задачей.

+ +

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

+ +

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

+ +
var doubles = [for (i in it) i * 2];
+
+ +

А включение генераторов создало бы новый итератор, который высчитывал бы  следующее умноженное значение, когда оно нужно:

+ +
var it2 = (for (i in it) i * 2);
+console.log(it2.next()); // Первое значение из it, умноженное на два
+console.log(it2.next()); // Второе значение из it, умноженное на два
+
+ +

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

+ +
var result = doSomething(for (i in it) i * 2);
+
+ +

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

+ +

Примеры

+ +

Простое включение генераторов

+ +
(for (i of [ 1, 2, 3 ]) i*i );
+// Функция-генератор, которая отдаёт 1, 4, 9 и так далее
+
+[...(for (i of [ 1, 2, 3 ]) i*i )];
+// [1, 4, 9]
+
+var abc = [ "A", "B", "C" ];
+(for (letters of abc) letters.toLowerCase());
+// Функция-генератор, которая отдаёт 'a', 'b' и 'c'
+
+ +

Включение генераторов с условием

+ +
var years = [ 1954, 1974, 1990, 2006, 2010, 2014 ];
+
+(for (year of years) if (year > 2000) year);
+// функция-генератор, которая отдаёт 2006, 2010 и 2014
+
+(for (year of years) if (year > 2000) if(year < 2010) year);
+// функция-генератор, которая отдаёт 2006, как и функция ниже:
+
+(for (year of years) if (year > 2000 && year < 2010) year);
+// функция-генератор, которая отдаёт 2006
+
+ +

Включение генератора в сравнении с функцией-генератором

+ +

Будет проще понять синтаксис включений генераторов, если сравнить его с функцией-генератором.

+ +

Пример 1: Простой генератор.

+ +
var numbers = [ 1, 2, 3 ];
+
+// Функция-генератор
+(function*() {
+  for (let i of numbers) {
+    yield i * i;
+  }
+})()
+
+// Включение генератора
+(for (i of numbers) i*i );
+
+// Результат: в обоих случаях получается генератор, который отдаёт [ 1, 4, 9 ]
+
+ +

Пример 2: Использование if в генераторе.

+ +
var numbers = [ 1, 2, 3 ];
+
+// Функция-генератор
+(function*() {
+  for (let i of numbers) {
+    if (i < 3) {
+      yield i * 1;
+    }
+  }
+})()
+
+// Включение генератора
+(for (i of numbers) if (i < 3) i);
+
+// Результат: в обоих случаях получается генератор, который отдаёт [ 1, 2 ]
+ +

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

+ +

Включения генераторов изначально входили в черновик ECMAScript 6, но их убрали в ревизии 27 (August 2014). Please see older revisions of ES6 for specification semantics.

+ +

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

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Начальная поддержка{{CompatNo}}{{ CompatGeckoDesktop("30") }}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Начальная поддержка{{CompatNo}}{{CompatNo}}{{ CompatGeckoMobile("30") }}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Особенности реализации в SpiderMonkey

+ + + +

Отличия от старых JS1.7/JS1.8 включений

+ +
JS1.7/JS1.8 включения убраны из Gecko 46 ({{bug(1220564)}}).
+ +

Старый синтаксис включений (не используйте!):

+ +
(X for (Y in Z))
+(X for each (Y in Z))
+(X for (Y of Z))
+
+ +

Отличия:

+ + + +

См. также

+ + diff --git a/files/ru/web/javascript/reference/operators/in/index.html b/files/ru/web/javascript/reference/operators/in/index.html new file mode 100644 index 0000000000..35ee2c4620 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/in/index.html @@ -0,0 +1,136 @@ +--- +title: in operator +slug: Web/JavaScript/Reference/Operators/in +tags: + - JavaScript + - Оператор + - Оператор отношения +translation_of: Web/JavaScript/Reference/Operators/in +--- +
{{jsSidebar("Operators")}}
+ +

Оператор in возвращает true, если свойство содержится в указанном объекте или в его цепочке прототипов.

+ +

Синтаксис

+ +
prop in object
+ +

Параметры

+ +
+
prop
+
Строка или symbol, представляющий название свойства или индекс массива (non-symbols будут конвертированы в строки).
+
+ +
+
object
+
Объект, в котором нужно проверить содежание свойства с заданным именем.
+
+ +

Описание

+ +

В примере ниже показаны некоторые способы использования оператора in.

+ +
// Массивы
+var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+0 in trees        // true
+3 in trees        // true
+6 in trees        // false
+"bay" in trees    // false (вы должны указать индекс элемента в массиве, а не значение в этом индексе)
+"length" in trees // true (length является свойством Array)
+
+// Уже существующие объекты
+"PI" in Math      // true
+
+// Пользовательские объекты
+var mycar = {make: "Honda", model: "Accord", year: 1998};
+"make" in mycar  // true
+"model" in mycar // true
+
+ +

Вы должны указать объект справа от оператора in. Например, вы можете указать строку, созданную через конструктор объекта String, но вы не можете указать строковый литерал.

+ +
var color1 = new String("green");
+"length" in color1 // returns true
+
+var color2 = "coral";
+// сгенерирует ошибку (color2 is not a String object)
+"length" in color2
+
+ +

Использование оператора in с неопределенными или с уже удаленными свойствами

+ +

Если вы удалили свойство при помощи оператора delete, то оператор in возвратит false для этого свойства.

+ +
var mycar = {make: "Honda", model: "Accord", year: 1998};
+delete mycar.make;
+"make" in mycar;  // false
+
+var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+delete trees[3];
+3 in trees; // false
+
+ +

Если вы зададите свойству значение {{jsxref("Global_Objects/undefined", "undefined")}}, но не удалите его, то для этого свойства оператор in вернет значение true.

+ +
var mycar = {make: "Honda", model: "Accord", year: 1998};
+mycar.make = undefined;
+"make" in mycar;  // true
+
+ +
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+trees[3] = undefined;
+3 in trees; // returns true
+
+ +

Наследуемые свойства

+ +

Оператор in возвратит true для свойств, которые унаследованы по цепочке прототипов. (Если вы хотите проверить только не наследованные свойства, используйте {{jsxref("Object.prototype.hasOwnProperty()")}}.)

+ +
"toString" in {}; // true
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ESDraft', '#sec-relational-operators', 'Relational Operators')}}{{Spec2('ESDraft')}}
{{SpecName('ES2015', '#sec-relational-operators', 'Relational Operators')}}{{Spec2('ES2015')}}
{{SpecName('ES5.1', '#sec-11.8.7', 'The in Operator')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-11.8.7', 'The in Operator')}}{{Spec2('ES3')}}Определено изначально. Реализовано в JavaScript 1.4
+ +

Совместимость с браузерами

+ +

{{Compat("javascript.operators.in")}}

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/index.html b/files/ru/web/javascript/reference/operators/index.html new file mode 100644 index 0000000000..eff74ba579 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/index.html @@ -0,0 +1,291 @@ +--- +title: Выражения и операторы +slug: Web/JavaScript/Reference/Operators +tags: + - JavaScript + - Operators +translation_of: Web/JavaScript/Reference/Operators +--- +
{{jsSidebar("Operators")}}
+ +

Эта глава описывает все операторы, выражения и ключевые слова языка JavaScript.

+ +

Выражения и операторы по категориям

+ +

Алфавитный список смотрите в боковой панели слева.

+ +

Первичные выражения

+ +

Базовые ключевые слова и общие выражения в JavaScript.

+ +
+
{{jsxref("Operators/this", "this")}}
+
Ключевое слово this ссылается на контекст выполняемой функции.
+
{{jsxref("Operators/function", "function")}}
+
Ключевое слово function определяет выражение функции.
+
{{jsxref("Operators/class", "class")}}
+
Ключевое слово class определяет выражение класса.
+
{{jsxref("Operators/function*", "function*")}}
+
Ключевое слово function* (со звёздочкой) определяет функцию-генератор.
+
{{jsxref("Operators/yield", "yield")}}
+
Пауза или продолжение выполнения функции-генератора.
+
{{jsxref("Operators/yield*", "yield*")}}
+
Делегирует выполнение другому генератору итерируемому объекту.
+
{{experimental_inline}} {{jsxref("Operators/async_function", "async function*")}}
+
async function определяет выражение асинхронной функции.
+
{{experimental_inline}} {{jsxref("Operators/await", "await")}}
+
Пауза и продолжение выполнения асинхронной функции и ожидание Promise (результата выполнения) с результатом разрешено/отклонено.
+
{{jsxref("Global_Objects/Array", "[]")}}
+
Синтаксис создания инициализатора/литерала массива.
+
{{jsxref("Operators/Object_initializer", "{}")}}
+
Синтаксис создания инициализатора/литерала объекта
+
{{jsxref("Global_Objects/RegExp", "/ab+c/i")}}
+
Синтаксис создания литерала регулярного выражения.
+
{{jsxref("Operators/Grouping", "( )")}}
+
Оператор группировки.
+
+ +

Левосторонние выражения

+ +

Значения слева являются назначением присваивания.

+ +
+
{{jsxref("Operators/Property_accessors", "Доступ к свойству", "", 1)}}
+
Операторы доступа к членам предоставляют доступ к свойству или методу объекта
+ (object.property и object['property']).
+
{{jsxref("Operators/new", "new")}}
+
Оператор new создаёт экземпляр объекта с использованием конструктора.
+
new.target
+
Свойство new.target ссылается на конструктор или функцию, который был вызван через оператор {{jsxref("Operators/new", "new")}}.
+
{{jsxref("Operators/super", "super")}}
+
Ключевое слово super вызывает конструктор родительского класса.
+
{{jsxref("Operators/Spread_operator", "...obj")}}
+
Оператор распространения позволяет развернуть выражение в местах, где ожидается несколько аргументов (при вызове функций) или несколько элементов (при создании литералов массива).
+
+ +

Инкремент и декремент

+ +

Операторы постфиксного/префиксного инкремента и декремента.

+ +
+
{{jsxref("Operators/Arithmetic_Operators", "A++", "#Increment")}}
+
Оператор постфиксного инкремента.
+
{{jsxref("Operators/Arithmetic_Operators", "A--", "#Decrement")}}
+
Оператор постфиксного декремента.
+
{{jsxref("Operators/Arithmetic_Operators", "++A", "#Increment")}}
+
Оператор префиксного инкремента. (Значение переменной, сначала, увеличивается на 1, а затем используется в выражении)
+
{{jsxref("Operators/Arithmetic_Operators", "--A", "#Decrement")}}
+
Оператор префиксного декремента.
+
+ +

Унарные операторы

+ +

Унарные опарации — это операции с одним операндом.

+ +
+
{{jsxref("Operators/delete", "delete")}}
+
Оператор delete удаляет свойство из объекта.
+
{{jsxref("Operators/void", "void")}}
+
Оператор void отбрасывает возвращаемое значение выражения.
+
{{jsxref("Operators/typeof", "typeof")}}
+
Оператор typeof определяет тип переданного объекта.
+
{{jsxref("Operators/Arithmetic_Operators", "+", "#Unary_plus")}}
+
Оператор унарного плюса преобразует свой операнд в тип {{jsxref("Global_Objects/Number", "Number")}}.
+
{{jsxref("Operators/Arithmetic_Operators", "-", "#Unary_negation")}}
+
Оператор унарного минуса преобразует свой операнд в тип {{jsxref("Global_Objects/Number", "Number")}}, а затем меняет его знак.
+
{{jsxref("Operators/Bitwise_Operators", "~", "#Bitwise_NOT")}}
+
Оператор побитового НЕ.
+
{{jsxref("Operators/Logical_Operators", "!", "#Logical_NOT")}}
+
Оператор логического НЕ.
+
+ +

Арифметические операторы

+ +

Арифметические операторы своими операндами принимают числовые значения (литерали или переменные) и возвращают одно числовое значение.

+ +
+
{{jsxref("Operators/Arithmetic_Operators", "+", "#Addition")}}
+
Оператор сложения.
+
{{jsxref("Operators/Arithmetic_Operators", "-", "#Subtraction")}}
+
Оператор вычитания.
+
{{jsxref("Operators/Arithmetic_Operators", "/", "#Division")}}
+
Оператор деления.
+
{{jsxref("Operators/Arithmetic_Operators", "*", "#Multiplication")}}
+
Оператор умножения.
+
{{jsxref("Operators/Arithmetic_Operators", "%", "#Remainder")}}
+
Оператор взятия остатка от деления.
+
{{jsxref("Operators/Arithmetic_Operators", "**", "#Exponentiation")}}
+
Оператор возведения в степень.
+
+ +

Реляционные операторы

+ +

Реляционные операторы (операторы отношения) сравнивают свои операнды и возвращают значение типа {{jsxref("Global_Objects/Boolean", "Boolean")}}, зависящее от того, был ли результат сравнения истинным или ложным.

+ +
+
{{jsxref("Operators/in", "in")}}
+
Оператор in определяет, содержит ли объект указанное свойство.
+
{{jsxref("Operators/instanceof", "instanceof")}}
+
Оператор instanceof определяет, является ли объект экземпляром потомком Prototype (или экземпляром) другого объекта.
+
{{jsxref("Operators/Comparison_Operators", "<", "#Less_than_operator")}}
+
Оператор меньше.
+
{{jsxref("Operators/Comparison_Operators", ">", "#Greater_than_operator")}}
+
Оператор больше.
+
{{jsxref("Operators/Comparison_Operators", "<=", "#Less_than_or_equal_operator")}}
+
Оператор меньше или равно.
+
{{jsxref("Operators/Comparison_Operators", ">=", "#Greater_than_or_equal_operator")}}
+
Оператор больше или равно.
+
+ +
+

Заметьте: => это не оператор. Это нотация для Стрелочных функций.

+
+ +

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

+ +

Результат вычисления оператора равенства всегда имеет тип {{jsxref("Global_Objects/Boolean", "Boolean")}} и значение, зависящее от того, был ли результат проверки истинным или ложным.

+ +
+
{{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}
+
Оператор проверки на равенство.
+
{{jsxref("Operators/Comparison_Operators", "!=", "#Inequality")}}
+
Оператор проверки на неравенство.
+
{{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}
+
Оператор проверки на идентичность.
+
{{jsxref("Operators/Comparison_Operators", "!==", "#Nonidentity")}}
+
Оператор проверки на неидентичность.
+
+ +

Операторы побитового сдвига

+ +

Операции для сдвига всех битов операнда.

+ +
+
{{jsxref("Operators/Bitwise_Operators", "<<", "#Left_shift")}}
+
Оператор побитового сдвига влево.
+
{{jsxref("Operators/Bitwise_Operators", ">>", "#Right_shift")}}
+
Оператор знакового побитового сдвига вправо.
+
{{jsxref("Operators/Bitwise_Operators", ">>>", "#Unsigned_right_shift")}}
+
Оператор беззнакового побитового сдвига вправо.
+
+ +

Бинарные побитовые операторы

+ +

Побитовые операторы трактуют свои операнды как набор из 32 битов (нулей и единиц) и возвращают стандартные числовые значения JavaScript.

+ +
+
{{jsxref("Operators/Bitwise_Operators", "&", "#Bitwise_AND")}}
+
Оператор побитового И.
+
{{jsxref("Operators/Bitwise_Operators", "|", "#Bitwise_OR")}}
+
Оператор побитового ИЛИ.
+
{{jsxref("Operators/Bitwise_Operators", "^", "#Bitwise_XOR")}}
+
Оператор побитового ИСКЛЮЧАЮЩЕГО ИЛИ.
+
+ +

Бинарные логические операторы

+ +

Логические операторы обычно используются вместе с булевыми (логическими) значениями и в сочетании с ними они возвращают булево значение.

+ +
+
{{jsxref("Operators/Logical_Operators", "&&", "#Logical_AND")}}
+
Оператор логического И.
+
{{jsxref("Operators/Logical_Operators", "||", "#Logical_OR")}}
+
Оператор логического ИЛИ.
+
+ +

Условный (тернарный) оператор

+ +
+
{{jsxref("Operators/Conditional_Operator", "(условие ? ifTrue : ifFalse)")}}
+
Условный оператор возвращает одно значение из двух данных в зависимости от логического значения условия.
+
+ +

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

+ +

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

+ +
+
{{jsxref("Operators/Assignment_Operators", "=", "#Assignment")}}
+
Оператор присваивания.
+
{{jsxref("Operators/Assignment_Operators", "*=", "#Multiplication_assignment")}}
+
Оператор присваивания с умножением.
+
{{jsxref("Operators/Assignment_Operators", "/=", "#Division_assignment")}}
+
Оператор присваивания с делением.
+
{{jsxref("Operators/Assignment_Operators", "%=", "#Remainder_assignment")}}
+
Оператор присваивания с взятием остатка от деления.
+
{{jsxref("Operators/Assignment_Operators", "+=", "#Addition_assignment")}}
+
Оператор присваивания со сложением.
+
{{jsxref("Operators/Assignment_Operators", "-=", "#Subtraction_assignment")}}
+
Оператор присваивания с вычитанием.
+
{{jsxref("Operators/Assignment_Operators", "<<=", "#Left_shift_assignment")}}
+
Оператор присваивания со сдвигом влево.
+
{{jsxref("Operators/Assignment_Operators", ">>=", "#Right_shift_assignment")}}
+
Оператор присваивания со знаковым сдвигом вправо.
+
{{jsxref("Operators/Assignment_Operators", ">>>=", "#Unsigned_right_shift_assignment")}}
+
Оператор присваивания с беззнаковым сдвигом вправо.
+
{{jsxref("Operators/Assignment_Operators", "&=", "#Bitwise_AND_assignment")}}
+
Оператор присваивания с побитовым И.
+
{{jsxref("Operators/Assignment_Operators", "^=", "#Bitwise_XOR_assignment")}}
+
Оператор присваивания с побитовым ИСКЛЮЧАЮЩИМ ИЛИ.
+
{{jsxref("Operators/Assignment_Operators", "|=", "#Bitwise_OR_assignment")}}
+
Оператор присваивания с побитовым ИЛИ.
+
{{jsxref("Operators/Destructuring_assignment", "[a, b] = [1, 2]")}}
+ {{jsxref("Operators/Destructuring_assignment", "{a, b} = {a:1, b:2}")}}
+
Деструктурирующее присваивание позволяет вам присваивать свойства массива или объекта переменным с использованием синтаксиса, очень похожего на объявление литералов массива или объекта.
+
+ +

Оператор запятая

+ +
+
{{jsxref("Operators/Comma_Operator", ",")}}
+
Оператор запятая позволяет вычислять несколько выражений в одном операторе и возвращает результат вычисления последнего выражения.
+
+

Нестандартные особенности

+
+
{{non-standard_inline}} {{jsxref("Operators/Legacy_generator_function", "Legacy generator function", "", 1)}}
+
Ключевое слово function может быть использовано для определения устаревших функций-генераторов в одном выражении. Для того, чтобы сделать такую функцию, её тело должно содержать хотя бы одно выражение {{jsxref("Operators/yield", "yield")}}.
+
{{non-standard_inline}} {{jsxref("Operators/Expression_closures", "Expression closures", "", 1)}}
+
Синтаксис закрытого выражения для сокращённого написания простейших функций.
+
{{non-standard_inline}} {{jsxref("Operators/Array_comprehensions", "[for (x of y) x]")}}
+
Упрощённый синтаксис создания массива.
+
{{non-standard_inline}} {{jsxref("Operators/Generator_comprehensions", "(for (x of y) y)")}}
+
Упрощённый синтаксис создания генератора.
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES1', '#sec-11', 'Expressions')}}{{Spec2('ES1')}}Изначальное определение.
{{SpecName('ES5.1', '#sec-11', 'Expressions')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}{{Spec2('ES6')}}Новое: Оператор распространения, деструктурирующее присваивание, ключевое слово super.
{{SpecName('ESDraft', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}{{Spec2('ESDraft')}}
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/instanceof/index.html b/files/ru/web/javascript/reference/operators/instanceof/index.html new file mode 100644 index 0000000000..81676c6bf5 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/instanceof/index.html @@ -0,0 +1,165 @@ +--- +title: instanceof +slug: Web/JavaScript/Reference/Operators/instanceof +tags: + - JavaScript + - Relational Operators + - instanceof + - Объект + - Оператор + - прототип +translation_of: Web/JavaScript/Reference/Operators/instanceof +--- +
{{jsSidebar("Operators")}}
+ +

Оператор instanceof проверяет, принадлежит ли объект к определённому классу. Другими словами, object instanceof constructor проверяет, присутствует ли объект constructor.prototype в цепочке прототипов object.

+ +
{{EmbedInteractiveExample("pages/js/expressions-instanceof.html")}}
+ +

Синтаксис

+ +
object instanceof constructor
+ +

Параметры

+ +
+
object
+
Проверяемый объект.
+
+ +
+
constructor
+
Функция-конструктор, на которую идёт проверка.
+
+ +

Описание

+ +

Оператор instanceof проверяет, присутствует ли объект constructor.prototype в цепочке прототипов object.

+ +
// объявляем конструкторы
+function C() {}
+function D() {}
+
+var o = new C();
+
+// true, так как: Object.getPrototypeOf(o) === C.prototype
+o instanceof C;
+
+// false, так как D.prototype не присутствует в цепочке прототипов o
+o instanceof D;
+
+o instanceof Object; // true, так как:
+C.prototype instanceof Object // true
+
+C.prototype = {};
+var o2 = new C();
+
+o2 instanceof C; // true
+
+// false, так как C.prototype отсутствует в цепочке прототипов o
+o instanceof C;
+
+D.prototype = new C(); // add C to [[Prototype]] linkage of D
+var o3 = new D();
+o3 instanceof D; // true
+o3 instanceof C; // true, так как C.prototype теперь присутствует в цепочке прототипов o3
+
+ +

Обратите внимание: результат оператора instanceof зависит от свойства constructor.prototype, поэтому результат оператора может поменяться после изменения этого свойства. Также результат может поменяться после изменения прототипа object (или цепочки прототипов) с помощью Object.setPrototypeOf или нестандартного свойства __proto__.

+ +

instanceof и множественные контексты (например, фреймы или окна)

+ +

Различные контексты имеют разные среды выполнения. Это означает, что они имеют различныые built-ins (разный глобальный объект, различные конструкторы и т.д.). Это может давать неожиданные результаты. Например, [] instanceof window.frames[0].Array вернёт false, потому что Array.prototype !== window.frames[0].Array а массив наследуется от Array.

+ +

Это может казаться несущественной проблемой сначала, но при работе с несколькими фреймами или окнами, и передачи объектов из одного контекста в другой с помощью функций, это может стать серьёзной проблемой. С другой стороны, безопасно проверить, является ли некоторый объект массивом можно используя Array.isArray(myObj).

+ +

Например, для проверки того, что Node является SVGElement в разных контекстах можно использовать myNode instanceof myNode.ownerDocument.defaultView.SVGElement.

+ +
Замечания для разработчиков Mozilla:
+Использование XPCOM instanceof в коде имеет специальный эффект: obj instanceof xpcomInterface (например Components.interfaces.nsIFile) вызывает obj.QueryInterface(xpcomInterface) и возвращает true если проверка на QueryInterface прошла успешно. Побочным эфектом этого вызова является то, что можно использовать свойства xpcomInterface на obj после успешной проверки с помощью instanceof. В отличии от стандартных глобальных JavaScript типов, проверка obj instanceof xpcomInterface работает как ожидается, даже если obj отнсится к другому контексту.
+ +

Примеры

+ +

Показывает, что String и Date имеют тип Object и граничные случаи

+ +

Следующий код использует instanceof, чтобы показать что объекты String и Date также имеют тип Object (они являются наследниками Object).

+ +

Однако, объекты, созданные с помощью литералов, являются исключениями — хотя их prototype равен undefined, выражение instanceof Object возвращает true.

+ +
var simpleStr = 'Это обычная строка';
+var myString  = new String();
+var newStr    = new String('Строка, созданная с помощью конструктора');
+var myDate    = new Date();
+var myObj     = {};
+
+simpleStr instanceof String; // возвращает false, проверяет цепочку прототипов
+myString  instanceof String; // возвращает true
+newStr    instanceof String; // возвращает true
+myString  instanceof Object; // возвращает true
+
+myObj instanceof Object;    // возвращает true, несмотря на прототип, равный undefined
+({})  instanceof Object;    // возвращает true, аналогично предыдущей строчке
+
+myString instanceof Date;   // возвращает false
+
+myDate instanceof Date;     // возвращает true
+myDate instanceof Object;   // возвращает true
+myDate instanceof String;   // возвращает false
+
+ +

Показывает, что mycar имеет тип Car и тип Object

+ +

Следующий код создает тип Car и экземпляр этого типа, mycar. Оператор instanceof показывает, что объект mycar имеет тип Car и тип Object.

+ +
function Car(make, model, year) {
+  this.make = make;
+  this.model = model;
+  this.year = year;
+}
+var mycar = new Car('Honda', 'Accord', 1998);
+var a = mycar instanceof Car;    // возвращает true
+var b = mycar instanceof Object; // возвращает true
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ESDraft', '#sec-relational-operators', 'Relational Operators')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-relational-operators', 'Relational Operators')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-11.8.6', 'The instanceof operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-11.8.6', 'The instanceof operator')}}{{Spec2('ES3')}}Изначальное определение. Реализована в JavaScript 1.4.
+ +

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

+ +

{{Compat("javascript.operators.instanceof")}}

+ +

См. также

+ + diff --git a/files/ru/web/javascript/reference/operators/new.target/index.html b/files/ru/web/javascript/reference/operators/new.target/index.html new file mode 100644 index 0000000000..bab9b8e956 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/new.target/index.html @@ -0,0 +1,137 @@ +--- +title: new.target +slug: Web/JavaScript/Reference/Operators/new.target +tags: + - ECMAScript6 + - JavaScript +translation_of: Web/JavaScript/Reference/Operators/new.target +--- +
{{JSSidebar("Operators")}}
+ +
Свойство new.target позволяет определить была ли функция или конструктор вызваны с помощью оператора new. В конструкторах и функциях инстанциированных с помощью оператора new,  new.target возвращает ссылку на конструктор или функцию. При обычном вызове функции new.target имеет значение {{jsxref("undefined")}}.
+ +

Синтаксис

+ +
new.target
+ +

Описание

+ +

Синтаксис new.target состоит из ключевого слова"new", точки, и свойства "target". Обычно "new." служит контекстом для доступа к свойству, но здесь "new." не совсем объект. Однако при вызове конструктора, new.target ссылается на конструктор вызванный с помощью new и таким образом "new." становится виртуальным контекстом.

+ +

Свойство new.target это мета свойство которое доступно во всех функциях. В стрелочных функция, new.target ссылается на new.target внешней функции.

+ +

Примеры

+ +

new.target в вызове функции

+ +

При обычном вызове функции (в противоположность вызову в качестве конструктора), new.target имеет значение {{jsxref("undefined")}}. Это позволяет определить была ли вызвана функция как конструктор через new или нет.

+ +
function Foo() {
+  if (!new.target) throw "Foo() must be called with new";
+  console.log("Foo instantiated with new");
+}
+
+new Foo(); // выведет "Foo instantiated with new"
+Foo(); // ошибка "Foo() must be called with new"
+
+ +

new.target в конструкторе

+ +

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

+ +
class A {
+  constructor() {
+    console.log(new.target.name);
+  }
+}
+
+class B extends A { constructor() { super(); } }
+
+var a = new A(); // вернет "A"
+var b = new B(); // вернет "B"
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES6', '#sec-built-in-function-objects', 'Built-in Function Objects')}}{{Spec2('ES6')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-built-in-function-objects', 'Built-in Function Objects')}}{{Spec2('ESDraft')}} 
+ +

Совместимость с браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatChrome(46.0)}}{{CompatGeckoDesktop(41)}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Базовая поддержка{{CompatNo}}{{CompatChrome(46.0)}}{{CompatGeckoMobile(41)}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatChrome(46.0)}}
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/new/index.html b/files/ru/web/javascript/reference/operators/new/index.html new file mode 100644 index 0000000000..ce21bd41c1 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/new/index.html @@ -0,0 +1,217 @@ +--- +title: Оператор new +slug: Web/JavaScript/Reference/Operators/new +tags: + - JavaScript + - Левосторонние выражения + - Оператор +translation_of: Web/JavaScript/Reference/Operators/new +--- +
{{jsSidebar("Operators")}}
+ +

Оператор (операторная функция) new создает экземпляр объекта, встроенного или определенного пользователем, имеющего конструктор.

+ +

Синтаксис

+ +
new constructor[([arguments])]
+ +

Параметры

+ +
+
constructor
+
Функция, задающая тип объекта.
+
+ +
+
arguments
+
Список параметров, с которыми будет вызван конструктор.
+
+ +

Описание

+ +

Создание объекта, определенного пользователем, требует два шага:

+ +
    +
  1. Написать функцию, которая задаст тип объекта.
    2. +
  2. Создать экземпляр объекта, используя  new.
    3. +
+ +

Чтобы определить новый тип объекта, создайте функцию, которая задаст его и имя и свойства. Свойство объекта также может быть объектом. Примеры приведены ниже.

+ +

Когда исполняется new Foo(...) , происходит следующее:

+ +
    +
  1. Создается новый объект, наследующий Foo.prototype.
    2. +
  2. Вызывается конструктор — функция Foo с указанными аргументами и this, привязанным к только что созданному объекту. new Foo эквивалентно new Foo(), то есть если аргументы не указаны, Foo вызывается без аргументов.
    3. +
  3. Результатом выражения new становится объект, возвращенный конструктором. Если конструктор не возвращет объект явно, используется объект из п. 1. (Обычно конструкторы не возвращают значение, но они могут делать это, если нужно переопределить обычный процесс создания объектов.)
    4. +
+ +

Всегда можно добавить свойство к уже созданному объекту. Например, car1.color = "black" добавляет свойство color к объекту car1, и присваивает ему значение "black". Это не затрагивает другие объекты. Чтобы добавить свойство ко всем объектам типа, нужно добавлять его в определение типа Car.

+ +

Добавить свойство к ранее определенному типу можно используя свойство Function.prototype. Это определит свойство для всех объектов, созданных этой функцией, а не только у какого-либо экземпляра. Следующий пример добавляет свойство color со значениеи null всем объектам типа car, а потом меняет его на  "black" только у экземпляра car1. Больше информации в статье prototype.

+ +
function Car() {}
+car1 = new Car();
+
+console.log(car1.color);    // undefined
+
+Car.prototype.color = null;
+console.log(car1.color);    // null
+
+car1.color = "black";
+console.log(car1.color);   // black
+
+ +

Примеры

+ +

Тип объекта и экземпляры объекта

+ +

Предположим, нам нужен тип объекта для автомобилей. Этот тип должен называться car, и иметь свойства: марка, модель и год.

+ +
function Car(make, model, year) {
+  this.make = make;
+  this.model = model;
+  this.year = year;
+}
+
+ +

Теперь можно создать экземпляр типа car:

+ +
var mycar = new Car("Eagle", "Talon TSi", 1993);
+
+ +

Это выражение создает экземпляр mycar и присваевает его свойствам указанные значения. Таким образом, mycar.make принимает значение "Eagle", mycar.year принимает значение 1993, и так далее.

+ +

Можно создать любое количество экземпляров car с помощью оператора new. Например:

+ +
var kenscar = new Car("Nissan", "300ZX", 1992);
+
+ +

Объект в качестве свойства

+ +

Предположим, есть объект person:

+ +
function Person(name, age, sex) {
+  this.name = name;
+  this.age = age;
+  this.sex = sex;
+}
+
+ +

Создадим два экземпляра:

+ +
var rand = new Person("Rand McNally", 33, "M");
+var ken = new Person("Ken Jones", 39, "M");
+
+ +

Изменим определение car, добавив свойство, указывающее владельца — owner:

+ +
function Car(make, model, year, owner) {
+  this.make = make;
+  this.model = model;
+  this.year = year;
+  this.owner = owner;
+}
+
+ +

Создадим экземпляры car:

+ +
var car1 = new Car("Eagle", "Talon TSi", 1993, rand);
+var car2 = new Car("Nissan", "300ZX", 1992, ken);
+
+ +

Вместо строковых или численных значений можно передать обект как параметр. Чтобы узнать имя владельца car2, получим доступ к свойству:

+ +
car2.owner.name
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#sec-new-operator', 'The new Operator')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-11.2.2', 'The new Operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-11.2.2', 'The new Operator')}}{{Spec2('ES3')}} 
{{SpecName('ES1', '#sec-11.2.2', 'The new Operator')}}{{Spec2('ES1')}}Изначальное определение. Реализовано JavaScript 1.0.
+ +

Совместимость с браузерами

+ +

{{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}}
+
+ +

См. также

+ + diff --git a/files/ru/web/javascript/reference/operators/nullish_coalescing_operator/index.html b/files/ru/web/javascript/reference/operators/nullish_coalescing_operator/index.html new file mode 100644 index 0000000000..71484f05a1 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/nullish_coalescing_operator/index.html @@ -0,0 +1,144 @@ +--- +title: Оператор нулевого слияния +slug: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator +translation_of: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator +--- +

{{JSSidebar("Operators")}}

+ +

Оператор нулевого слияния (??) это логический оператор, который возвращает значение правого операнда когда значение левого операнда равно {{jsxref("null")}} или {{jsxref("undefined")}}, в противном случае будет возвращено значение левого операнда.

+ +

В отличие от логического ИЛИ (||), левая часть оператора вычисляется и возвращается даже если его результат после приведения к логическому типу оказывается ложным, но не является null или undefined. Другими словами, если вы используете || чтобы установить значение по умолчанию, вы можете столкнуться с неожиданным поведением если считаете некоторые ложные значения пригодными для использования (например, "" или 0). Ниже приведены примеры.

+ +
{{EmbedInteractiveExample("pages/js/expressions-nullishcoalescingoperator.html")}}
+ + + +

Синтаксис

+ +
leftExpr ?? rightExpr
+
+ +

Примеры

+ +

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

+ +

В этом примере показано как устанавливать значения по умолчанию, оставив в покое значения отличные от null или undefined.

+ +
const nullValue = null;
+const emptyText = ""; // falsy
+const someNumber = 42;
+
+const valA = nullValue ?? "default for A";
+const valB = emptyText ?? "default for B";
+const valC = someNumber ?? 0;
+
+console.log(valA); // "default for A"
+console.log(valB); // "" (так как пустая строка не null или undefined)
+console.log(valC); // 42
+ +

Значение по умолчанию в присваивании переменной

+ +

Ранее, для присваивания значения по умолчанию переменной использовался оператор логического ИЛИ (||):

+ +
let foo;
+
+//  переменной foo никогда не присваивалось значение, поэтому она undefined
+let someDummyText = foo || 'Hello!';
+ +

Однако, оператор || это логический оператор, левый операнд которого при сравнении неявно приводится к булевому значению, поэтому любое ложное значение (0, '', NaN, null, undefined) не возвращается. Данное поведение может быть нежелательным если вы рассматриваете 0, '', или NaN как корректные значения.

+ +
let count = 0;
+let text = "";
+
+let qty = count || 42;
+let message = text || "hi!";
+console.log(qty);     // 42 and not 0
+console.log(message); // "hi!" and not ""
+
+ +

Оператор нулевого слияния предотвращает попадание в такую ловушку, возвращая второй операнд если первый оказывается null or undefined (но не любым другим ложным значением):

+ +
let myText = ''; // Пустая строка (тоже является ложным значением при приведении к логическому типу)
+
+let notFalsyText = myText || 'Hello world';
+console.log(notFalsyText); // Hello world
+
+let preservingFalsy = myText ?? 'Hi neighborhood';
+console.log(preservingFalsy); // '' (так как myText не undefined и не null)
+
+ +

Синтаксическое сокращение

+ +

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

+ +
function A() { console.log('A was called'); return undefined;}
+function B() { console.log('B was called'); return false;}
+function C() { console.log('C was called'); return "foo";}
+
+console.log( A() ?? C() );
+// выводит "A was called", затем "C was called", и затем "foo"
+// так как A() возвращает undefined, поэтому оба выражения вычисляются
+
+console.log( B() ?? C() );
+// выводит "B was called", затем "false"
+// так как B() возвращает false (но не null или undefined), правое
+// выражение не вычисляется
+
+ +

Не объединяется с И или ИЛИ операторами

+ +

Нельзя напрямую объединять И (&&) и ИЛИ (||) операторы с ??. При таком выражении будет выброшен SyntaxError.

+ +
null || undefined ?? "foo"; // выбрасывает SyntaxError
+true || undefined ?? "foo"; // выбрасывает SyntaxError
+ +

Однако, при заключении в скобки выражение является корректным:

+ +
(null || undefined) ?? "foo"; // returns "foo"
+
+ +

Отношение к оператору опциональной последовательности (?.)

+ +

Оператор нулевого слияния определяет undefined и null как специальные значения так же как и оператор опциональной последовательности (?.), который используется для доступа к свойствам объекта, значение которого может быть null или undefined.

+ +
let foo = { someFooProp: "hi" };
+
+console.log(foo.someFooProp?.toUpperCase());  // "HI"
+console.log(foo.someBarProp?.toUpperCase()); // undefined
+
+ +

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

+ + + + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#prod-Nulli', 'nullish coalescing expression')}}
+ +

Совместимость с браузерами

+ + + +

{{Compat("javascript.operators.nullish_coalescing")}}

+ +

Прогресс реализации

+ +

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

+ +
{{EmbedTest262ReportResultsTable("coalesce-expression")}}
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/object_initializer/index.html b/files/ru/web/javascript/reference/operators/object_initializer/index.html new file mode 100644 index 0000000000..c7172a0c03 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/object_initializer/index.html @@ -0,0 +1,431 @@ +--- +title: Инициализация объектов +slug: Web/JavaScript/Reference/Operators/Object_initializer +translation_of: Web/JavaScript/Reference/Operators/Object_initializer +--- +
{{JsSidebar("Операторы")}}
+ +

Объекты могут быть инициализированы с помощью new Object(), Object.create() или литеральной (инициирующей) нотации. Инициализатор объекта это разделенный запятыми список ноль или более пар имен свойств и ассоциируемых с ними значений, заключенных в фигурные скобки ({}).

+ +

Синтаксис

+ +
var o = {};
+var o = {a: 'foo', b: 42, c: {}};
+
+var a = 'foo', b = 42, c = {};
+var o = {a: a, b: b, c: c};
+
+var o = {
+  property: function ([parameters]) {},
+  get property() {},
+  set property(value) {}
+};
+
+ +

Новая нотация в ECMAScript 2015

+ +

Пожалуйста, просмотрите таблицу поддержки этих нотаций. В неподдерживаемом окружении, эти нотации приведут к синтаксической ошибке.

+ +
// Сокращение имен свойств (ES2015)
+var a = 'foo', b = 42, c = {};
+var o = {a, b, c};
+
+// Сокращение имен методов (ES2015)
+var o = {
+  property([parameters]) {}
+};
+
+// Вычисление имен свойств (ES2015)
+var prop = 'foo';
+var o = {
+  [prop]: 'hey',
+  ['b' + 'ar']: 'there'
+};
+ +

Описание

+ +

Инициализатор объекта это выражение, которое описывает инициализацию {{jsxref("Object")}}. Объекты состоят из свойств, которые используются для описания объекта. Значения свойств объектов могут содержать как {{Glossary("примитивные")}} типы данных, так и другие объекты.

+ +

Создание объектов

+ +

Пустой объект без свойств может быть создан следующим образом:

+ +
var object = {};
+ +

Однако, преимущество литеральной или инициирующей нотации это возможность быстро создавать объекты со свойствами внутри фигурных скобок. Создается простой список пар ключ: значение, разделенных запятой. Следующий код создает объект с тремя парами значений и ключи это "foo", "age" и "baz". Значения этих ключей строка "bar", число 42 и другой объект.

+ +
var object = {
+  foo: 'bar',
+  age: 42,
+  baz: {myProp: 12}
+}
+ +

Доступность свойств

+ +

После того, как создали объект, вы, вероятно, захотите прочитать или изменить его. Свойства объектов могут быть получены при помощи точечной нотации или квадратных скобок. Смотрите property accessors для детальной информации.

+ +
object.foo; // "bar"
+object['age']; // 42
+
+object.foo = 'baz';
+
+ +

Определение свойств

+ +

Мы уже рассмотрели, как объявить свойства, используя синтаксис инициализации. Зачастую, в коде появляются свойства, которые вы захотите поместить в объект. Вы увидете следующий код:

+ +
var a = 'foo',
+    b = 42,
+    c = {};
+
+var o = {
+  a: a,
+  b: b,
+  c: c
+};
+ +

С ECMAScript 2015 появилась короткая нотация, способная достичь того же:

+ +
var a = 'foo',
+    b = 42,
+    c = {};
+
+// Сокращение имен свойств (ES2015)
+var o = {a, b, c};
+
+// Иначе говоря,
+console.log((o.a === {a}.a)); // true
+
+ +

Повторение имен свойств

+ +

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

+ +
var a = {x: 1, x: 2};
+console.log(a); // {x: 2}
+
+ +

В строгом режиме ECMAScript 5, повторение имен свойств будет воспринято как {{jsxref("SyntaxError")}}.  С введением вычисляемых имен свойств и появлением возможности создавать дубликаты во время выполнения кода, ECMAScript 2015 убрал это ограничение.

+ +
function haveES2015DuplicatePropertySemantics() {
+  'use strict';
+  try {
+    ({prop: 1, prop: 2});
+
+    // Не будет ошибки, повторение имен доступно в строгом режиме
+    return true;
+  } catch(e) {
+    // Будет ошибка, дубликаты запрещены в строгом режиме
+    return false;
+  }
+}
+ +

Описание методов

+ +

Свойство объекта также может ссылаться на function, getter или setter.

+ +
var o = {
+  property: function ([parameters]) {},
+  get property() {},
+  set property(value) {}
+};
+ +

В ECMAScript 2015, доступна короткая нотация, поэтому слово "function" более не обязательно.

+ +
// Сокращение имен методов (ES2015)
+var o = {
+  property([parameters]) {},
+  *generator() {}
+};
+ +

В ECMAScript 2015 есть способ кратко объявить свойства, чьими значениями являются генераторы функций:

+ +
var o = {
+  *generator() {
+    ...........
+  }
+};
+ +

Что эквивалентно следующей ES5-подобной нотации (но отметьте, что  ECMAScript 5 не содержит генераторов):

+ +
var o = {
+  generator: function* () {
+    ...........
+  }
+};
+ +

Для большей информации и примеров смотри method definitions.

+ +

Вычисляемые имена свойств

+ +

Начиная с ECMAScript 2015, синтаксис объявления объектов также поддерживает вычисляемые имена свойств. Это позволяет добавлять в скобки [] выражение, которое будет вычислено, как имя свойства. Это похоже на скобочную нотацию синтаксиса property accessor, которую вы, вероятно, уже использовали, чтобы прочитать и задать свойство. Теперь можно использовать аналогичный способ с литеральными объектами:

+ +
// Вычисляемое имя свойства (ES2015)
+var i = 0;
+var a = {
+  ['foo' + ++i]: i,
+  ['foo' + ++i]: i,
+  ['foo' + ++i]: i
+};
+
+console.log(a.foo1); // 1
+console.log(a.foo2); // 2
+console.log(a.foo3); // 3
+
+var param = 'size';
+var config = {
+  [param]: 12,
+  ['mobile' + param.charAt(0).toUpperCase() + param.slice(1)]: 4
+};
+
+console.log(config); // {size: 12, mobileSize: 4}
+ +

Spread-свойства

+ +

Rest/Spread свойство ECMAScript предлагает (stage 3) добавлять spread свойства в литеральную нотацию. Оно копирует собственные перечисляемые свойства из представленного объекта в новый.

+ +

Поверхностное копирование (исключая prototype) или слияние объектов теперь возможно с помощью более короткого синтаксиса, чем  {{jsxref("Object.assign()")}}.

+ +
var obj1 = { foo: 'bar', x: 42 };
+var obj2 = { foo: 'baz', y: 13 };
+
+var clonedObj = { ...obj1 };
+// Объект { foo: "bar", x: 42 }
+
+var mergedObj = { ...obj1, ...obj2 };
+// Объект { foo: "baz", x: 42, y: 13 }
+ +

Заметьте, что {{jsxref("Object.assign()")}} вызывает setters, тогда как оператор spread нет.

+ +

Изменение Prototype

+ +

Объявление свойства в виде __proto__: value или "__proto__": value не создаст свойства с именем __proto__.  Вместо этого, если предоставляемое значение объект или null, оно заменит [[Prototype]] создаваемого объекта на это значение.  (Если значение не объект или null, объект не изменится.)

+ +
var obj1 = {};
+assert(Object.getPrototypeOf(obj1) === Object.prototype);
+
+var obj2 = {__proto__: null};
+assert(Object.getPrototypeOf(obj2) === null);
+
+var protoObj = {};
+var obj3 = {'__proto__': protoObj};
+assert(Object.getPrototypeOf(obj3) === protoObj);
+
+var obj4 = {__proto__: 'not an object or null'};
+assert(Object.getPrototypeOf(obj4) === Object.prototype);
+assert(!obj4.hasOwnProperty('__proto__'));
+
+ +

Только одно изменение prototype разрешено через литеральное объявление объекта: несколько изменений prototype вызовут синтаксическую ошибку.

+ +

Объявление свойства не через "двоеточие" не изменит знаения prototype: это описание будет выглядеть идентично такому же объявлению свойства с использованием любого другого имени.

+ +
var __proto__ = 'variable';
+
+var obj1 = {__proto__};
+assert(Object.getPrototypeOf(obj1) === Object.prototype);
+assert(obj1.hasOwnProperty('__proto__'));
+assert(obj1.__proto__ === 'variable');
+
+var obj2 = {__proto__() { return 'hello'; }};
+assert(obj2.__proto__() === 'hello');
+
+var obj3 = {['__prot' + 'o__']: 17};
+assert(obj3.__proto__ === 17);
+
+ +

Литеральная нотация vs JSON

+ +

Литеральная нотация не то же самое, что и  JavaScript Object Notation (JSON). Хотя они и выглядят аналогично, существует разница между ними:

+ + + +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}initial definition.
{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}{{Spec2('ES5.1')}}getter and setter added.
{{SpecName('ES2015', '#sec-object-initializer', 'Object Initializer')}}{{Spec2('ES2015')}}Shorthand method/property names and computed property names added.
{{SpecName('ESDraft', '#sec-object-initializer', 'Object Initializer')}}{{Spec2('ESDraft')}}
Rest/Spread Properties for ECMAScript DraftStage 3 draft.
+ +

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

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome(1.0)}}{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.0")}}111
Computed property names{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoDesktop("34")}}{{CompatNo}}347.1
Shorthand property names{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoDesktop("33")}}{{CompatNo}}349
Shorthand method names{{CompatChrome(42.0)}}{{CompatVersionUnknown}}{{CompatGeckoDesktop("34")}}{{CompatNo}}349
Spread properties{{CompatChrome(60)}}{{CompatNo}}{{CompatGeckoDesktop("55")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewEdgeFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("1.0")}}111{{CompatChrome(1.0)}}
Computed property names{{CompatNo}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("34")}}{{CompatNo}}347.1{{CompatNo}}
Shorthand property names{{CompatNo}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("33")}}{{CompatNo}}349{{CompatNo}}
Shorthand method names{{CompatNo}}{{CompatChrome(42.0)}}{{CompatVersionUnknown}}{{CompatGeckoMobile("34")}}{{CompatNo}}349{{CompatChrome(42.0)}}
Spread properties{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("55")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

See also

+ + diff --git a/files/ru/web/javascript/reference/operators/operator_precedence/index.html b/files/ru/web/javascript/reference/operators/operator_precedence/index.html new file mode 100644 index 0000000000..2362cdc038 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/operator_precedence/index.html @@ -0,0 +1,322 @@ +--- +title: Приоритет операторов +slug: Web/JavaScript/Reference/Operators/Operator_Precedence +tags: + - JavaScript + - Операторы + - подробности об операторах + - приоритет операторов +translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence +--- +
{{jsSidebar("Operators")}}
+ +

Приоритет операторов определяет порядок, в котором операторы выполняются. Операторы с более высоким приоритетом выполняются первыми.

+ +
{{EmbedInteractiveExample("pages/js/expressions-operatorprecedence.html")}}
+ + + +

Ассоциативность

+ +

Ассоциативность определяет порядок, в котором обрабатываются операторы с одинаковым приоритетом. Например, рассмотрим выражение:

+ +
a OP b OP c
+
+ +

Левая ассоциативность (слева направо) означает, что оно обрабатывается как (a OP b) OP c, в то время как правая ассоциативность (справа налево) означает, что они интерпретируются как a OP (b OP c). Операторы присваивания являются право-ассоциативными, так что вы можете написать:

+ +
a = b = 5;
+
+ +

с ожидаемым результатом, что a и b будут равны 5. Это происходит, потому что оператор присваивания возвращает тот результат, который присваивает. Сначала b становится равным 5, затем a принимает значение b.

+ +

Примеры

+ +
3 > 2 && 2 > 1
+// вернёт true
+
+3 > 2 > 1
+// вернёт false, потому что 3 > 2 возвращает true, в свою очередь true > 1 вернёт false
+// Добавление скобок значительно повышает читаемость выражения: (3 > 2) > 1
+ +

Таблица

+ +

Данная таблица упорядочена с самого высокого приоритета (20) до самого низкого (1).

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ПриоритетТип оператораАссоциативностьКонкретные операторы
20{{jsxref("Operators/Grouping", "Группировка")}}не определено( … )
19{{jsxref("Operators/Property_Accessors", "Доступ к свойствам", "#Dot_notation")}}слева направо… . …
{{jsxref("Operators/Property_Accessors", "Доступ к свойствам с возможностью вычисления","#Bracket_notation")}}слева направо… [ … ]
{{jsxref("Operators/new","new")}} (со списком аргументов)не определеноnew … ( … )
Вызов функциислева направо… ( … )
18{{jsxref("Operators/new","new")}} (без списка аргументов)справа налевоnew …
17{{jsxref("Operators/Arithmetic_Operators","Постфиксный инкремент","#Increment")}}не определено… ++
{{jsxref("Operators/Arithmetic_Operators","Постфиксный декремент","#Decrement")}}… --
16Логическое отрицаниесправа налево! …
Побитовое отрицание~ …
Унарный плюс+ …
Унарный минус- …
Префиксный инкремент++ …
Префиксный декремент-- …
typeoftypeof …
voidvoid …
deletedelete …
awaitawait …
15Возведение в степеньсправа налево… ** …
14Умножениеслева направо… * …
Деление… / …
Остаток… % …
13Сложениеслева направо… + …
Вычитание… - …
12Побитовый сдвиг влевослева направо… << …
Побитовый сдвиг вправо… >> …
Сдвиг вправо с заполнением нулей… >>> …
11Меньшеслева направо… < …
Меньше или равно… <= …
Больше… > …
Больше или равно… >= …
in… in …
instanceof… instanceof …
10Равнослева направо… == …
Не равно… != …
Строго равно… === …
Строго не равно… !== …
9Побитовое «И»слева направо… & …
8Побитовое исключающее «ИЛИ»слева направо… ^ …
7Побитовое «ИЛИ»слева направо… | …
6Логическое «И»слева направо… && …
5Логическое «ИЛИ»слева направо… || …
4Условныйсправа налево… ? … : …
3Присваиваниесправа налево… = …
… += …
… -= …
… **= …
… *= …
… /= …
… %= …
… <<= …
… >>= …
… >>>= …
… &= …
… ^= …
… |= …
2yieldсправа налевоyield …
yield*yield* …
1Запятая / Последовательностьслева направо… , …
diff --git a/files/ru/web/javascript/reference/operators/optional_chaining/index.html b/files/ru/web/javascript/reference/operators/optional_chaining/index.html new file mode 100644 index 0000000000..30fd29e3c0 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/optional_chaining/index.html @@ -0,0 +1,176 @@ +--- +title: "Оператор\_опциональной последовательности" +slug: Web/JavaScript/Reference/Operators/Optional_chaining +translation_of: Web/JavaScript/Reference/Operators/Optional_chaining +--- +
{{jsSidebar("Operators")}}
+ +

Оператор опциональной последовательности ?. позволяет получить значение свойства, находящегося на любом уровне вложенности в цепочке связанных между собой объектов, без необходимости проверять каждое из промежуточных свойств в ней на существование.  ?. работает подобно оператору ., за исключением того, что не выбрасывает исключение, если объект, к свойству или методу которого идёт обращение, равен {{jsxref("null")}} или {{jsxref("undefined")}}. В этих случаях он возвращает undefined.

+ +

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

+ +
{{EmbedInteractiveExample("pages/js/expressions-optionalchainingoperator.html", "taller")}}
+ +
+ + + +

Синтаксис

+ +
obj?.prop
+obj?.[expr]
+arr?.[index]
+func?.(args)
+
+ +

Описание

+ +

Оператор опциональной последовательности предоставляет способ упростить доступ к значениям в цепочке обьектов, когда возможно, что какое-то свойство (или метод) в ней равно undefined или null.

+ +

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

+ +
let nestedProp = obj.first && obj.first.second;
+ +

Если обращаться к obj.first.second без проверки obj.first, то, если свойство obj.first равно null или undefined, выбросится исключение {{jsxref("TypeError")}}.

+ +

Однако, с оператором опциональной последовательности (?.) не требуется явно проверять ссылку на obj.first перед обращением к obj.first.second:

+ +
let nestedProp = obj.first?.second;
+ +

Если используется оператор ?. вместо ., JavaScript знает о необходимости проверки obj.first перед обращением к obj.first.second. Если значение obj.first равно null или undefined, выполнение выражения автоматически прекращается и возвращается undefined.

+ +

Это эквивалентно следующему (кроме создания временной переменной):

+ +
let temp = obj.first;
+let nestedProp = ((temp === null || temp === undefined) ? undefined : temp.second);
+ +

Опциональная последовательность с вызовом функции

+ +

Вы можете использовать ?., когда необходимо вызвать метод, которого может не существовать. Это может быть полезно, например, при использовании API, в котором метод может быть недоступен из-за устаревания или неподдерживаемости устройством пользователя.

+ +

Использование ?. с вызовом функции значит, что выполнение автоматически вернет undefined, а не выбросит исключение, если метод не найден:

+ +
let result = someInterface.customMethod?.();
+ +
+

Обратите внимание: Для существующего свойства, не являющегося функцией, использование конструкции x.y?.() всё равно выбросит {{jsxref("TypeError")}} исключение (x.y не является функцией).

+
+ +

Работа с функциями обратного вызова и обработчиками событий

+ +

Если Вы используете функции обратного вызова или извлекаете методы обьекта деструктурирующим присваиванием, Вы можете получить несуществующие значения, которые нельзя вызывать как функции до проверки на их существование. Используя оператор ?., Вы можете избежать лишних проверок:

+ +
// С использованием ES2019
+function doSomething(onContent, onError) {
+  try {
+    // ... делаем что-то с данными
+  }
+  catch (err) {
+    if (onError) { // проверяем, существует ли onError
+      onError(err.message);
+    }
+  }
+}
+ +
// С использованием оператора опциональной последовательности
+function doSomething(onContent, onError) {
+  try {
+   // ... делаем что-то с данными
+  }
+  catch (err) {
+    onError?.(err.message); // не выбросит исключение, если onError равен undefined
+  }
+}
+
+ +

Опциональные последовательности в выражениях

+ +

Вы также можете использовать оператор опциональной последовательности, когда обращаетесь к свойству с помощью скобочной нотации:

+ +
let nestedProp = obj?.['prop' + 'Name'];
+
+ +

Примеры

+ +

Базовый пример

+ +

В этом примере производится обращение к свойству name элемента с ключом bar объекта Map. Элемент с таким ключом отсутствует, но исключение выброшено не будет; nameBar равен undefined.

+ +
let myMap = new Map();
+myMap.set("foo", {name: "baz", desc: "inga"});
+
+let nameBar = myMap.get("bar")?.name;
+ +

Сокращенное выполнение

+ +

При использовании оператора опциональной последовательности в выражениях, где левая часть операнда равна null или undefined, выражение не будет выполнено. Например:

+ +
let potentiallyNullObj = null;
+let x = 0;
+let prop = potentiallyNullObj?.[x++];
+
+console.log(x); // 0, т.к. x не был инкрементирован
+
+ +

Совместное использование операторов опциональной последовательности

+ +

Во вложенных объектах возможно использование оператора опциональной последовательности неограниченное количество раз:

+ +
let customer = {
+  name: "Carl",
+  details: {
+    age: 82,
+    location: "Paradise Falls" // точный адрес неизвестен
+  }
+};
+let customerCity = customer.details?.address?.city;
+
+// … это также работает с вызовами функций
+let duration = vacations.trip?.getTime?.();
+
+ +

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

+ +

Оператор {{JSxRef("Operators/Nullish_Coalescing_Operator", "??", '', 1)}} может использоваться после опциональной последовательности для установления значения по умолчанию:

+ +
let customer = {
+  name: "Carl",
+  details: { age: 82 }
+};
+const customerCity = customer?.city ?? "Unknown city";
+console.log(customerCity); // Unknown city
+ +

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

+ + + + + + + + + + + + + + + + +
СпецификацияСтатусПримечание
Proposal for the "optional chaining" operatorStage 4
+ +

Совместимость с браузерами

+ +
+ + +

{{Compat("javascript.operators.optional_chaining")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/property_accessors/index.html b/files/ru/web/javascript/reference/operators/property_accessors/index.html new file mode 100644 index 0000000000..84ba61f9fd --- /dev/null +++ b/files/ru/web/javascript/reference/operators/property_accessors/index.html @@ -0,0 +1,203 @@ +--- +title: Property accessors +slug: Web/JavaScript/Reference/Operators/Property_Accessors +translation_of: Web/JavaScript/Reference/Operators/Property_Accessors +--- +
{{jsSidebar("Operators")}}
+ +

Доступ к свойствам объекта можно получить, используя точечную и скобочную записи.

+ +

{{EmbedInteractiveExample("pages/js/expressions-propertyaccessors.html", "taller")}}

+ +

Синтаксис

+ +
object.property
+object["property"]
+
+ +

Описание

+ +

Можно думать об объекте как об ассоциативном массиве (или карте, словаре, хэш-таблице, таблице поиска). Ключи в таком массиве - это имена свойств объекта.

+ +

Когда речь идёт о свойствах объекта, обычно различают собственно свойства и методы. Однако разделение свойство/метод это не более чем условность. Метод - это просто свойство, которое можно вызвать (например, если оно содержит ссылку на {{jsxref("Function", "функцию")}} в качестве значения.

+ +

Есть два способа доступа к свойствам: точечная и скобочная записи.

+ +

Точечная запись

+ +

В записи object.property, property должно быть действительным идентификатором. (В стандарте ECMAScript, имена своств технически называются "IdentifierNames", а не "Identifiers", поэтому зарезервированные слова могут быть использованы в их качестве, но это не рекомендуется). Например, object.$1 является верной записью, а object.1 - нет.

+ +
const variable = object.property_name;
+
+object.property_name = value;
+
+ +
const object = {};
+
+object.$1 = 'foo';
+console.log(object.$1);  // 'foo'
+
+object.1 = 'bar';        // SyntaxError
+console.log(object.1);   // SyntaxError
+ +

Здесь метод с именем createElement считывается с объекта document и вызывается.

+ +
document.createElement('pre')
+ +

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

+ +
// SyntaxError, здесь считается, что 77. это число,
+// поэтому такая запись эквивалентна (77.)toExponentional()
+// что является ошибкой
+77.toExponentional()
+// Рабочие варианты:
+77.toExponential()
+77
+.toExponential()
+;(77).toExponential()
+// Здесь первая точка относится к числу, вторая вызывает метод
+// то есть эта запись равносильна (77.).toExponential()
+77..toExponential()
+// Эквивалентно (77.0).toExponential()
+77.0.toExponential()
+ +

Скобочная запись

+ +

В записи object[property_name], property_name - это выражение, вычисляющееся в строку или символ. Это может быть любая строка, не обязательно действительный идентификатор, например '1foo', '!bar!' или даже ' ' (пробел).

+ +
const variable = object[property_name]
+object[property_name] = value
+ +

Пример, аналогичный примеру в предыдущем пункте:

+ +
document['createElement']('pre');
+
+ +

Пробел перед скобкой допускается:

+ +
document ['createElement']('pre')
+ +

Имена свойств

+ +

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

+ +
const object = {}
+object['1'] = 'value'
+console.log(object[1])
+ +

Этот пример также выводит 'value', так как и foo, и bar приводятся к одной и той же строке.

+ +
const foo = {unique_prop: 1}
+const bar = {unique_prop: 2}
+const object = {}
+
+object[foo] = 'value';
+console.log(object[bar]);
+
+ +

В движке SpiderMonkey JavaScript это строка '[object Object]'.

+ +

Привязка методов

+ +

Метод не привязан к содержащему его объекту. Это значит, что значение this в методах объекта не всегда указывает на него. Вместо этого, this "передаётся" при вызове метода. Смотрите подробнее this.

+ +

Примеры

+ +

Скобочная запись или eval

+ +

Новички JavaScript часто делают ошибку, используя eval там, где можно просто использовать скобочную запись.

+ +

Например, следующий синтаксис можно часто увидеть в скриптах.

+ +
x = eval('document.forms.form_name.elements.' + strFormControl + '.value');
+
+ +

Функция eval() очень медленная и её использования следует избегать, когда это возможно. Кроме того, строка strFormControl при таком использовании обязаны содержать действительный идентификатор, что не является обязательным для id полей формы, то есть, например, поле с id 1 не получится получить такой записмью. Лучше вместо этого использовать скобочную запись:

+ +
x = document.forms["form_name"].elements[strFormControl].value;
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES6', '#sec-property-accessors', 'Property Accessors')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-11.2.1', 'Property Accessors')}}{{Spec2('ES5.1')}}
{{SpecName('ES1', '#sec-11.2.1', 'Property Accessors')}}{{Spec2('ES1')}}Изначальное определение.
+ +

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

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/spread_syntax/index.html b/files/ru/web/javascript/reference/operators/spread_syntax/index.html new file mode 100644 index 0000000000..c96be61337 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/spread_syntax/index.html @@ -0,0 +1,249 @@ +--- +title: Spread syntax +slug: Web/JavaScript/Reference/Operators/Spread_syntax +translation_of: Web/JavaScript/Reference/Operators/Spread_syntax +--- +
{{jsSidebar("Operators")}}
+ +
Spread syntax позволяет расширить доступные для итерации элементы (например, массивы или строки) в местах
+ + + +
{{EmbedInteractiveExample("pages/js/expressions-spreadsyntax.html")}}
+ + + +

Синтаксис

+ +

Для вызовов функций:

+ +
myFunction(...iterableObj);
+
+ +

Для литералов массива или строк:

+ +
[...iterableObj, '4', 'five', 6];
+ +

Для литералов объекта (новое в ECMAScript 2018):

+ +
let objClone = { ...obj };
+ +

Примеры

+ +

Spread в вызовах функций

+ +

Замена apply

+ +

Обычно используют {{jsxref( "Function.prototype.apply")}} в случаях, когда хотят использовать элементы массива в качестве аргументов функции.

+ +
function myFunction(x, y, z) { }
+var args = [0, 1, 2];
+myFunction.apply(null, args);
+ +

С spread syntax вышеприведенное можно записать как:

+ +
function myFunction(x, y, z) { }
+var args = [0, 1, 2];
+myFunction(...args);
+ +

Любой аргумент в списке аргументов может использовать spread syntax, и его можно использовать несколько раз.

+ +
function myFunction(v, w, x, y, z) { }
+var args = [0, 1];
+myFunction(-1, ...args, 2, ...[3]);
+ +

Apply для new

+ +

Вызывая конструктор через ключевое слово new, невозможно использовать массив и apply напрямую (apply выполняет [[Call]], а не [[Construct]]).Однако благодаря spread syntax, массив может быть с легкостью использован со словом new:

+ +
var dateFields = [1970, 0, 1];  // 1 Jan 1970
+var d = new Date(...dateFields);
+
+ +

Чтобы использовать new с массивом параметров без spread syntax, вам потребуется использование частичного применения:

+ +
function applyAndNew(constructor, args) {
+   function partial () {
+      return constructor.apply(this, args);
+   };
+   if (typeof constructor.prototype === "object") {
+      partial.prototype = Object.create(constructor.prototype);
+   }
+   return partial;
+}
+
+
+function myConstructor () {
+   console.log("arguments.length: " + arguments.length);
+   console.log(arguments);
+   this.prop1="val1";
+   this.prop2="val2";
+};
+
+var myArguments = ["hi", "how", "are", "you", "mr", null];
+var myConstructorWithArguments = applyAndNew(myConstructor, myArguments);
+
+console.log(new myConstructorWithArguments);
+// (internal log of myConstructor):           arguments.length: 6
+// (internal log of myConstructor):           ["hi", "how", "are", "you", "mr", null]
+// (log of "new myConstructorWithArguments"): {prop1: "val1", prop2: "val2"}
+ +

Spread в литералах массива

+ +

Более мощный литерал массива

+ +

Без spread syntax, применение синтаксиса литерала массива для создания нового массива на основе существующего недостаточно и требуется императивный код вместо комбинации методов push, splice, concat и т.д. С spread syntax реализация становится гораздо более лаконичной:

+ +
var parts = ['shoulders', 'knees'];
+var lyrics = ['head', ...parts, 'and', 'toes'];
+// ["head", "shoulders", "knees", "and", "toes"]
+
+ +

Аналогично развертыванию в массиве аргументов, ... может быть использован повсеместно и многократно в литерале массива.

+ +

Копирование массива

+ +
var arr = [1, 2, 3];
+var arr2 = [...arr]; // like arr.slice()
+arr2.push(4);
+
+// arr2 becomes [1, 2, 3, 4]
+// arr remains unaffected
+
+ +

Примечание: Spread syntax на самом деле переходит лишь на один уровень глубже при копировании массива. Таким образом, он может не подходить для копирования многоразмерных массивов, как показывает следующий пример: (также как и c {{jsxref("Object.assign()")}}) и синтаксис spred 

+ +
const a = [[1], [2], [3]];
+const b = [...a];
+b.shift().shift(); // 1
+// О нет. Теперь на массив "а" относятся также: а
+//[[], [2], [3]]
+
+ +

Лучший способ конкатенации массивов

+ +

Для конкатенации массива часто используется {{jsxref("Array.concat")}}:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+// Append all items from arr2 onto arr1
+arr1 = arr1.concat(arr2);
+ +

С использованием spread syntax:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+arr1 = [...arr1, ...arr2];
+
+ +

{{jsxref("Array.unshift")}} часто используется для вставки массива значений в начало существующего массива. Без spread syntax:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+// Prepend all items from arr2 onto arr1
+Array.prototype.unshift.apply(arr1, arr2) // arr1 is now [3, 4, 5, 0, 1, 2]
+ +

С использованием spread syntax [Следует отметить, что такой способ создает новый массив arr1. В отличие от {{jsxref("Array.unshift")}}, исходный массив не мутируется]:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+arr1 = [...arr2, ...arr1]; // arr1 is now [3, 4, 5, 0, 1, 2]
+
+ +

Spread в литералах объекта

+ +

Предложение Rest/Spread Properties for ECMAScript (стадия 4) добавляет свойства spread в литералы объекта. Оно копирует собственные перечисляемые свойства данного объекта в новый объект.

+ +

Поверхностное копирование (без прототипа) или объединение объектов теперь возможно с использованием более короткого, чем {{jsxref("Object.assign()")}}, синтаксиса.

+ +
var obj1 = { foo: 'bar', x: 42 };
+var obj2 = { foo: 'baz', y: 13 };
+
+var clonedObj = { ...obj1 };
+// Object { foo: "bar", x: 42 }
+
+var mergedObj = { ...obj1, ...obj2 };
+// Object { foo: "baz", x: 42, y: 13 }
+ +

Обратите внимание, что {{jsxref("Object.assign()")}} запускает setters, а spread syntax нет.

+ +

Обратите внимание, что вы не можете заменить или имитировать функцию {{jsxref("Object.assign()")}}:

+ +
var obj1 = { foo: 'bar', x: 42 };
+var obj2 = { foo: 'baz', y: 13 };
+const merge = ( ...objects ) => ( { ...objects } );
+
+var mergedObj = merge ( obj1, obj2);
+// Object { 0: { foo: 'bar', x: 42 }, 1: { foo: 'baz', y: 13 } }
+
+var mergedObj = merge ( {}, obj1, obj2);
+// Object { 0: {}, 1: { foo: 'bar', x: 42 }, 2: { foo: 'baz', y: 13 } }
+ +

В приведенном выше примере оператор распространения не работает так, как можно было бы ожидать: он распространяет массив аргументов в литерал объекта благодаря параметру rest.

+ +

Только для итерируемых объектов

+ +

Spread syntax ( кроме случаев spread properties) может быть применен только к итерируемым объектам (iterable objects) :

+ +
var obj = {'key1': 'value1'};
+var array = [...obj]; // TypeError: obj is not iterable
+
+ +

Spread с большим количеством значений

+ +

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

+ +

Rest синтаксис (параметры)

+ +

Синтаксис для rest оператора выглядит таким же как и для spread оператора, однако он используется для деструктуризации массивов и объектов. Фактически, rest оператор противоположен spread оператору: последний раскладывает массив на элементы, тогда как первый собирает много элементов в один. См. rest parameters.

+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES2015', '#sec-array-initializer')}}{{Spec2('ES2015')}}Defined in several sections of the specification: Array Initializer, Argument Lists
{{SpecName('ES2018', '#sec-object-initializer')}}{{Spec2('ES2018')}}Defined in Object Initializer
{{SpecName('ESDraft', '#sec-array-initializer')}}{{Spec2('ESDraft')}}Без изменений.
{{SpecName('ESDraft', '#sec-object-initializer')}}{{Spec2('ESDraft')}}Без изменений.
+ +

Browser compatibility

+ + + +

{{Compat("javascript.operators.spread")}}

+ +

See also

+ + diff --git a/files/ru/web/javascript/reference/operators/super/index.html b/files/ru/web/javascript/reference/operators/super/index.html new file mode 100644 index 0000000000..4f3b525185 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/super/index.html @@ -0,0 +1,186 @@ +--- +title: super +slug: Web/JavaScript/Reference/Operators/super +tags: + - ECMAScript 2015 + - JavaScript + - Классы +translation_of: Web/JavaScript/Reference/Operators/super +--- +
{{jsSidebar("Operators")}}
+ +

Ключевое слово super используется для вызова функций, принадлежащих родителю объекта.

+ +

Выражения: super.prop и super[expr] - действительны в любом методе определения в обоих классах и в литералах объекта.

+ +

Синтаксис

+ +
super([arguments]); // вызов родительского конструктора.
+super.functionOnParent([arguments]);
+
+ +

Описание

+ +

В конструкторе ключевое слово super() используется как функция, вызывающая родительский конструктор. Её необходимо вызвать до первого обращения к ключевому слову this в теле конструктора. Ключевое слово super также может быть использовано для вызова функций родительского объекта.

+ +

Пример

+ +

Использование super в классах

+ +

Этот фрагмент кода взят из classes sample (live demo). В этом примере super() вызывается , чтобы предотвратить использования одинакового для классов Rectangle and Square определения тела конструктора.

+ +
class Polygon {
+  constructor(height, width) {
+    this.name = 'Polygon';
+    this.height = height;
+    this.width = width;
+  }
+  sayName() {
+    console.log('Hi, I am a ', this.name + '.');
+  }
+}
+
+class Square extends Polygon {
+  constructor(length) {
+    this.height; // ReferenceError, super должен быть вызыван первым!
+
+    // Здесь, вызывается метод конструктора родительского класса с длинами,
+    // указанными для ширины и высоты класса Polygon
+    super(length, length);
+
+    // Примечание: в производных классах, super() необходимо вызывать прежде чем
+    // использывать 'this'. Если этого не сделать будет сообщение об ошибке ссылки.
+    this.name = 'Square';
+  }
+
+  get area() {
+    return this.height * this.width;
+  }
+
+  set area(value) {
+    this.area = value;
+  }
+}
+ +

Супер-вызовы статических методов

+ +

Вы так же можете вызывать super на статических методах.

+ +
class Rectangle {
+  constructor() {}
+  static logNbSides() {
+    return 'У меня 4 стороны,';
+  }
+}
+
+class Square extends Rectangle {
+  constructor() {}
+  static logDescription() {
+    return super.logNbSides() + ' которые все равны';
+  }
+}
+Square.logDescription(); // 'У меня 4 стороны, которые все равны'
+ +

Удаление свойств super вызывает ошибку

+ +

Вы не можете использовать delete operator и super.prop или super[expr] при удалении родительского класса он выдаст:{{jsxref("ReferenceError")}}.

+ +
class Base {
+  constructor() {}
+  foo() {}
+}
+class Derived extends Base {
+  constructor() {}
+  delete() {
+    delete super.foo; // это плохо
+  }
+}
+
+new Derived().delete(); // ReferenceError: invalid delete involving 'super'.
+ +

super.prop не может переопределять свойства, защищённые от записи

+ +

При определении незаписываемых свойств с помощью, например, {{jsxref("Object.defineProperty")}}, super не может перезаписать значение свойства.

+ +
class X {
+  constructor() {
+    Object.defineProperty(this, 'prop', {
+      configurable: true,
+      writable: false,
+      value: 1
+    });
+  }
+}
+
+class Y extends X {
+  constructor() {
+    super();
+  }
+  foo() {
+    super.prop = 2;   // Не возможно перезаписать значение.
+  }
+}
+
+var y = new Y();
+y.foo(); // TypeError: "prop" доступен только для чтения
+console.log(y.prop); // 1
+ +

Использование super.prop в объектных литералах

+ +

Super также можно использовать в объекте инициализатора / литерала. В этом примере, два объекта определяют метод. Во втором объекте, super вызывает первый метод объекта. Это работает с помощью {{jsxref("Object.setPrototypeOf()")}}, с которой мы можем установить прототип для obj2 в obj1, так что super может найти method1 в obj1.

+ +
var obj1 = {
+  method1() {
+    console.log("method 1");
+  }
+}
+
+var obj2 = {
+  method2() {
+   super.method1();
+  }
+}
+
+Object.setPrototypeOf(obj2, obj1);
+obj2.method2(); // logs "method 1"
+
+ +

Характеристики

+ + + + + + + + + + + + + + + + + + + +
ХарактеристикиСтатусКомментарий
{{SpecName('ES6', '#sec-super-keyword', 'super')}}{{Spec2('ES6')}}Initial definition.
{{SpecName('ESDraft', '#sec-super-keyword', 'super')}}{{Spec2('ESDraft')}}
+ +

Совместимость в браузерах

+ +

{{Compat("javascript.operators.super")}}

+ +
+ +

Gecko specific notes

+ + + +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/this/index.html b/files/ru/web/javascript/reference/operators/this/index.html new file mode 100644 index 0000000000..cfd5ae4385 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/this/index.html @@ -0,0 +1,412 @@ +--- +title: this +slug: Web/JavaScript/Reference/Operators/this +tags: + - JavaScript + - Operator + - Reference + - this + - свойства языка +translation_of: Web/JavaScript/Reference/Operators/this +--- +
{{jsSidebar("Operators")}}
+ +

Поведение ключевого слова this в JavaScript несколько отличается по сравнению с остальными языками. Имеются также различия при использовании this в строгом и нестрогом режиме.

+ +

В большинстве случаев значение this определяется тем, каким образом вызвана функция. Значение this не может быть установлено путем присваивания во время исполнения кода и может иметь разное значение при каждом вызове функции. В ES5 представлен метод {{jsxref('Function.prototype.bind()', 'bind()')}}, который используется для {{jsxref('Operators/this','привязки значения ключевого слова this независимо от того, как вызвана функция','Метод_bind')}}. Также в ES2015 представлены {{jsxref('Functions/Arrow_functions', 'стрелочные функции')}}, которые не создают собственные привязки к this (они сохраняют значение this лексического окружения, в котором были созданы).

+ +
{{EmbedInteractiveExample("pages/js/expressions-this.html")}}
+ + + +

Синтаксис

+ +
this
+ +

Значение

+ +

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

+ +

Global контекст

+ +

В глобальном контексте выполнения (за пределами каких-либо функций) this ссылается на глобальный объект вне зависимости от режима (строгий или нестрогий).

+ +
// В браузерах, объект window также является объектом global:
+console.log(this === window); // true
+
+a = 37;
+console.log(window.a); // 37
+
+this.b = "MDN";
+console.log(window.b)  // "MDN"
+console.log(b)         // "MDN"
+
+ +
+

Note: Вы всегда можете легко получить объект global, используя глобальное свойство {{jsxref ("globalThis")}}, независимо от текущего контекста, в котором выполняется ваш код.

+
+ +

Function контекст

+ +

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

+ +

Простой вызов

+ +

Поскольку следующий код не в {{jsxref('Strict_mode', 'строгом режиме')}}, и значение this не устанавливается вызовом, по умолчанию будет использоваться объект global, которым в браузере является {{domxref('window')}}.

+ +
function f1(){
+  return this;
+}
+
+// В браузере:
+f1() === window; // window - глобальный объект в браузере
+
+// В Node:
+f1() === global; // global - глобальный объект в Node
+
+ +

В строгом режиме, если значение this не установлено в контексте выполнения, оно остается undefined, как показано в следующем примере:

+ +
function f2(){
+  "use strict"; // см. strict mode
+  return this;
+}
+
+f2() === undefined; // true
+
+ +
Во втором примере this должно иметь значение {{jsxref("undefined")}}, потому что функция f2 была вызвана напрямую, а не как метод или свойство объекта (например, window.f2()). Реализация этой особенности не поддерживалась в некоторых браузерах, когда они впервые начали поддерживать {{jsxref('Strict_mode', 'строгий режим')}}. В результате они некорректно возвращали объект window.
+ +

Для того, чтобы при вызове функции установить this в определенное значение, используйте {{jsxref('Function.prototype.call()', 'call()')}} или {{jsxref('Function.prototype.apply()', 'apply()')}}, как в следующих примерах.

+ +

Пример 1

+ +
// В качестве первого аргумента методов call или apply может быть передан объект,
+// на который будет указывать this.
+var obj = {a: 'Custom'};
+
+// Это свойство принадлежит глобальному объекту
+var a = 'Global';
+
+function whatsThis() {
+  return this.a;  //значение this зависит от контекста вызова функции
+
+}
+
+whatsThis();          // 'Global'
+whatsThis.call(obj);  // 'Custom'
+whatsThis.apply(obj); // 'Custom'
+ +

Пример 2

+ +
function add(c, d) {
+  return this.a + this.b + c + d;
+}
+
+var o = {a: 1, b: 3};
+
+// Первый параметр - это объект для использования в качестве
+// 'this', последующие параметры передаются как
+// аргументы функции call
+add.call(o, 5, 7); // 16
+
+// Первый параметр - это объект для использования в качестве
+// 'this', второй - массив, чьи члены используются
+// в качестве аргументов функции call
+add.apply(o, [10, 20]); // 34
+
+ +

Обратите внимание, что в нестрогом режиме, если значение, переданное в call или apply как this, не является объектом, будет сделана попытка преобразовать его в объект с помощью внутренней операции ToObject. Таким образом, если переданное значение является примитивом, таким как 7 или 'foo', оно будет преобразовано в Object с использованием связанного конструктора, так что примитивное число 7 будет преобразовано в объект так, как будто с помощью new Number(7), а строка 'foo' - как будто с помощью new String('foo'), например

+ +
function bar() {
+  console.log(Object.prototype.toString.call(this));
+}
+
+bar.call(7);     // [object Number]
+bar.call('foo'); // [object String]
+
+ +

Метод bind

+ +

ECMAScript 5 представил {{jsxref("Function.prototype.bind()")}}. Вызов f.bind(someObject) создает новую функцию с тем же телом и областью действия, что и f, но там, где в исходной функции используется this, в новой функции оно постоянно будет связано с первым аргументом bind, независимо от того, как функция используется.

+ +
function f() {
+  return this.a;
+}
+
+var g = f.bind({a: 'azerty'});
+console.log(g()); // azerty
+
+var h = g.bind({a: 'yoo'}); // bind only works once!
+console.log(h()); // azerty
+
+var o = {a: 37, f: f, g: g, h: h};
+console.log(o.a, o.f(), o.g(), o.h()); // 37,37, azerty, azerty
+ +

Стрелочные функции

+ +

В {{jsxref('Functions/Arrow_functions', 'стрелочных функциях')}}, this привязан к окружению, в котором была создана функция. В глобальной области видимости this будет указывать на глобальный объект.

+ +
var globalObject = this;
+var foo = (() => this);
+console.log(foo() === globalObject); // true
+ +
+

Note: если аргумент this передаётся в call, bind или apply при вызове стрелочной функции, он будет проигнорирован. Вы всё ещё можете добавить аргументы к вызову, но первый аргумент (thisArg) должен быть установлен в null.

+
+ +

Неважно, как стрелочная функция foo() будет вызвана, её значение this будет указывать на глобальный объект. this будет сохранять свое значение, даже если функция foo() будет вызвана как метод объекта (что в обычных функциях связывает this с объектом вызова) или с использованием методов call, apply или bind:

+ +
// Вызов функции как метода объекта
+var obj = {foo: foo};
+console.log(obj.foo() === globalObject); // true
+
+// Попытка установить this с помощью call
+console.log(foo.call(obj) === globalObject); // true
+
+// Попытка установить this с помощью bind
+foo = foo.bind(obj);
+console.log(foo() === globalObject); // true
+ +

Несмотря ни на что, this стрелочной функции foo() имеет то же значение, что и при создании функции (глобальный объект в примере выше). То же самое касается стрелочных функций, созданных внутри других функций: их this будет привязан к окружению.

+ +
// Создаем объект obj, содержащий метод bar, который возвращает функцию,
+// которая возвращает свой this. Возвращаемая функция создана
+// как стрелочная функция, таким образом её this постоянно замкнут
+// на this функции, в которой она создана. Значение bar может быть установлено
+// в вызове, который, в свою очередь, устанавливает значение возвращаемой функции.
+var obj = { bar : function() {
+                    var x = (() => this);
+                    return x;
+                  }
+          };
+
+// Вызываем bar как метод объекта obj, устанавливая его this на obj
+// Присваиваем ссылку возвращаемой функции переменной fn
+var fn = obj.bar();
+
+// Вызываем fn без установки this, что в обычных функциях указывало бы
+// на глобальный объект или undefined в строгом режиме.
+console.log(fn() === obj); // true
+
+// Но будьте осторожны, если вы ссылаетесь на метод obj, не вызывая его
+var fn2 = obj.bar;
+// Вызов this стрелочной функции изнутри метода bar вернёт теперь window,
+// потому что он следует за this из fn2.
+console.log(fn2()() == window); // true
+ +

В примере выше, функция (назовем её анонимной функцией A), присвоенная методу obj.bar, возвращает другую функцию (назовем её анонимной функцией B) которая создана как стрелочная функция. В результате, this функции B при вызове замкнут на this, принадлежащий obj.bar (функции A). this функции B всегда будет иметь то значение, которое он получил при создании. В примере выше, this функции B указывает на this функции A,которым является obj, таким образом this будет равен obj даже тогда, когда будет вызван методом, который в нормальных условиях устанавливал бы значение this равным undefined или глобальному обьекту (или любым другим методом, как в предыдущем примере в глобальном контексте выполнения).

+ +

В методе объекта

+ +

Когда функция вызывается как метод объекта, используемое в этой функции ключевое слово this принимает значение объекта, по отношению к которому вызван метод.

+ +

В следующем примере, когда вызвано свойство o.f() , внутри функции this привязано к объекту o.

+ +
var o = {
+  prop: 37,
+  f: function() {
+    return this.prop;
+  }
+};
+
+console.log(o.f()); // logs 37
+
+ +

Необходимо отметить, что на поведение this совсем не влияет то, как или где была определена функция. В предыдущем примере мы определили функцию внутри свойства f во время определения объекта o. Однако, мы могли бы также просто определить сначала функцию, а затем закрепить ее за за свойством o.f. В этом случае поведение this не изменится:

+ +
var o = {prop: 37};
+
+function independent() {
+  return this.prop;
+}
+
+o.f = independent;
+
+console.log(o.f()); // logs 37
+
+ +

Эти примеры показывают, что имеет значение только то, что функция была вызвана из свойства f объекта o.

+ +

Аналогично, привязывание this обуславливается наличием ближайшей ссылки на объект или свойство. В следующем примере, когда мы вызываем функцию, мы обращаемся к ней как к методу g объекта o.b. На этот раз во время выполнения, this, что находится внутри функции, будет ссылаться на o.b. Тот факт, что объект является членом объекта o, не имеет значения; важна только ближайшая ссылка.

+ +
o.b = {g: independent, prop: 42};
+console.log(o.b.g()); // logs 42
+
+ +

this в цепочке object's prototype

+ +

Это же представление справедливо и для методов, определенных где-либо в цепочке object's prototype. Если метод находится в цепочке прототипов, то this ссылается на объект, на котором был вызван метод, т.е. так, словно метод является методом самого объекта, а не прототипа.

+ +
var o = {f:function(){ return this.a + this.b; }};
+var p = Object.create(o);
+p.a = 1;
+p.b = 4;
+
+console.log(p.f()); // 5
+
+ +

В этом примере объект, которому присвоена переменная p, не имеет собственного свойства f, а наследует это свойство от своего прототипа. Однако, совершенно неважно, что поиск свойства f в конце концов обнаружит его на объекте o. Поскольку поиск начался с p.f, то и свойство this внутри функции f будет ссылаться на объект p. Таким образом, если f вызывается как метод p, то и this относится к p. Это полезная особенность прототипного наследования JS.

+ +

this с геттерами/сеттерами

+ +

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

+ +
function modulus(){
+  return Math.sqrt(this.re * this.re + this.im * this.im);
+}
+
+var o = {
+  re: 1,
+  im: -1,
+  get phase(){
+    return Math.atan2(this.im, this.re);
+  }
+};
+
+Object.defineProperty(o, 'modulus', {
+    get: modulus, enumerable:true, configurable:true});
+
+console.log(o.phase, o.modulus); // logs -0.78 1.4142
+
+ +

В конструкторе

+ +

Когда функция используется как конструктор (с ключевым словом new ), this связано с создаваемым новым объектом.

+ +

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

+ +
/*
+ * Конструктор работает таким образом:
+ *
+ * function MyConstructor(){
+ *   // фактический код, составляющий тело функции.
+ *   // создание свойств с |this| по
+ *   // желанию, определяя их значения; например,
+ *   this.fum = "nom";
+ *   // и т.д.
+ *
+ *   // Если функция возвращает выражение,
+ *   // возвращающее объект, этот объект будет
+ *   // результатом выражения |new|. В обратном случае,
+ *   // результат выражения - объект,
+ *   // в данный момент привязанный к |this|
+ *   // (т.е. наиболее часто встречающийся случай).
+ * }
+ */
+
+function C() {
+  this.a = 37;
+}
+
+var o = new C();
+console.log(o.a); // logs 37
+
+
+function C2() {
+  this.a = 37;
+  return {a: 38};
+}
+
+o = new C2();
+console.log(o.a); // logs 38
+
+ +

В последнем примере (C2), из-за того, что конструктор вернул объект, новый объект, к которому было привязано this, был просто отброшен. (Это фактически делает выражение "this.a = 37;" "мертвым" кодом. Он не является буквально нерабочим, так как он выполняется, но он может быть изъят без каких-либо внешних эффектов.)

+ +

call и apply

+ +

Когда в теле функции используется ключевое слово this, его значение может быть привязано к конкретному объекту в вызове при помощи методов call или apply, которые наследуются всеми функциями от Function.prototype.

+ +
function add(c, d) {
+  return this.a + this.b + c + d;
+}
+
+var o = {a: 1, b: 3};
+
+// Первый параметр - это объект, который следует использовать как
+// 'this', последующие параметры передаются
+// как аргументы при вызове функции
+add.call(o, 5, 7); // 1 + 3 + 5 + 7 = 16
+
+// Первый параметр - объект, который следует использовать как
+// 'this', второй параметр - массив,
+// элементы которого используются как аргументы при вызове функции
+add.apply(o, [10, 20]); // 1 + 3 + 10 + 20 = 34
+
+ +

Необходимо отметить, что если методам call и apply передается значение с this, которое не является при этом объектом, будет предпринята попытка конвертировать значение в объект, используя внутреннюю операцию ToObject. Если переданное значение является примитивным типом, например 7 или 'foo', оно будет преобразовано в объект с использованием родственного конструктора, так примитив 7 преобразовывается в объект через new Number(7), а строка 'foo' в объект через new String('foo'), и т.д.

+ +
function bar() {
+  console.log(Object.prototype.toString.call(this));
+}
+
+bar.call(7); // [object Number]
+
+ +

Как обработчик событий DOM

+ +

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

+ +
// Когда вызывается как слушатель, связанный элемент становится синим
+function bluify(e) {
+  // Всегда true
+  console.log(this === e.currentTarget);
+  // true, когда currentTarget и target один объект
+  console.log(this === e.target);
+  this.style.backgroundColor = '#A5D9F3';
+}
+
+// Получить список каждого элемента в документе
+var elements = document.getElementsByTagName('*');
+
+// Добавить bluify как слушателя кликов, чтобы при
+// нажатии на элемент он становился синим
+for (var i = 0; i < elements.length; i++) {
+  elements[i].addEventListener('click', bluify, false);
+}
+ +

В инлайновом обработчике событий

+ +

Когда код вызван из инлайнового обработчика, this указывает на DOM элемент, в котором расположен код события:

+ +
<button onclick="alert(this.tagName.toLowerCase());">
+  Показать this
+</button>
+
+ +

Код выше выведет 'button'. Следует отметить, что this будет указывать на DOM элемент только во внешних (не вложенных) функциях:

+ +
<button onclick="alert((function() {return this;} ()));">
+  Показать вложенный this
+</button>
+
+ +

В этом случае this вложенной функции не будет установлен, так что будет возвращен global/window объект.

+ +

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

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-this-keyword', 'The this keyword')}}
+ +

Совместимость

+ + + +

{{Compat("javascript.operators.this")}}

+ +

Смотри также

+ + diff --git a/files/ru/web/javascript/reference/operators/typeof/index.html b/files/ru/web/javascript/reference/operators/typeof/index.html new file mode 100644 index 0000000000..f3a5ca27a3 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/typeof/index.html @@ -0,0 +1,242 @@ +--- +title: typeof +slug: Web/JavaScript/Reference/Operators/typeof +tags: + - JavaScript + - Оператор +translation_of: Web/JavaScript/Reference/Operators/typeof +--- +
{{jsSidebar("Operators")}}
+ +

Оператор typeof возвращает строку, указывающую тип операнда.

+ +
{{EmbedInteractiveExample("pages/js/expressions-typeof.html")}}
+ +

Синтаксис

+ +

Операнд следует за оператором typeof:

+ +
typeof operand
+ +

Параметры

+ +

operand является выражением, представляющим объект или {{Glossary("Primitive", "примитив")}}, тип которого должен быть возвращен.

+ +

Описание

+ +

В следующей таблице приведены возможные возвращаемые значения typeof. Дополнительная информация о типах и примитивах находится на странице структуры данных JavaScript.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TypeResult
Undefined"undefined"
Null"object" (смотрите ниже)
Boolean"boolean"
Number"number"
String"string"
Symbol (новый тип из ECMAScript 2015)"symbol"
Host object (определено JS окружением)Зависит от реализации
Function object (реализует [[Call]] в терминах ECMA-262)"function"
Любой другой тип"object"
+ +

Примеры

+ +
// Числа
+typeof 37 === 'number';
+typeof 3.14 === 'number';
+typeof(42) === 'number';
+typeof Math.LN2 === 'number';
+typeof Infinity === 'number';
+typeof NaN === 'number'; // несмотря на то, что это "Not-A-Number" (не число)
+typeof Number(1) === 'number'; // никогда не используйте эту запись!
+
+
+// Строки
+typeof '' === 'string';
+typeof 'bla' === 'string';
+typeof '1' === 'string'; // обратите внимание, что число внутри строки всё равно имеет тип строки
+typeof (typeof 1) === 'string'; // typeof всегда вернёт в этом случае строку
+typeof String('abc') === 'string'; // никогда не используйте эту запись!
+
+
+// Booleans
+typeof true === 'boolean';
+typeof false === 'boolean';
+typeof Boolean(true) === 'boolean'; // никогда не используйте эту запись!
+
+
+// Символы
+typeof Symbol() === 'symbol'
+typeof Symbol('foo') === 'symbol'
+typeof Symbol.iterator === 'symbol'
+
+
+// Undefined
+typeof undefined === 'undefined';
+typeof declaredButUndefinedVariable === 'undefined';
+typeof undeclaredVariable === 'undefined';
+
+
+// Объекты
+typeof {a: 1} === 'object';
+
+// используйте Array.isArray или Object.prototype.toString.call
+// чтобы различить обычные объекты и массивы
+typeof [1, 2, 4] === 'object';
+
+typeof new Date() === 'object';
+
+
+// То что ниже приводит к ошибкам и проблемам. Не используйте!
+typeof new Boolean(true) === 'object';
+typeof new Number(1) === 'object';
+typeof new String('abc') === 'object';
+
+
+// Функции
+typeof function() {} === 'function';
+typeof class C {} === 'function';
+typeof Math.sin === 'function';
+
+ +

null

+ +
// Это было определено с рождения JavaScript
+typeof null === 'object';
+
+ +

 

+ +

В первой реализации JavaScript значения были представлены парой тип тега и значение. Тип тега для объектов равнялся 0. null был представлен как нулевой указатель (0x00 в большинстве платформ). Следовательно, тип тега для null равнялся нулю, поэтому возвращаемое значение typeof является фиктивным. (подробнее)

+ +

Исправление было предложено в ECMAScript (через отключение), но было отклонено. Это привело бы к тому, что typeof null === 'null'.

+ +

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

+ +
// Все функции-конструкторы, созданные с помощью 'new', будут иметь тип 'object'
+var str = new String('String');
+var num = new Number(100);
+
+typeof str; // Вернёт 'object'
+typeof num; // Вернёт 'object'
+
+// Но существует исключение для конструктора Function
+
+var func = new Function();
+
+typeof func; // Вернёт 'function'
+
+ +

Регулярные выражения

+ +

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

+ +
typeof /s/ === 'function'; // Chrome 1-12 Не соответствует ECMAScript 5.1
+typeof /s/ === 'object';   // Firefox 5+  Соответствует ECMAScript 5.1
+
+ +

Ошибки, связанные с временными мёртвыми зонами

+ +

До ECMAScript 2015, гарантировалось, что оператор typeof вернёт строку для любого операнда, с которым он был вызван. Это изменилось после добавления неподнимающихся объявлений let and const с блочной областью  видимости. Теперь, если переменные объявлены с помощью let и const, и для них вызывается typeof в блоке объявления переменных, но до объявления, то выбрасывается ReferenceError. Поведение отличается от необъявленных переменных, для которых typeof вернёт 'undefined'. Переменные с блочной областью видимости находятся в "временной мёртвой зоне", которая длится от начала блока до момента объявления переменных. В этой зоне попытка доступа к переменным выбрасывает исключение.

+ +
typeof undeclaredVariable === 'undefined';
+typeof newLetVariable; let newLetVariable; // ReferenceError
+typeof newConstVariable; const newConstVariable = 'hello'; // ReferenceError
+
+ +

Исключения

+ +

Во всех текущих браузерах существует нестандартный host-объект {{domxref("document.all")}}, который имеет тип Undefined.

+ +
typeof document.all === 'undefined';
+
+ +

Хотя спецификация разрешает собственные имена типов для нестандартных экзотических объектов, требуется чтобы эти имена отличались от предопределённых. Ситуация, когда document.all имеет тип undefined должна рассматриваться как исключительное нарушение правил.

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ESDraft', '#sec-typeof-operator', 'The typeof Operator')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-typeof-operator', 'The typeof Operator')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-11.4.3', 'The typeof Operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-11.4.3', 'The typeof Operator')}}{{Spec2('ES3')}} 
{{SpecName('ES1', '#sec-11.4.3', 'The typeof Operator')}}{{Spec2('ES1')}}Изначальное определение. Реализовано в JavaScript 1.1
+ +

Совместимость с браузерами

+ +

{{Compat("javascript.operators.typeof")}}

+ +

IE-специфичные замечания

+ +

В IE 6, 7 и 8 многие host-объекты являются объектами, но не функциями. Например:

+ +
typeof alert === 'object'
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/void/index.html b/files/ru/web/javascript/reference/operators/void/index.html new file mode 100644 index 0000000000..e415aacae7 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/void/index.html @@ -0,0 +1,150 @@ +--- +title: void operator +slug: Web/JavaScript/Reference/Operators/void +tags: + - JavaScript + - Операторы + - Унарные +translation_of: Web/JavaScript/Reference/Operators/void +--- +
{{jsSidebar("Operators")}}
+ +

Оператор void вычисляет переданное выражение и возвращает {{jsxref("Global_Objects/undefined", "undefined")}}.

+ +

Синтаксис

+ +
void expression
+ +

Описание

+ +

Этот оператор позволяет вставлять выражения, которые производят дополнительные действия, в места, где ожидается {{jsxref("Global_Objects/undefined", "undefined")}}.

+ +

Оператор void часто используется для получения примитивного значения undefined, используя "void(0)" (что эквивалентно "void 0"). В подобных случаях можно просто использовать глобальную переменную {{jsxref("Global_Objects/undefined", "undefined")}} (предполагая, что её значение по умолчанию не было изменено).

+ +

Самовызывающаяся функция (IIFE)

+ +

С оператором void можно использовать самовызывающиеся функции.

+ +
void function iife() {
+    var bar = function () {};
+    var baz = function () {};
+    var foo = function () {
+        bar();
+        baz();
+     };
+    var biz = function () {};
+
+    foo();
+    biz();
+}();
+
+ +

JavaScript URIs

+ +

Когда браузер переходит по javascript: URI, он вычисляет код в URI и заменяет содержание страницы возвращенным значением, если оно не равно {{jsxref("Global_Objects/undefined", "undefined")}}. Можно воспользоваться оператором void для возврата {{jsxref("Global_Objects/undefined", "undefined")}}. Например:

+ +
<a href="javascript:void(0);">
+  Click here to do nothing
+</a>
+
+<a href="javascript:void(document.body.style.backgroundColor='green');">
+  Click here for green background
+</a>
+
+ +

Однако заметим, что не рекомендуется использовать псевдо-протокол javascript:.  Лучше прибегнуть к другим альтернативам, таким, как обработчики событий.

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ESDraft', '#sec-void-operator', 'The void Operator')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-void-operator', 'The void Operator')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-11.4.2', 'The void Operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-11.4.2', 'The void Operator')}}{{Spec2('ES3')}} 
{{SpecName('ES1', '#sec-11.4.2', 'The void Operator')}}{{Spec2('ES1')}}Изначальное определение. Реализована в JavaScript 1.1.
+ +

Совместимость с браузерами

+ +

{{ 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() }}
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/operators/yield/index.html b/files/ru/web/javascript/reference/operators/yield/index.html new file mode 100644 index 0000000000..04552374c8 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/yield/index.html @@ -0,0 +1,94 @@ +--- +title: yield +slug: Web/JavaScript/Reference/Operators/yield +tags: + - ECMAScript6 + - JavaScript + - Генераторы + - Итераторы + - Оператор + - Экспериментальный +translation_of: Web/JavaScript/Reference/Operators/yield +--- +
{{jsSidebar("Operators")}}
+ +

Ключевое слово yield используется для остановки и возобновления функций-генераторов ({{jsxref("Statements/function*", "function*")}} или legacy generator function).

+ +

{{EmbedInteractiveExample("pages/js/expressions-yield.html")}}

+ +

Синтаксис

+ +
 [rv] = yield [[выражение]];
+ +
+
выражение
+
Возвращаемое выражение. Если не указано, то возвращается значение undefined.
+
rv
+
Возвращает необязательное значение, которое передаётся в next() генератора, чтобы возобновить его выполнение.
+
+ +

Описание

+ +

Ключевое слово yield вызывает остановку функции-генератора и возвращает текущее значение выражения, указанного после ключевого слова yield. Его можно рассматривать как аналог ключевого слова return в функции-генераторе.

+ +

На самом деле ключевое слово yield  возвращает объект с двумя параметрами, value и done. При этом, value является результатом вычисления выражения после yield, а done указывает, была ли завершена функция-генератор.

+ +

Во время остановки на операторе yield, выполнение кода в функции-генераторе не возобновится, пока не будет вызван метод next() возвращаемого функцией объекта-генератора. Это предоставляет непосредственный контроль за выполнением генератора и возвратом его значений.

+ +

Примеры

+ +

Следующий фрагмент кода содержит определение функции-генератора и вспомогательной функции:

+ +
function* foo(){
+  var index = 0;
+  while(index <= 2) // при достижении 2, done в yield станет true, а value undefined;
+    yield index++;
+}
+ +

После того как тело функции-генератора определено, оно может использоваться для получения итератора:

+ +
var iterator = foo();
+console.log(iterator.next()); // { value:0, done:false }
+console.log(iterator.next()); // { value:1, done:false }
+console.log(iterator.next()); // { value:2, done:false }
+console.log(iterator.next()); // { value:undefined, done:true }
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES2015', '#prod-YieldExpression', 'Yield')}}{{Spec2('ES2015')}}Изначальное определение.
{{SpecName('ESDraft', '#prod-YieldExpression', 'Yield')}}{{Spec2('ESDraft')}}
+ +

Совместимость с браузерами

+ +

{{Compat("javascript.operators.yield")}}

+ +

Cмотрите также

+ + + +
+
+
diff --git a/files/ru/web/javascript/reference/operators/yield_star_/index.html b/files/ru/web/javascript/reference/operators/yield_star_/index.html new file mode 100644 index 0000000000..c20f6969e6 --- /dev/null +++ b/files/ru/web/javascript/reference/operators/yield_star_/index.html @@ -0,0 +1,227 @@ +--- +title: yield* +slug: Web/JavaScript/Reference/Operators/yield* +translation_of: Web/JavaScript/Reference/Operators/yield* +--- +
{{jsSidebar("Operators")}}
+ +

Выражение yield* используется для того, чтобы "передать упраевление" функцией-генератором другому {{jsxref("Statements/function*", "генератору")}} или итерируемому объекту.

+ +

Синтаксис

+ +
 yield* [[expression]];
+ +
+
expression
+
Итерируемый объект
+
+ +

Описание

+ +

Выражение yield* в функции-генераторе принимает итерируемый объект и возвращает его значения по очереди, как если бы эта функция-генератор возвращала иъ сама.

+ +

Значение выражения yield* само по себе равно посленему значению итурируемого объекта (т.е., того когда done равно true).

+ +

Примеры

+ +

Передача другому генератору

+ +

В следующем примере, значения полученные из g1() возвращаются из g2 вызовами next, как будто бы она вычислила их сама.

+ +
function* g1() {
+  yield 2;
+  yield 3;
+  yield 4;
+}
+
+function* g2() {
+  yield 1;
+  yield* g1();
+  yield 5;
+}
+
+var iterator = g2();
+
+console.log(iterator.next()); // { value: 1, done: false }
+console.log(iterator.next()); // { value: 2, done: false }
+console.log(iterator.next()); // { value: 3, done: false }
+console.log(iterator.next()); // { value: 4, done: false }
+console.log(iterator.next()); // { value: 5, done: false }
+console.log(iterator.next()); // { value: undefined, done: true }
+
+ +

Другие итерируемые объекты

+ +

Помимо объектов генераторов, yield* может перебирать другие виды итерируемых объектов, т.е. массивы, строки, объекты аргументов и др.

+ +
function* g3() {
+  yield* [1, 2];
+  yield* "34";
+  yield* Array.from(arguments);
+  // Определение этого итератора ниже
+  yield* new PowesOfTwo(4)
+}
+
+var iterator = g3(5, 6);
+
+// Значения из массива
+console.log(iterator.next()); // { value: 1, done: false }
+console.log(iterator.next()); // { value: 2, done: false }
+// Из строки
+console.log(iterator.next()); // { value: "3", done: false }
+console.log(iterator.next()); // { value: "4", done: false }
+// Из аргументов
+console.log(iterator.next()); // { value: 5, done: false }
+console.log(iterator.next()); // { value: 6, done: false }
+// Из специального итератора
+console.log(iterator.next()); // { value: 1, done: false }
+console.log(iterator.next()); // { value: 2, done: false }
+console.log(iterator.next()); // { value: 4, done: false }
+
+console.log(iterator.next()); // { value: undefined, done: true }
+
+// Итератор, который возвращает все степени двойки
+// до maximum включительно
+class PowersOfTwo {
+  constructor(maximum) {
+    this.maximum = maximum
+    this.value = 1
+  }
+  [Symbol.iterator]() {
+    const self = this
+    return {
+      next() {
+        if(self.value > self.maximum) return { done: true }
+
+        const value = self.value
+        self.value *= 2
+        return { done: false, value }
+      }
+    }
+  }
+}
+
+ +

Собственное значение выражения yield*

+ +

yield* - это выражение, а не оператор, поэтому оно имеет значение, равное последнему значению итератора 

+ +
function* g4() {
+  yield* [1, 2, 3];
+  return "foo";
+}
+
+var result;
+
+function* g5() {
+  result = yield* g4();
+}
+
+var iterator = g5();
+
+console.log(iterator.next()); // { value: 1, done: false }
+console.log(iterator.next()); // { value: 2, done: false }
+console.log(iterator.next()); // { value: 3, done: false }
+console.log(iterator.next()); // { value: undefined, done: true },
+                              // g4() в этой точке вернёт { value: "foo", done: true }
+
+console.log(result);          // "foo"
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#', 'Yield')}}{{Spec2('ES6')}}Initial definition.
{{SpecName('ESDraft', '#', 'Yield')}}{{Spec2('ESDraft')}}
+ +

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

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Basic support{{CompatVersionUnknown}}{{CompatGeckoDesktop("27.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureAndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatGeckoMobile("27.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Специфичные для Firefox примечания

+ + + +

See also

+ + diff --git "a/files/ru/web/javascript/reference/operators/\320\263\321\200\321\203\320\277\320\277\320\270\321\200\320\276\320\262\320\272\320\260/index.html" "b/files/ru/web/javascript/reference/operators/\320\263\321\200\321\203\320\277\320\277\320\270\321\200\320\276\320\262\320\272\320\260/index.html" new file mode 100644 index 0000000000..ecc180ab21 --- /dev/null +++ "b/files/ru/web/javascript/reference/operators/\320\263\321\200\321\203\320\277\320\277\320\270\321\200\320\276\320\262\320\272\320\260/index.html" @@ -0,0 +1,91 @@ +--- +title: Оператор группировки +slug: Web/JavaScript/Reference/Operators/Группировка +tags: + - JavaScript + - Оператор + - Основные выражения +translation_of: Web/JavaScript/Reference/Operators/Grouping +--- +
{{jsSidebar("Operators")}}
+ +

Оператор группировки ( ) контролирует порядок выполнения в выражениях.

+ +
{{EmbedInteractiveExample("pages/js/expressions-groupingoperator.html")}}
+ + + +

Синтаксис

+ +
 ( )
+ +

Описание

+ +

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

+ +

Примеры

+ +

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

+ +
let a = 1;
+let b = 2;
+let c = 3;
+
+// обычный порядок
+a + b * c     // 7
+// выполнится так
+a + (b * c)   // 7
+
+// теперь переопределим порядок
+// сложение будет до умножения
+(a + b) * c   // 9
+
+// что эквивалентно следующему
+a * c + b * c // 9
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ESDraft', '#sec-grouping-operator', 'The Grouping Operator')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-grouping-operator', 'The Grouping Operator')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-11.1.6', 'The Grouping Operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES1', '#sec-11.1.4', 'The Grouping Operator')}}{{Spec2('ES1')}}Изначальное определение.
+ +

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

+ + + +

{{Compat("javascript.operators.grouping")}}

+ +

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

+ + diff --git "a/files/ru/web/javascript/reference/operators/\320\272\320\276\320\275\320\262\320\265\320\271\320\265\321\200\320\275\321\213\320\271_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200/index.html" "b/files/ru/web/javascript/reference/operators/\320\272\320\276\320\275\320\262\320\265\320\271\320\265\321\200\320\275\321\213\320\271_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200/index.html" new file mode 100644 index 0000000000..fa43c6d346 --- /dev/null +++ "b/files/ru/web/javascript/reference/operators/\320\272\320\276\320\275\320\262\320\265\320\271\320\265\321\200\320\275\321\213\320\271_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200/index.html" @@ -0,0 +1,77 @@ +--- +title: Конвейерный оператор +slug: Web/JavaScript/Reference/Operators/Конвейерный_оператор +tags: + - Experimental + - JavaScript + - Operator + - Оператор + - Экспериментальный +translation_of: Web/JavaScript/Reference/Operators/Pipeline_operator +--- +
{{jsSidebar("Operators")}} {{SeeCompatTable}}
+ +

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

+ +
let url = "%21" |> decodeURI;
+
+ +

Эквивалентный вызов в традиционном синтаксисе выглядит следующим образом:

+ +
let url = decodeURI("%21");
+
+ +

Синтаксис

+ +
выражение |> функция
+ +

Значение указанного выражения передаётся в функцию в качестве единственного параметра.

+ +

Примеры

+ +

Цепочки вызовов функций

+ +

Конвейерный оператор позволяет улучшить читаемость кода, в случае когда встречается цепочка из нескольких функций.

+ +
const double = (n) => n * 2;
+const increment = (n) => n + 1;
+
+// без конвейерного оператора
+double(increment(double(double(5)))); // 42
+
+// с конвейерным оператором
+5 |> double |> double |> increment |> double; // 42
+
+ +

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

+ + + + + + + + + + + + + + + + +
СпецификацияСтатусComment
Pipeline operator draftЭтап 1Еще не включен в спецификацию ECMAScript.
+ +

Совместимость с браузерами

+ +
+ + +

{{Compat("javascript.operators.pipeline")}}

+
+ +

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

+ + diff --git "a/files/ru/web/javascript/reference/operators/\320\273\320\276\320\263\320\270\321\207\320\265\321\201\320\272\320\270\320\265_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200\321\213/index.html" "b/files/ru/web/javascript/reference/operators/\320\273\320\276\320\263\320\270\321\207\320\265\321\201\320\272\320\270\320\265_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200\321\213/index.html" new file mode 100644 index 0000000000..43878ea58c --- /dev/null +++ "b/files/ru/web/javascript/reference/operators/\320\273\320\276\320\263\320\270\321\207\320\265\321\201\320\272\320\270\320\265_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200\321\213/index.html" @@ -0,0 +1,299 @@ +--- +title: Логические операторы +slug: Web/JavaScript/Reference/Operators/Логические_операторы +translation_of: Web/JavaScript/Reference/Operators +--- +
{{jsSidebar("Operators")}}
+ +
Логические операторы используются, как правило, с примитивами {{jsxref("Boolean")}} (логического) типа. В этом случае результатом работы оператора является значение типа Boolean. Между тем операторы && и || возвращают, вообще говоря, значение одного из операнда, потому при использовании в качестве аргументов этих операторов величин, тип которых отличен от Boolean, тип возвращаемого значения может быть отличным от Boolean.
+ +
+ +

Описание

+ +

В таблице приведены описания логических операторов:

+ + + + + + + + + + + + + + + + + + + + + + + + +
ОператорИспользованиеОписание
Логическое И (&&)expr1 && expr2Возвращает значение expr1, если оно может быть преобразовано в false; иначе возвращает значение expr2. Таким образом, при использовании с величинами типа Boolean оператор && вернет true, если оба операнда могут быть преобразованы в true; иначе оператор && вернет false. 
Логическое ИЛИ (||)expr1 || expr2 +

Возвращает значение expr1, если оно может быть преобразовано в true; иначе возвращает значение expr2. Таким образом, при использовании с величинами типа Boolean оператор || вернет true если хоть один из них равен true; в других случаях вернет false.

+
Логическое НЕ (!)!exprВозвращает false если значение expr можно привести к true;  в противоположном случае возвращает true.
+ +

Примеры значений выражений, которые могут быть преобразованы в false:

+ + + +

Хоть операторы && и || могут использовать операнды с не булевыми значениями, но они всёравно рассматриваются, как булевы операторы, т.к. их возвращаемые ими значения всегда могут быть сконвертированы в булевы значения.

+ +

Короткая схема вычислений

+ +

Так как логические операторы выполняются слева направо, они проверяются на "короткие вычисления" по следующим правилам:

+ + + +

Часть выражения (anything) не вычисляется. Если в ней есть вызов функции, то эта функция не будет вызвана.

+ +

Например, следующие две функции делают одно и тоже:

+ +
function shortCircuitEvaluation() {
+  doSomething() || doSomethingElse()
+}
+
+function equivalentEvaluation() {
+  var flag = doSomething();
+  if (!flag) {
+    doSomethingElse();
+  }
+}
+
+ +

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

+ +
false && true  || true      // вернёт true
+false && (true || true)     // вернёт false
+ +

Логическое И (&&)

+ +

Следующий код показывает пример оператора && (логическое И).

+ +
a1 = true  && true      // t && t вернёт true
+a2 = true  && false     // t && f вернёт false
+a3 = false && true      // f && t вернёт false
+a4 = false && (3 == 4)  // f && f вернёт false
+a5 = "Cat" && "Dog"     // t && t вернёт "Dog"
+a6 = false && "Cat"     // f && t вернёт false
+a7 = "Cat" && false     // t && f вернёт false
+
+ +

Логическое ИЛИ (||)

+ +

Это код представляет собой пример оператора || (логическое ИЛИ).

+ +
o1 = true  || true       // t || t вернёт true
+o2 = false || true       // f || t вернёт true
+o3 = true  || false      // t || f вернёт true
+o4 = false || (3 == 4)   // f || f вернёт false
+o5 = "Cat" || "Dog"      // t || t вернёт "Cat"
+o6 = false || "Cat"      // f || t вернёт "Cat"
+o7 = "Cat" || false      // t || f вернёт "Cat"
+
+ +

Логическое НЕ (!)

+ +

Следующий код является примером оператора ! (логическое НЕ).

+ +
n1 = !true              // !t вернёт false
+n2 = !false             // !f вернёт true
+n3 = !"Cat"             // !t вернёт false
+
+ +

Правила преобразования

+ +

Конвертирование И в ИЛИ

+ +

следующая операция использует булев тип:

+ +
bCondition1 && bCondition2
+ +

это всегда равно:

+ +
!(!bCondition1 || !bCondition2)
+ +

Конвертирование ИЛИ в И

+ +

эта операция использует булев тип:

+ +
bCondition1 || bCondition2
+ +

что эквивалентно:

+ +
!(!bCondition1 && !bCondition2)
+ +

Конвертирование многих НЕ

+ +

следующая операция использует булев тип:

+ +
!!bCondition
+ +

что равно:

+ +
bCondition
+ +

Удаление вложенных скобок

+ +

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

+ +

Удаление вложенных И

+ +

Это составное выражение использует булев тип:

+ +
bCondition1 || (bCondition2 && bCondition3)
+ +

что будет равным:

+ +
bCondition1 || bCondition2 && bCondition3
+ +

Удаление вложенного ИЛИ

+ +

Следующее составное выражение использует булев тип:

+ +
bCondition1 && (bCondition2 || bCondition3)
+ +

всегда равно:

+ +
!(!bCondition1 || !bCondition2 && !bCondition3)
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES5.1')}}{{Spec2('ES1')}}Изначальное определение
{{SpecName('ES5.1', '#sec-11.11')}}{{Spec2('ES5.1')}}Определено в нескольких секциях спецификации: Логический оператор НЕ, Бинарные логические операторы
{{SpecName('ES6', '#sec-binary-logical-operators')}}{{Spec2('ES6')}}Определено в нескольких секциях спецификации: Логический оператор НЕ, Бинарные логические операторы
{{SpecName('ESDraft', '#sec-binary-logical-operators')}}{{Spec2('ESDraft')}}Определено в нескольких секциях спецификации: Логический оператор НЕ, Бинарные логические операторы
+ +

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

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Логическое И (&&){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Логическое ИЛИ (||){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Логическое НЕ (!){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Логическое И (&&){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Логическое ИЛИ (||){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Логическое НЕ (!){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

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

+ + diff --git "a/files/ru/web/javascript/reference/operators/\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200_\320\267\320\260\320\277\321\217\321\202\320\260\321\217/index.html" "b/files/ru/web/javascript/reference/operators/\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200_\320\267\320\260\320\277\321\217\321\202\320\260\321\217/index.html" new file mode 100644 index 0000000000..471c81ba88 --- /dev/null +++ "b/files/ru/web/javascript/reference/operators/\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200_\320\267\320\260\320\277\321\217\321\202\320\260\321\217/index.html" @@ -0,0 +1,103 @@ +--- +title: Оператор Запятая +slug: Web/JavaScript/Reference/Operators/Оператор_Запятая +tags: + - Оператор запятая +translation_of: Web/JavaScript/Reference/Operators/Comma_Operator +--- +
{{jsSidebar("Operators")}}
+ +

Оператор запятая выполняет каждый из его операндов (слева направо) и возвращает значение последнего операнда.

+ +
{{EmbedInteractiveExample("pages/js/expressions-commaoperators.html")}}
+ + + +

Синтаксис

+ +
expr1, expr2, expr3...
+ +

Параметры

+ +
+
expr1, expr2, expr3...
+
Любые выражения.
+
+ +

Описание

+ +

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

+ +

Примеры

+ +

Если a это двумерный массив элементов размерностью 10 х 10, то приведенный ниже код использует оператор запятая для одновременного изменения двух переменных за раз.

+ +

Следующий код выводит в консоль значения диагональных элементов массива:

+
for (let i = 0, j = 9; i <= 9; i++, j--)
+  console.log("a[" + i + "][" + j + "] = " + a[i][j]);
+ +

Заметьте, что запятая при объявлении переменной var, let или const не является оператором запятая, так как в данном случае она находится не в выражении. Скорее, это спец символ в объявлении переменных, комбинирующий их множество в одно выражение. Практически, эта запятая ведет себя почти так же, как и запятая.

+ +
  // подобное объявление запрещено в строгом режиме(strict mode)
+
+a = b = 3, c = 4; // возвращает 4 в консоль
+console.log(a); // 3
+x = (y = 5, z = 6); // возвращает 6 в консоль
+console.log(x); // 6
+
+ +

Оператор запятая полностью отличается от запятой в массивах, объектах, аргументах и параметрах функции.

+ +

Вычисления и возврат значения

+ +

Другой пример использования оператора запятой – вычисления перед возвратом значения. Как было указано ранее, будет возвращён только последний элемент, но все предыдущие также будут вычислены. Таким образом можно сделать:

+ +
function myFunc () {
+  let x = 0;
+
+  return (x += 1, x); // то же самое, что return ++x;
+}
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ESDraft', '#sec-comma-operator', 'Comma operator')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-comma-operator', 'Comma operator')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-11.14', 'Comma operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES1', '#sec-11.14', 'Comma operator')}}{{Spec2('ES1')}}Initial definition
+ +

Совместимость браузеров

+ + + +

{{Compat("javascript.operators.comma")}}

+ +

Смотри также

+ + diff --git "a/files/ru/web/javascript/reference/operators/\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200\321\213_\321\201\321\200\320\260\320\262\320\275\320\265\320\275\320\270\321\217/index.html" "b/files/ru/web/javascript/reference/operators/\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200\321\213_\321\201\321\200\320\260\320\262\320\275\320\265\320\275\320\270\321\217/index.html" new file mode 100644 index 0000000000..f565d7d293 --- /dev/null +++ "b/files/ru/web/javascript/reference/operators/\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200\321\213_\321\201\321\200\320\260\320\262\320\275\320\265\320\275\320\270\321\217/index.html" @@ -0,0 +1,285 @@ +--- +title: Операторы сравнения +slug: Web/JavaScript/Reference/Operators/Операторы_сравнения +tags: + - JavaScript + - Операторы +translation_of: Web/JavaScript/Reference/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}}
+
+ +


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

+ + diff --git "a/files/ru/web/javascript/reference/operators/\320\277\321\200\320\270\321\201\320\262\320\260\320\270\320\262\320\260\320\275\320\270\320\265/index.html" "b/files/ru/web/javascript/reference/operators/\320\277\321\200\320\270\321\201\320\262\320\260\320\270\320\262\320\260\320\275\320\270\320\265/index.html" new file mode 100644 index 0000000000..0517dc2ccd --- /dev/null +++ "b/files/ru/web/javascript/reference/operators/\320\277\321\200\320\270\321\201\320\262\320\260\320\270\320\262\320\260\320\275\320\270\320\265/index.html" @@ -0,0 +1,66 @@ +--- +title: Присваивание (=) +slug: Web/JavaScript/Reference/Operators/Присваивание +tags: + - Assignment operator + - JavaScript + - Language feature + - Operator + - Reference + - Оператор + - Оператор присваивания + - "Особенность\_языка" + - справочник +translation_of: Web/JavaScript/Reference/Operators/Assignment +--- +
{{jsSidebar("Operators")}}
+ +

Простой оператор присваивания (=) используется для присваивания значения переменной. Операция присваивания вычисляется в присваиваемую величину. Присваивание по цепочке (chaining) используется для назначения нескольким переменным одинакового значения.

+ +

{{EmbedInteractiveExample("pages/js/expressions-assignment.html")}}

+ +
+ + + +

Синтаксис

+ +
Оператор: x = y
+
+ +

Примеры

+ +

Простое и цепное присваивание

+ +
// Предположим следующие переменные и их значения
+//  x = 5
+//  y = 10
+//  z = 25
+
+x = y     // x будет присвоено значение 10
+x = y = z // x, y и z будут равны 25
+ +

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

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}
+ +

Совместимость с браузерами

+ + + +

{{Compat("javascript.operators.assignment")}}

+ +

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

+ + diff --git "a/files/ru/web/javascript/reference/operators/\321\203\321\201\320\273\320\276\320\262\320\275\321\213\320\271_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200/index.html" "b/files/ru/web/javascript/reference/operators/\321\203\321\201\320\273\320\276\320\262\320\275\321\213\320\271_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200/index.html" new file mode 100644 index 0000000000..344d7f21d9 --- /dev/null +++ "b/files/ru/web/javascript/reference/operators/\321\203\321\201\320\273\320\276\320\262\320\275\321\213\320\271_\320\276\320\277\320\265\321\200\320\260\321\202\320\276\321\200/index.html" @@ -0,0 +1,169 @@ +--- +title: Условный (тернарный) оператор +slug: Web/JavaScript/Reference/Operators/Условный_оператор +tags: + - JavaScript + - Оператор +translation_of: Web/JavaScript/Reference/Operators/Conditional_Operator +--- +
{{jsSidebar("Operators")}}
+ +

Условный (тернарный) оператор - единственный оператор в JavaScript, принимающий три операнда: условие, за которым следует знак вопроса (?), затем выражение, которое выполняется, если условие истинно, сопровождается двоеточием (:), и, наконец, выражение, которое выполняется, если условие ложно. Он часто используется в качестве укороченного варианта условного оператора if.

+ +

Синтаксис

+ +
условие ? выражение1 : выражение2
+ +

Параметры

+ +
+
условие
+
Выражение, принимающее значение true или false.
+
+ +
+
выражение1, выражение2
+
Выражения, значения которых могут принадлежать любому типу.
+
+ +

Описание

+ +

Оператор возвращает значение выражения1, если условие верно, и значение выражения2 в противном случае. Например, чтобы вывести сообщение, текст которого зависит от значения переменной isMember, можно использовать такое выражение:

+ +
"The fee is " + (isMember ? "$2.00" : "$10.00")
+
+ +

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

+ +
var elvisLives = Math.PI > 4 ? "Да" : "Нет";
+ +

Возможны множественные тернарные операции (обратите внимание: условный оператор ассоциативен справа):

+ +
var firstCheck = false,
+    secondCheck = false,
+    access = firstCheck ? "Доступ запрещен" : secondCheck ? "Доступ запрещен" : "Доступ разрешен";
+
+console.log( access ); // выводит в консоль "Доступ разрешен"
+ +

Тернарные операции можно использовать и сами по себе - для выполнения различных операций:

+ +
var stop = false, age = 16;
+
+age > 18 ? location.assign("continue.html") : stop = true;
+
+ +

Также возможно выполнять несколько операций на каждое сравнение, разделив их запятыми:

+ +
var stop = false, age = 23;
+
+age > 18 ? (
+    alert("Хорошо, вы можете продолжить."),
+    location.assign("continue.html")
+) : (
+    stop = true,
+    alert("Простите, вы еще так юны!")
+);
+
+ +

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

+ +
var age = 16;
+
+var url = age > 18 ? (
+    alert("Хорошо, вы можете продолжить."),
+    // alert вернет "undefined", но это будет проигнорировано, потому что
+    // не является последним в списке значений, разделенных запятой
+    "continue.html" // значение будет присвоено, если age > 18
+) : (
+    alert("Вы слишком молоды!"),
+    alert("Простите :-("),
+    // ит.д. ит.д.
+    "stop.html" // значение будет присвоено, если !(age > 18)
+);
+
+location.assign(url); // "stop.html"
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES6', '#sec-conditional-operator', 'Условный Оператор')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-11.12', 'Условный оператор')}}{{Spec2('ES5.1')}}
{{SpecName('ES1', '#sec-11.12', 'Условный оператор')}}{{Spec2('ES1')}}Изначальное определение. Реализация в JavaScript 1.0.
+ +

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

+ +

{{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