diff options
Diffstat (limited to 'files/ru/web/javascript/reference/operators')
13 files changed, 75 insertions, 75 deletions
diff --git a/files/ru/web/javascript/reference/operators/addition/index.html b/files/ru/web/javascript/reference/operators/addition/index.html index 944ef3d8a7..c9b2961231 100644 --- a/files/ru/web/javascript/reference/operators/addition/index.html +++ b/files/ru/web/javascript/reference/operators/addition/index.html @@ -18,14 +18,14 @@ translation_of: Web/JavaScript/Reference/Operators/Addition <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate"><strong>Оператор:</strong> <var>x</var> + <var>y</var> +<pre class="syntaxbox"><strong>Оператор:</strong> <var>x</var> + <var>y</var> </pre> <h2 id="Примеры">Примеры</h2> <h3 id="Сложение_чисел">Сложение чисел</h3> -<pre class="brush: js notranslate">// Number + Number -> addition +<pre class="brush: js">// Number + Number -> addition 1 + 2 // 3 // Boolean + Number -> addition @@ -37,7 +37,7 @@ false + false // 0 <h3 id="Сложение_строк">Сложение строк</h3> -<pre class="brush: js notranslate">// String + String -> concatenation +<pre class="brush: js">// String + String -> concatenation 'foo' + 'bar' // "foobar" // Number + String -> concatenation diff --git a/files/ru/web/javascript/reference/operators/addition_assignment/index.html b/files/ru/web/javascript/reference/operators/addition_assignment/index.html index e7124ec00f..99c5b74dc5 100644 --- a/files/ru/web/javascript/reference/operators/addition_assignment/index.html +++ b/files/ru/web/javascript/reference/operators/addition_assignment/index.html @@ -18,14 +18,14 @@ translation_of: Web/JavaScript/Reference/Operators/Addition_assignment <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate"><strong>Оператор:</strong> x += y +<pre class="syntaxbox"><strong>Оператор:</strong> x += y <strong>Значение:</strong> x = x + y</pre> <h2 id="Примеры">Примеры</h2> <h3 id="Использование_сложения_с_присваиванием">Использование сложения с присваиванием</h3> -<pre class="brush: js notranslate">// Assuming the following variables +<pre class="brush: js">// Assuming the following variables // foo = 'foo' // bar = 5 // baz = true diff --git a/files/ru/web/javascript/reference/operators/assignment/index.html b/files/ru/web/javascript/reference/operators/assignment/index.html index 795c61c381..70aacd182a 100644 --- a/files/ru/web/javascript/reference/operators/assignment/index.html +++ b/files/ru/web/javascript/reference/operators/assignment/index.html @@ -26,14 +26,14 @@ original_slug: Web/JavaScript/Reference/Operators/Присваивание <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate"><strong>Оператор:</strong> x = y +<pre class="syntaxbox"><strong>Оператор:</strong> x = y </pre> <h2 id="Примеры">Примеры</h2> <h3 id="Простое_и_цепное_присваивание">Простое и цепное присваивание</h3> -<pre class="brush: js notranslate">// Предположим следующие переменные и их значения +<pre class="brush: js">// Предположим следующие переменные и их значения // x = 5 // y = 10 // z = 25 diff --git a/files/ru/web/javascript/reference/operators/bitwise_and/index.html b/files/ru/web/javascript/reference/operators/bitwise_and/index.html index bdb11d9d4b..745ad33be8 100644 --- a/files/ru/web/javascript/reference/operators/bitwise_and/index.html +++ b/files/ru/web/javascript/reference/operators/bitwise_and/index.html @@ -18,14 +18,14 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_AND <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate"><code><var>a</var> & <var>b</var></code> +<pre class="syntaxbox"><code><var>a</var> & <var>b</var></code> </pre> <h2 id="Описание">Описание</h2> <p>Операнды преобразуются в 32-битные целые числа и выражаются серией битов (нулей and единиц). Числа с более чем 32 битами отбрасывают старшие разряды. Например, следующее целое число с более чем 32 битами будет преобразовано в 32-битное целое:</p> -<pre class="brush: js notranslate">До: 11100110111110100000000000000110000000000001 +<pre class="brush: js">До: 11100110111110100000000000000110000000000001 После: 10100000000000000110000000000001</pre> <p>Каждый бит в первом операнде связан с соответствующим битом во втором операнде:<em>первый бит - с первым</em>,<em>второй- со вторым</em>, и т.д.</p> @@ -66,7 +66,7 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_AND </tbody> </table> -<pre class="brush: js notranslate">. 9 (base 10) = 00000000000000000000000000001001 (base 2) +<pre class="brush: js">. 9 (base 10) = 00000000000000000000000000001001 (base 2) 14 (base 10) = 00000000000000000000000000001110 (base 2) -------------------------------- 14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10) @@ -78,7 +78,7 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_AND <h3 id="Использование_побитового_И">Использование побитового И</h3> -<pre class="brush: js notranslate">// 5: 00000000000000000000000000000101 +<pre class="brush: js">// 5: 00000000000000000000000000000101 // 2: 00000000000000000000000000000010 5 & 2; // 0</pre> diff --git a/files/ru/web/javascript/reference/operators/class/index.html b/files/ru/web/javascript/reference/operators/class/index.html index c7efce0be6..4fa06e092f 100644 --- a/files/ru/web/javascript/reference/operators/class/index.html +++ b/files/ru/web/javascript/reference/operators/class/index.html @@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Operators/class <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate">var MyClass = class <em>[className]</em> [extends] { +<pre class="syntaxbox">var MyClass = class <em>[className]</em> [extends] { // тело класса };</pre> @@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Operators/class <p>Так же, как и при использовании class declaration, тело класса у class expression будет исполняться в {{jsxref("Strict_mode", "строгом режиме", "", 1)}}.</p> -<pre class="brush: js notranslate">'use strict'; +<pre class="brush: js">'use strict'; var Foo = class {}; // свойство конструктора опционально var Foo = class {}; // повторное объявление разрешено @@ -39,7 +39,7 @@ class Foo {}; // Throws TypeError, doesn't allow re-declaration <p>Простой анонимный class expression, на который можно сослаться с помощью переменной "Foo".</p> -<pre class="brush: js notranslate">var Foo = class { +<pre class="brush: js">var Foo = class { constructor() {} bar() { return "Hello World!"; @@ -55,7 +55,7 @@ Foo.name; // "Foo" <p>Если вы хотите сослаться на конкретный класс внутри тела класса, вы можете создать именованный class expression. Это имя будет доступно только внутри области видимости самого class expression.</p> -<pre class="brush: js notranslate">var Foo = class NamedFoo { +<pre class="brush: js">var Foo = class NamedFoo { constructor() {} whoIsThere() { return NamedFoo.name; diff --git a/files/ru/web/javascript/reference/operators/conditional_operator/index.html b/files/ru/web/javascript/reference/operators/conditional_operator/index.html index a95e4faac7..259cd5122e 100644 --- a/files/ru/web/javascript/reference/operators/conditional_operator/index.html +++ b/files/ru/web/javascript/reference/operators/conditional_operator/index.html @@ -13,7 +13,7 @@ original_slug: Web/JavaScript/Reference/Operators/Условный_операт <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate"><em>условие</em> ? <em>выражение1</em> : <em>выражение2 </em></pre> +<pre class="syntaxbox"><em>условие</em> ? <em>выражение1</em> : <em>выражение2 </em></pre> <h3 id="Параметры">Параметры</h3> @@ -31,16 +31,16 @@ original_slug: Web/JavaScript/Reference/Operators/Условный_операт <p>Оператор возвращает значение <code>выражения1</code>, если <code>условие</code> верно, и значение <code>выражения2</code> в противном случае. Например, чтобы вывести сообщение, текст которого зависит от значения переменной <code>isMember</code>, можно использовать такое выражение:</p> -<pre class="brush: js notranslate">"The fee is " + (isMember ? "$2.00" : "$10.00") +<pre class="brush: js">"The fee is " + (isMember ? "$2.00" : "$10.00") </pre> <p>Также можно присваивать значения переменным на основе результатов работы тернарного оператора :</p> -<pre class="brush: js notranslate">var elvisLives = Math.PI > 4 ? "Да" : "Нет";</pre> +<pre class="brush: js">var elvisLives = Math.PI > 4 ? "Да" : "Нет";</pre> <p>Возможны множественные тернарные операции (обратите внимание: условный оператор ассоциативен справа):</p> -<pre class="brush: js notranslate">var firstCheck = false, +<pre class="brush: js">var firstCheck = false, secondCheck = false, access = firstCheck ? "Доступ запрещён" : secondCheck ? "Доступ запрещён" : "Доступ разрешён"; @@ -48,14 +48,14 @@ console.log( access ); // выводит в консоль "Доступ раз <p>Тернарные операции можно использовать и сами по себе - для выполнения различных операций:</p> -<pre class="brush: js notranslate">var stop = false, age = 16; +<pre class="brush: js">var stop = false, age = 16; age > 18 ? location.assign("continue.html") : stop = true; </pre> <p>Также возможно выполнять несколько операций на каждое сравнение, разделив их запятыми:</p> -<pre class="brush: js notranslate">var stop = false, age = 23; +<pre class="brush: js">var stop = false, age = 23; age > 18 ? ( alert("Хорошо, вы можете продолжить."), @@ -68,7 +68,7 @@ age > 18 ? ( <p>При присвоении значения также возможно выполнение более одной операции. В этом случае переменной <strong>будет присвоено то значение, </strong><em><strong>которое стоит последним в списке значений, разделённых запятой</strong></em>.</p> -<pre class="brush: js notranslate">var age = 16; +<pre class="brush: js">var age = 16; var url = age > 18 ? ( alert("Хорошо, вы можете продолжить."), diff --git a/files/ru/web/javascript/reference/operators/decrement/index.html b/files/ru/web/javascript/reference/operators/decrement/index.html index 722d4a5889..64d29374a3 100644 --- a/files/ru/web/javascript/reference/operators/decrement/index.html +++ b/files/ru/web/javascript/reference/operators/decrement/index.html @@ -18,7 +18,7 @@ translation_of: Web/JavaScript/Reference/Operators/Decrement <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate"><strong>Operator:</strong> <var>x</var>-- or --<var>x</var> +<pre class="syntaxbox"><strong>Operator:</strong> <var>x</var>-- or --<var>x</var> </pre> <h2 id="Описание">Описание</h2> @@ -31,7 +31,7 @@ translation_of: Web/JavaScript/Reference/Operators/Decrement <h3 id="Постфиксный_декремент">Постфиксный декремент</h3> -<pre class="brush: js notranslate">let x = 3; +<pre class="brush: js">let x = 3; y = x--; // y = 3 @@ -40,7 +40,7 @@ y = x--; <h3 id="Префиксный_декремент">Префиксный декремент</h3> -<pre class="brush: js notranslate">let a = 2; +<pre class="brush: js">let a = 2; b = --a; // a = 1 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 index f31321b93a..a6bfca160a 100644 --- a/files/ru/web/javascript/reference/operators/nullish_coalescing_operator/index.html +++ b/files/ru/web/javascript/reference/operators/nullish_coalescing_operator/index.html @@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate"><var>leftExpr</var> ?? <var>rightExpr</var> +<pre class="syntaxbox"><var>leftExpr</var> ?? <var>rightExpr</var> </pre> <h2 id="Примеры">Примеры</h2> @@ -25,7 +25,7 @@ translation_of: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator <p>В этом примере показано как устанавливать значения по умолчанию, оставив в покое значения отличные от <code>null</code> или <code>undefined</code>.</p> -<pre class="brush: js notranslate">const nullValue = null; +<pre class="brush: js">const nullValue = null; const emptyText = ""; // falsy const someNumber = 42; @@ -41,14 +41,14 @@ console.log(valC); // 42</pre> <p>Ранее, для присваивания значения по умолчанию переменной использовался оператор логического ИЛИ (<code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR_2">||</a></code>):</p> -<pre class="brush: js notranslate">let foo; +<pre class="brush: js">let foo; // переменной foo никогда не присваивалось значение, поэтому она undefined let someDummyText = foo || 'Hello!';</pre> <p>Однако, оператор <code>||</code> это логический оператор, левый операнд которого при сравнении неявно приводится к булевому значению, поэтому любое <em>ложное</em> значение (<code>0</code>, <code>''</code>, <code>NaN</code>, <code>null</code>, <code>undefined</code>) не возвращается. Данное поведение может быть нежелательным если вы рассматриваете <code>0</code>, <code>''</code>, или <code>NaN</code> как корректные значения.</p> -<pre class="brush: js notranslate">let count = 0; +<pre class="brush: js">let count = 0; let text = ""; let qty = count || 42; @@ -59,7 +59,7 @@ console.log(message); // "hi!" and not "" <p>Оператор нулевого слияния предотвращает попадание в такую ловушку, возвращая второй операнд если первый оказывается <code>null</code> or <code>undefined</code> (но не любым другим <em>ложным</em> значением):</p> -<pre class="brush: js notranslate">let myText = ''; // Пустая строка (тоже является ложным значением при приведении к логическому типу) +<pre class="brush: js">let myText = ''; // Пустая строка (тоже является ложным значением при приведении к логическому типу) let notFalsyText = myText || 'Hello world'; console.log(notFalsyText); // Hello world @@ -72,7 +72,7 @@ console.log(preservingFalsy); // '' (так как myText не undefined и не <p>Так же как при использовании логического И и ИЛИ, правое выражение не вычисляется если найдено подходящее значение в левом.</p> -<pre class="brush: js notranslate">function A() { console.log('A was called'); return undefined;} +<pre class="brush: js">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";} @@ -90,19 +90,19 @@ console.log( B() ?? C() ); <p>Нельзя напрямую объединять И (<code>&&</code>) и ИЛИ (<code>||</code>) операторы с <code>??</code>. При таком выражении будет выброшен <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">SyntaxError</a></code>.</p> -<pre class="brush: js example-bad notranslate">null || undefined ?? "foo"; // выбрасывает SyntaxError +<pre class="brush: js example-bad">null || undefined ?? "foo"; // выбрасывает SyntaxError true || undefined ?? "foo"; // выбрасывает SyntaxError</pre> <p>Однако, при заключении в скобки выражение является корректным:</p> -<pre class="brush: js example-good notranslate">(null || undefined) ?? "foo"; // returns "foo" +<pre class="brush: js example-good">(null || undefined) ?? "foo"; // returns "foo" </pre> <h3 id="Отношение_к_оператору_опциональной_последовательности_.">Отношение к оператору опциональной последовательности (<code>?.</code>)</h3> <p>Оператор нулевого слияния определяет <code>undefined</code> и <code>null</code> как специальные значения так же как и <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Optional_chaining">оператор опциональной последовательности (<code>?.</code>)</a>, который используется для доступа к свойствам объекта, значение которого может быть <code>null</code> или <code>undefined</code>.</p> -<pre class="brush: js notranslate">let foo = { someFooProp: "hi" }; +<pre class="brush: js">let foo = { someFooProp: "hi" }; console.log(foo.someFooProp?.toUpperCase()); // "HI" console.log(foo.someBarProp?.toUpperCase()); // undefined diff --git a/files/ru/web/javascript/reference/operators/operator_precedence/index.html b/files/ru/web/javascript/reference/operators/operator_precedence/index.html index 81ac025747..2de7b65912 100644 --- a/files/ru/web/javascript/reference/operators/operator_precedence/index.html +++ b/files/ru/web/javascript/reference/operators/operator_precedence/index.html @@ -20,19 +20,19 @@ translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence <p>Ассоциативность определяет порядок, в котором обрабатываются операторы с одинаковым приоритетом. Например, рассмотрим выражение:</p> -<pre class="syntaxbox notranslate">a OP b OP c +<pre class="syntaxbox">a OP b OP c </pre> <p>Левая ассоциативность (слева направо) означает, что оно обрабатывается как <code>(a OP b) OP c</code>, в то время как правая ассоциативность (справа налево) означает, что они интерпретируются как <code>a OP (b OP c)</code>. Операторы присваивания являются право-ассоциативными, так что вы можете написать:</p> -<pre class="brush: js notranslate">a = b = 5; +<pre class="brush: js">a = b = 5; </pre> <p>с ожидаемым результатом, что <code>a</code> и <code>b</code> будут равны 5. Это происходит, потому что оператор присваивания возвращает тот результат, который присваивает. Сначала <code>b</code> становится равным 5, затем <code>a</code> принимает значение <code>b</code>.</p> <h2 id="Примеры">Примеры</h2> -<pre class="brush: js notranslate"><code>3 > 2 && 2 > 1 +<pre class="brush: js"><code>3 > 2 && 2 > 1 // вернёт true 3 > 2 > 1 diff --git a/files/ru/web/javascript/reference/operators/property_accessors/index.html b/files/ru/web/javascript/reference/operators/property_accessors/index.html index 938833a348..005cef9b49 100644 --- a/files/ru/web/javascript/reference/operators/property_accessors/index.html +++ b/files/ru/web/javascript/reference/operators/property_accessors/index.html @@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Operators/Property_Accessors <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate">object.property +<pre class="syntaxbox">object.property object["property"] </pre> @@ -27,12 +27,12 @@ object["property"] <p class="brush: js">В записи <code>object.property</code>, <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">property</span></font> должно быть действительным <a href="/ru/docs/%D0%A1%D0%BB%D0%BE%D0%B2%D0%B0%D1%80%D1%8C/Identifier">идентификатором</a>. (В стандарте ECMAScript, имена свойств технически называются "IdentifierNames", а не "Identifiers", поэтому зарезервированные слова могут быть использованы в их качестве, но это не рекомендуется). Например, <code>object.$1</code> является верной записью, а <code>object.1</code> - нет.</p> -<pre class="brush: js notranslate">const variable = <var>object</var>.<var>property_name;</var> +<pre class="brush: js">const variable = <var>object</var>.<var>property_name;</var> <var>object</var>.<var>property_name</var> = value; </pre> -<pre class="brush: js notranslate">const object = {}; +<pre class="brush: js">const object = {}; object.$1 = 'foo'; console.log(object.$1); // 'foo' @@ -42,11 +42,11 @@ console.log(object.1); // SyntaxError</pre> <p>Здесь метод с именем <code>createElement</code> считывается с объекта <code>document</code> и вызывается.</p> -<pre class="brush: js notranslate">document.createElement('pre')</pre> +<pre class="brush: js">document.createElement('pre')</pre> <p>Если вы хотите вызвать метод на численном литерале, не имеющий части с экспонентой или точки, отделяющей дробную часть, нужно ставить пробел перед точкой, являющейся частью обращения к этому методу, чтобы интерпретатор не посчитал, что это точка отделяет дробную часть числа (или использовать другие способы этого избежать).</p> -<pre class="brush: js notranslate">// SyntaxError, здесь считается, что 77. это число, +<pre class="brush: js">// SyntaxError, здесь считается, что 77. это число, // поэтому такая запись эквивалентна (77.)toExponentional() // что является ошибкой 77.toExponentional() @@ -65,29 +65,29 @@ console.log(object.1); // SyntaxError</pre> <p class="brush: js">В записи <code>object[property_name]</code>, <em><code>property_name</code> - </em>это выражение, вычисляющееся в строку или <a href="/ru/docs/%D0%A1%D0%BB%D0%BE%D0%B2%D0%B0%D1%80%D1%8C/Symbol">символ</a>. Это может быть любая строка, не обязательно действительный идентификатор, например <code>'1foo'</code>, '<code>!bar!'</code> или даже <code>' '</code> (пробел).</p> -<pre class="brush: js notranslate">const variable = object[property_name] +<pre class="brush: js">const variable = object[property_name] object[property_name] = value</pre> <p>Пример, аналогичный примеру в предыдущем пункте:</p> -<pre class="brush: js notranslate">document['createElement']('pre'); +<pre class="brush: js">document['createElement']('pre'); </pre> <p>Пробел перед скобкой допускается:</p> -<pre class="brush: js notranslate">document ['createElement']('pre')</pre> +<pre class="brush: js">document ['createElement']('pre')</pre> <h3 id="Имена_свойств">Имена свойств</h3> <p>Имена свойств могут быть строками или <a href="/ru/docs/%D0%A1%D0%BB%D0%BE%D0%B2%D0%B0%D1%80%D1%8C/Symbol">символами</a>. Любое другое значение приводится к строке. Следующий код выводит <code>'value'</code>, поскольку число <code>1</code> приводится к строке <code>'1'</code>.</p> -<pre class="brush: js notranslate">const object = {} +<pre class="brush: js">const object = {} object['1'] = 'value' console.log(object[1])</pre> <p>Этот пример также выводит <code>'value',</code> так как и <code>foo</code>, и <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">bar</span></font> приводятся к одной и той же строке.</p> -<pre class="brush: js notranslate">const foo = {unique_prop: 1} +<pre class="brush: js">const foo = {unique_prop: 1} const bar = {unique_prop: 2} const object = {} @@ -109,12 +109,12 @@ console.log(object[bar]); <p>Например, следующий синтаксис можно часто увидеть в скриптах.</p> -<pre class="brush: js notranslate">x = eval('document.forms.form_name.elements.' + strFormControl + '.value'); +<pre class="brush: js">x = eval('document.forms.form_name.elements.' + strFormControl + '.value'); </pre> <p>Функция <code>eval()</code> очень медленная и её использования следует избегать, когда это возможно. Кроме того, строка <code>strFormControl</code> при таком использовании обязаны содержать действительный идентификатор, что не является обязательным для <code>id</code> полей формы, то есть, например, поле с id <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">1</span></font> не получится получить такой записью. Лучше вместо этого использовать скобочную запись:</p> -<pre class="brush: js notranslate">x = document.forms["form_name"].elements[strFormControl].value; +<pre class="brush: js">x = document.forms["form_name"].elements[strFormControl].value; </pre> <h2 id="Спецификации">Спецификации</h2> diff --git a/files/ru/web/javascript/reference/operators/spread_syntax/index.html b/files/ru/web/javascript/reference/operators/spread_syntax/index.html index 1019bdd757..5eb3e561d9 100644 --- a/files/ru/web/javascript/reference/operators/spread_syntax/index.html +++ b/files/ru/web/javascript/reference/operators/spread_syntax/index.html @@ -21,16 +21,16 @@ translation_of: Web/JavaScript/Reference/Operators/Spread_syntax <p>Для вызовов функций:</p> -<pre class="syntaxbox notranslate">myFunction(...iterableObj); +<pre class="syntaxbox">myFunction(...iterableObj); </pre> <p>Для литералов массива или строк:</p> -<pre class="syntaxbox notranslate">[...iterableObj, '4', 'five', 6];</pre> +<pre class="syntaxbox">[...iterableObj, '4', 'five', 6];</pre> <p>Для литералов объекта (новое в ECMAScript 2018):</p> -<pre class="syntaxbox notranslate">let objClone = { ...obj };</pre> +<pre class="syntaxbox">let objClone = { ...obj };</pre> <h2 id="Примеры">Примеры</h2> @@ -40,19 +40,19 @@ translation_of: Web/JavaScript/Reference/Operators/Spread_syntax <p>Обычно используют {{jsxref( "Function.prototype.apply")}} в случаях, когда хотят использовать элементы массива в качестве аргументов функции.</p> -<pre class="brush: js notranslate">function myFunction(x, y, z) { } +<pre class="brush: js">function myFunction(x, y, z) { } var args = [0, 1, 2]; myFunction.apply(null, args);</pre> <p>С <strong>spread syntax</strong> вышеприведённое можно записать как:</p> -<pre class="brush: js notranslate">function myFunction(x, y, z) { } +<pre class="brush: js">function myFunction(x, y, z) { } var args = [0, 1, 2]; myFunction(...args);</pre> <p>Любой аргумент в списке аргументов может использовать <strong>spread syntax</strong>, и его можно использовать несколько раз.</p> -<pre class="brush: js notranslate">function myFunction(v, w, x, y, z) { } +<pre class="brush: js">function myFunction(v, w, x, y, z) { } var args = [0, 1]; myFunction(-1, ...args, 2, ...[3]);</pre> @@ -60,13 +60,13 @@ myFunction(-1, ...args, 2, ...[3]);</pre> <p>Вызывая конструктор через ключевое слово <code>new</code>, невозможно использовать массив и <code>apply</code> <strong>напрямую </strong>(<code>apply</code> выполняет <code>[[Call]]</code>, а не <code>[[Construct]]</code>).Однако благодаря spread syntax, массив может быть с лёгкостью использован со словом <code>new:</code></p> -<pre class="brush: js notranslate">var dateFields = [1970, 0, 1]; // 1 Jan 1970 +<pre class="brush: js">var dateFields = [1970, 0, 1]; // 1 Jan 1970 var d = new Date(...dateFields); </pre> <p>Чтобы использовать <code>new</code> с массивом параметров без spread syntax, вам потребуется использование частичного применения:</p> -<pre class="brush: js notranslate">function applyAndNew(constructor, args) { +<pre class="brush: js">function applyAndNew(constructor, args) { function partial () { return constructor.apply(this, args); }; @@ -98,7 +98,7 @@ console.log(new myConstructorWithArguments); <p>Без spread syntax, применение синтаксиса литерала массива для создания нового массива на основе существующего недостаточно и требуется императивный код вместо комбинации методов <code>push</code>, <code>splice</code>, <code>concat</code> и т.д. С spread syntax реализация становится гораздо более лаконичной:</p> -<pre class="brush: js notranslate">var parts = ['shoulders', 'knees']; +<pre class="brush: js">var parts = ['shoulders', 'knees']; var lyrics = ['head', ...parts, 'and', 'toes']; // ["head", "shoulders", "knees", "and", "toes"] </pre> @@ -107,7 +107,7 @@ var lyrics = ['head', ...parts, 'and', 'toes']; <h4 id="Копирование_массива">Копирование массива</h4> -<pre class="brush: js notranslate">var arr = [1, 2, 3]; +<pre class="brush: js">var arr = [1, 2, 3]; var arr2 = [...arr]; // like arr.slice() arr2.push(4); @@ -117,7 +117,7 @@ arr2.push(4); <p><strong>Примечание:</strong> Spread syntax на самом деле переходит лишь на один уровень глубже при копировании массива. Таким образом, он может не подходить для копирования многоразмерных массивов, как показывает следующий пример: (также как и c {{jsxref("Object.assign()")}}) и синтаксис spred </p> -<pre class="brush: js notranslate">const a = [[1], [2], [3]]; +<pre class="brush: js">const a = [[1], [2], [3]]; const b = [...a]; b.shift().shift(); // 1 // О нет. Теперь на массив "а" относятся также: а @@ -128,28 +128,28 @@ b.shift().shift(); // 1 <p>Для конкатенации массива часто используется {{jsxref("Array.concat")}}:</p> -<pre class="brush: js notranslate">var arr1 = [0, 1, 2]; +<pre class="brush: js">var arr1 = [0, 1, 2]; var arr2 = [3, 4, 5]; // Append all items from arr2 onto arr1 arr1 = arr1.concat(arr2);</pre> <p>С использованием spread syntax:</p> -<pre class="brush: js notranslate">var arr1 = [0, 1, 2]; +<pre class="brush: js">var arr1 = [0, 1, 2]; var arr2 = [3, 4, 5]; arr1 = [...arr1, ...arr2]; </pre> <p>{{jsxref("Array.unshift")}} часто используется для вставки массива значений в начало существующего массива. Без spread syntax:</p> -<pre class="brush: js notranslate">var arr1 = [0, 1, 2]; +<pre class="brush: js">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]</pre> <p>С использованием spread syntax [Следует отметить, что такой способ создаёт новый массив <code>arr1</code>. В отличие от {{jsxref("Array.unshift")}}, исходный массив не мутируется]:</p> -<pre class="brush: js notranslate">var arr1 = [0, 1, 2]; +<pre class="brush: js">var arr1 = [0, 1, 2]; var arr2 = [3, 4, 5]; arr1 = [...arr2, ...arr1]; // arr1 is now [3, 4, 5, 0, 1, 2] </pre> @@ -160,7 +160,7 @@ arr1 = [...arr2, ...arr1]; // arr1 is now [3, 4, 5, 0, 1, 2] <p>Поверхностное копирование (без прототипа) или объединение объектов теперь возможно с использованием более короткого, чем {{jsxref("Object.assign()")}}, синтаксиса.</p> -<pre class="brush: js notranslate">var obj1 = { foo: 'bar', x: 42 }; +<pre class="brush: js">var obj1 = { foo: 'bar', x: 42 }; var obj2 = { foo: 'baz', y: 13 }; var clonedObj = { ...obj1 }; @@ -173,7 +173,7 @@ var mergedObj = { ...obj1, ...obj2 }; <p>Обратите внимание, что вы не можете заменить или имитировать функцию {{jsxref("Object.assign()")}}:</p> -<pre class="brush: js notranslate">var obj1 = { foo: 'bar', x: 42 }; +<pre class="brush: js">var obj1 = { foo: 'bar', x: 42 }; var obj2 = { foo: 'baz', y: 13 }; const merge = ( ...objects ) => ( { ...objects } ); @@ -189,7 +189,7 @@ var mergedObj = merge ( {}, obj1, obj2); <p>Spread syntax ( кроме случаев spread properties) может быть применён только к итерируемым объектам (<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator">iterable</a> objects) :</p> -<pre class="brush: js notranslate">var obj = {'key1': 'value1'}; +<pre class="brush: js">var obj = {'key1': 'value1'}; var array = [...obj]; // TypeError: obj is not iterable </pre> diff --git a/files/ru/web/javascript/reference/operators/yield/index.html b/files/ru/web/javascript/reference/operators/yield/index.html index d30b1bbce5..34f3245f4d 100644 --- a/files/ru/web/javascript/reference/operators/yield/index.html +++ b/files/ru/web/javascript/reference/operators/yield/index.html @@ -18,7 +18,7 @@ translation_of: Web/JavaScript/Reference/Operators/yield <h2 id="Syntax">Синтаксис</h2> -<pre class="syntaxbox language-html notranslate"> [<em>rv</em>] = <strong>yield</strong> [[выражение]];</pre> +<pre class="syntaxbox language-html"> [<em>rv</em>] = <strong>yield</strong> [[выражение]];</pre> <dl> <dt><code>выражение</code></dt> @@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Operators/yield <p>Следующий фрагмент кода содержит определение функции-генератора и вспомогательной функции:</p> -<pre class="brush: js notranslate">function* foo(){ +<pre class="brush: js">function* foo(){ var index = 0; while(index <= 2) // при достижении 2, done в yield станет true, а value undefined; yield index++; @@ -47,7 +47,7 @@ translation_of: Web/JavaScript/Reference/Operators/yield <p>После того как тело функции-генератора определено, оно может использоваться для получения итератора:</p> -<pre class="brush: js notranslate">var iterator = foo(); +<pre class="brush: js">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 } diff --git a/files/ru/web/javascript/reference/operators/yield_star_/index.html b/files/ru/web/javascript/reference/operators/yield_star_/index.html index 003e027d0e..1b1da5bd17 100644 --- a/files/ru/web/javascript/reference/operators/yield_star_/index.html +++ b/files/ru/web/javascript/reference/operators/yield_star_/index.html @@ -9,7 +9,7 @@ translation_of: Web/JavaScript/Reference/Operators/yield* <h2 id="Синтаксис">Синтаксис</h2> -<pre class="syntaxbox notranslate"> yield* [[expression]];</pre> +<pre class="syntaxbox"> yield* [[expression]];</pre> <dl> <dt><code>expression</code></dt> @@ -28,7 +28,7 @@ translation_of: Web/JavaScript/Reference/Operators/yield* <p>В следующем примере, значения полученные из <code>g1()</code> возвращаются из <code>g2</code> вызовами <code>next</code>, как будто бы она вычислила их сама.</p> -<pre class="brush: js notranslate">function* g1() { +<pre class="brush: js">function* g1() { yield 2; yield 3; yield 4; @@ -54,7 +54,7 @@ console.log(iterator.next()); // { value: undefined, done: true } <p>Помимо объектов генераторов, <code>yield*</code> может перебирать другие виды итерируемых объектов, т.е. массивы, строки, объекты аргументов и др.</p> -<pre class="brush: js notranslate">function* g3() { +<pre class="brush: js">function* g3() { yield* [1, 2]; yield* "34"; yield* Array.from(arguments); @@ -106,7 +106,7 @@ class PowersOfTwo { <p><code>yield*</code> - это выражение, а не оператор, поэтому оно имеет значение, равное последнему значению итератора </p> -<pre class="brush: js notranslate">function* g4() { +<pre class="brush: js">function* g4() { yield* [1, 2, 3]; return "foo"; } @@ -162,7 +162,7 @@ console.log(result); // "foo" <li>Начиная с Gecko 33 {{geckoRelease(33)}}, разбор выражений yield было приведено к соответствию с последними спецификациями ES6 ({{bug(981599)}}): <ul> <li>Реализована корректная обработка разрыва строки. Разрыва строки между "yield" и "*" быть не может. Такой код вызовет {{jsxref("SyntaxError")}}: - <pre class="brush: js notranslate">function* foo() { + <pre class="brush: js">function* foo() { yield *[]; }</pre> |