From 980fe00a74a9ad013b945755415ace2e5429c3c2 Mon Sep 17 00:00:00 2001 From: Alexey Pyltsyn Date: Wed, 27 Oct 2021 02:31:24 +0300 Subject: [RU] Remove notranslate (#2874) --- .../reference/operators/addition/index.html | 6 ++-- .../operators/addition_assignment/index.html | 4 +-- .../reference/operators/assignment/index.html | 4 +-- .../reference/operators/bitwise_and/index.html | 8 ++--- .../reference/operators/class/index.html | 8 ++--- .../operators/conditional_operator/index.html | 14 ++++----- .../reference/operators/decrement/index.html | 6 ++-- .../nullish_coalescing_operator/index.html | 18 +++++------ .../operators/operator_precedence/index.html | 6 ++-- .../operators/property_accessors/index.html | 24 +++++++-------- .../reference/operators/spread_syntax/index.html | 36 +++++++++++----------- .../reference/operators/yield/index.html | 6 ++-- .../reference/operators/yield_star_/index.html | 10 +++--- 13 files changed, 75 insertions(+), 75 deletions(-) (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 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

Синтаксис

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

 
 
Примеры

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

 
-
// Number + Number -> addition
+
// Number + Number -> addition
 1 + 2 // 3
 
 // Boolean + Number -> addition
@@ -37,7 +37,7 @@ false + false // 0
 
 
Сложение строк

 
-
// String + String -> concatenation
+
// 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
 
 
Синтаксис

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

 
 
Примеры

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

 
-
// Assuming the following variables
+
// 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/Присваивание
 
 
Синтаксис

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

 
 
Примеры

 
 
Простое и цепное присваивание

 
-
// Предположим следующие переменные и их значения
+
// Предположим следующие переменные и их значения
 //  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
 
 
Синтаксис

 
-
a & b
+
a & b
 

 
 
Описание

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

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

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

@@ -66,7 +66,7 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_AND
  
 
 
-
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+
.    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
 
 
Использование побитового И

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

 
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
 
 
Синтаксис

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

 
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Operators/class
 
 
Так же, как и при использовании class declaration, тело класса у class expression будет исполняться в {{jsxref("Strict_mode", "строгом режиме", "", 1)}}.

 
-
'use strict';
+
'use strict';
 var Foo = class {}; // свойство конструктора опционально
 var Foo = class {}; // повторное объявление разрешено
 
@@ -39,7 +39,7 @@ class Foo {}; // Throws TypeError, doesn't allow re-declaration
 
 
Простой анонимный class expression, на который можно сослаться с помощью переменной "Foo".

 
-
var Foo = class {
+
var Foo = class {
   constructor() {}
   bar() {
     return "Hello World!";
@@ -55,7 +55,7 @@ Foo.name; // "Foo"
 
 
Если вы хотите сослаться на конкретный класс внутри тела класса, вы можете создать именованный class expression. Это имя будет доступно только внутри области видимости самого class expression.

 
-
var Foo = class NamedFoo {
+
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/Условный_операт
 
 
Синтаксис

 
-
условие ? выражение1 : выражение2 

+
условие ? выражение1 : выражение2 

 
 
Параметры

 
@@ -31,16 +31,16 @@ original_slug: Web/JavaScript/Reference/Operators/Условный_операт
 
 
Оператор возвращает значение выражения1, если условие верно, и значение выражения2 в противном случае. Например, чтобы вывести сообщение, текст которого зависит от значения переменной isMember, можно использовать такое выражение:

 
-
"The fee is " + (isMember ? "$2.00" : "$10.00")
+
"The fee is " + (isMember ? "$2.00" : "$10.00")
 

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

 
-
var elvisLives = Math.PI > 4 ? "Да" : "Нет";

+
var elvisLives = Math.PI > 4 ? "Да" : "Нет";

 
 
Возможны множественные тернарные операции (обратите внимание: условный оператор ассоциативен справа):

 
-
var firstCheck = false,
+
var firstCheck = false,
     secondCheck = false,
     access = firstCheck ? "Доступ запрещён" : secondCheck ? "Доступ запрещён" : "Доступ разрешён";
 
@@ -48,14 +48,14 @@ console.log( access ); // выводит в консоль "Доступ раз
 
 
Тернарные операции можно использовать и сами по себе - для выполнения различных операций:

 
-
var stop = false, age = 16;
+
var stop = false, age = 16;
 
 age > 18 ? location.assign("continue.html") : stop = true;
 

 
 
Также возможно выполнять несколько операций на каждое сравнение, разделив их запятыми:

 
-
var stop = false, age = 23;
+
var stop = false, age = 23;
 
 age > 18 ? (
     alert("Хорошо, вы можете продолжить."),
@@ -68,7 +68,7 @@ age > 18 ? (
 
 
При присвоении значения также возможно выполнение более одной операции. В этом случае переменной будет присвоено то значение, которое стоит последним в списке значений, разделённых запятой.

 
-
var age = 16;
+
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
 
 
Синтаксис

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

 
 
Описание

@@ -31,7 +31,7 @@ translation_of: Web/JavaScript/Reference/Operators/Decrement
 
 
Постфиксный декремент

 
-
let x = 3;
+
let x = 3;
 y = x--;
 
 // y = 3
@@ -40,7 +40,7 @@ y = x--;
 
 
Префиксный декремент

 
-
let a = 2;
+
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
 
 
Синтаксис

 
-
leftExpr ?? rightExpr
+
leftExpr ?? rightExpr
 

 
 
Примеры

@@ -25,7 +25,7 @@ translation_of: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator
 
 
В этом примере показано как устанавливать значения по умолчанию, оставив в покое значения отличные от null или undefined.

 
-
const nullValue = null;
+
const nullValue = null;
 const emptyText = ""; // falsy
 const someNumber = 42;
 
@@ -41,14 +41,14 @@ console.log(valC); // 42

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

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

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

 
-
let count = 0;
+
let count = 0;
 let text = "";
 
 let qty = count || 42;
@@ -59,7 +59,7 @@ console.log(message); // "hi!" and not ""
 
 
Оператор нулевого слияния предотвращает попадание в такую ловушку, возвращая второй операнд если первый оказывается null or undefined (но не любым другим ложным значением):

 
-
let myText = ''; // Пустая строка (тоже является ложным значением при приведении к логическому типу)
+
let myText = ''; // Пустая строка (тоже является ложным значением при приведении к логическому типу)
 
 let notFalsyText = myText || 'Hello world';
 console.log(notFalsyText); // Hello world
@@ -72,7 +72,7 @@ console.log(preservingFalsy); // '' (так как myText не undefined и не
 
 
Так же как при использовании логического И и ИЛИ, правое выражение не вычисляется если найдено подходящее значение в левом.

 
-
function A() { console.log('A was called'); return undefined;}
+
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() );
 
 
Нельзя напрямую объединять И (&&) и ИЛИ (||) операторы с ??. При таком выражении будет выброшен SyntaxError.

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

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

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

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

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

 
-
let foo = { someFooProp: "hi" };
+
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
 
 
Ассоциативность определяет порядок, в котором обрабатываются операторы с одинаковым приоритетом. Например, рассмотрим выражение:

 
-
a OP b OP c
+
a OP b OP c
 

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

 
-
a = b = 5;
+
a = b = 5;
 

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

 
 
Примеры

 
-
3 > 2 && 2 > 1
+
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
 
 
Синтаксис

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

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

 
-
const variable = object.property_name;
+
const variable = object.property_name;
 
 object.property_name = value;
 

 
-
const object = {};
+
const object = {};
 
 object.$1 = 'foo';
 console.log(object.$1);  // 'foo'
@@ -42,11 +42,11 @@ console.log(object.1);   // SyntaxError

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

 
-
document.createElement('pre')

+
document.createElement('pre')

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

 
-
// SyntaxError, здесь считается, что 77. это число,
+
// SyntaxError, здесь считается, что 77. это число,
 // поэтому такая запись эквивалентна (77.)toExponentional()
 // что является ошибкой
 77.toExponentional()
@@ -65,29 +65,29 @@ console.log(object.1);   // SyntaxError

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

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

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

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

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

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

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

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

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

 
-
const object = {}
+
const object = {}
 object['1'] = 'value'
 console.log(object[1])

 
 
Этот пример также выводит 'value', так как и foo, и bar приводятся к одной и той же строке.

 
-
const foo = {unique_prop: 1}
+
const foo = {unique_prop: 1}
 const bar = {unique_prop: 2}
 const object = {}
 
@@ -109,12 +109,12 @@ console.log(object[bar]);
 
 
Например, следующий синтаксис можно часто увидеть в скриптах.

 
-
x = eval('document.forms.form_name.elements.' + strFormControl + '.value');
+
x = eval('document.forms.form_name.elements.' + strFormControl + '.value');
 

 
 
Функция eval() очень медленная и её использования следует избегать, когда это возможно. Кроме того, строка strFormControl при таком использовании обязаны содержать действительный идентификатор, что не является обязательным для id полей формы, то есть, например, поле с id 1 не получится получить такой записью. Лучше вместо этого использовать скобочную запись:

 
-
x = document.forms["form_name"].elements[strFormControl].value;
+
x = document.forms["form_name"].elements[strFormControl].value;
 

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

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
 
 
Для вызовов функций:

 
-
myFunction(...iterableObj);
+
myFunction(...iterableObj);
 

 
 
Для литералов массива или строк:

 
-
[...iterableObj, '4', 'five', 6];

+
[...iterableObj, '4', 'five', 6];

 
 
Для литералов объекта (новое в ECMAScript 2018):

 
-
let objClone = { ...obj };

+
let objClone = { ...obj };

 
 
Примеры

 
@@ -40,19 +40,19 @@ translation_of: Web/JavaScript/Reference/Operators/Spread_syntax
 
 
Обычно используют {{jsxref( "Function.prototype.apply")}} в случаях, когда хотят использовать элементы массива в качестве аргументов функции.

 
-
function myFunction(x, y, z) { }
+
function myFunction(x, y, z) { }
 var args = [0, 1, 2];
 myFunction.apply(null, args);

 
 
С spread syntax вышеприведённое можно записать как:

 
-
function myFunction(x, y, z) { }
+
function myFunction(x, y, z) { }
 var args = [0, 1, 2];
 myFunction(...args);

 
 
Любой аргумент в списке аргументов может использовать spread syntax, и его можно использовать несколько раз.

 
-
function myFunction(v, w, x, y, z) { }
+
function myFunction(v, w, x, y, z) { }
 var args = [0, 1];
 myFunction(-1, ...args, 2, ...[3]);

 
@@ -60,13 +60,13 @@ myFunction(-1, ...args, 2, ...[3]);

 
 
Вызывая конструктор через ключевое слово new, невозможно использовать массив и apply напрямую (apply выполняет [[Call]], а не [[Construct]]).Однако благодаря spread syntax, массив может быть с лёгкостью использован со словом new:

 
-
var dateFields = [1970, 0, 1];  // 1 Jan 1970
+
var dateFields = [1970, 0, 1];  // 1 Jan 1970
 var d = new Date(...dateFields);
 

 
 
Чтобы использовать new с массивом параметров без spread syntax, вам потребуется использование частичного применения:

 
-
function applyAndNew(constructor, args) {
+
function applyAndNew(constructor, args) {
    function partial () {
       return constructor.apply(this, args);
    };
@@ -98,7 +98,7 @@ console.log(new myConstructorWithArguments);
 
 
Без spread syntax, применение синтаксиса литерала массива для создания нового массива на основе существующего недостаточно и требуется императивный код вместо комбинации методов push, splice, concat и т.д. С spread syntax реализация становится гораздо более лаконичной:

 
-
var parts = ['shoulders', 'knees'];
+
var parts = ['shoulders', 'knees'];
 var lyrics = ['head', ...parts, 'and', 'toes'];
 // ["head", "shoulders", "knees", "and", "toes"]
 

@@ -107,7 +107,7 @@ var lyrics = ['head', ...parts, 'and', 'toes'];
 
 
Копирование массива

 
-
var arr = [1, 2, 3];
+
var arr = [1, 2, 3];
 var arr2 = [...arr]; // like arr.slice()
 arr2.push(4);
 
@@ -117,7 +117,7 @@ arr2.push(4);
 
 
Примечание: Spread syntax на самом деле переходит лишь на один уровень глубже при копировании массива. Таким образом, он может не подходить для копирования многоразмерных массивов, как показывает следующий пример: (также как и c {{jsxref("Object.assign()")}}) и синтаксис spred 

 
-
const a = [[1], [2], [3]];
+
const a = [[1], [2], [3]];
 const b = [...a];
 b.shift().shift(); // 1
 // О нет. Теперь на массив "а" относятся также: а
@@ -128,28 +128,28 @@ b.shift().shift(); // 1
 
 
Для конкатенации массива часто используется {{jsxref("Array.concat")}}:

 
-
var arr1 = [0, 1, 2];
+
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 arr1 = [0, 1, 2];
 var arr2 = [3, 4, 5];
 arr1 = [...arr1, ...arr2];
 

 
 
{{jsxref("Array.unshift")}} часто используется для вставки массива значений в начало существующего массива. Без spread syntax:

 
-
var arr1 = [0, 1, 2];
+
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 arr1 = [0, 1, 2];
 var arr2 = [3, 4, 5];
 arr1 = [...arr2, ...arr1]; // arr1 is now [3, 4, 5, 0, 1, 2]
 

@@ -160,7 +160,7 @@ arr1 = [...arr2, ...arr1]; // arr1 is now [3, 4, 5, 0, 1, 2]
 
 
Поверхностное копирование (без прототипа) или объединение объектов теперь возможно с использованием более короткого, чем {{jsxref("Object.assign()")}}, синтаксиса.

 
-
var obj1 = { foo: 'bar', x: 42 };
+
var obj1 = { foo: 'bar', x: 42 };
 var obj2 = { foo: 'baz', y: 13 };
 
 var clonedObj = { ...obj1 };
@@ -173,7 +173,7 @@ var mergedObj = { ...obj1, ...obj2 };
 
 
Обратите внимание, что вы не можете заменить или имитировать функцию {{jsxref("Object.assign()")}}:

 
-
var obj1 = { foo: 'bar', x: 42 };
+
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);
 
 
Spread syntax ( кроме случаев spread properties) может быть применён только к итерируемым объектам (iterable objects) :

 
-
var obj = {'key1': 'value1'};
+
var obj = {'key1': 'value1'};
 var array = [...obj]; // TypeError: obj is not iterable
 

 
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
 
 
Синтаксис

 
-
 [rv] = yield [[выражение]];

+
 [rv] = yield [[выражение]];

 
 

  
выражение

@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Operators/yield
 
 
Следующий фрагмент кода содержит определение функции-генератора и вспомогательной функции:

 
-
function* foo(){
+
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
 
 
После того как тело функции-генератора определено, оно может использоваться для получения итератора:

 
-
var iterator = foo();
+
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*
 
 
Синтаксис

 
-
 yield* [[expression]];

+
 yield* [[expression]];

 
 

  
expression

@@ -28,7 +28,7 @@ translation_of: Web/JavaScript/Reference/Operators/yield*
 
 
В следующем примере, значения полученные из g1() возвращаются из g2 вызовами next, как будто бы она вычислила их сама.

 
-
function* g1() {
+
function* g1() {
   yield 2;
   yield 3;
   yield 4;
@@ -54,7 +54,7 @@ console.log(iterator.next()); // { value: undefined, done: true }
 
 
Помимо объектов генераторов, yield* может перебирать другие виды итерируемых объектов, т.е. массивы, строки, объекты аргументов и др.

 
-
function* g3() {
+
function* g3() {
   yield* [1, 2];
   yield* "34";
   yield* Array.from(arguments);
@@ -106,7 +106,7 @@ class PowersOfTwo {
 
 
yield* - это выражение, а не оператор, поэтому оно имеет значение, равное последнему значению итератора 

 
-
function* g4() {
+
function* g4() {
   yield* [1, 2, 3];
   return "foo";
 }
@@ -162,7 +162,7 @@ console.log(result);          // "foo"
  
  • Начиная с Gecko 33 {{geckoRelease(33)}}, разбор выражений yield было приведено к соответствию с последними спецификациями ES6 ({{bug(981599)}}):
   
      
    
    • Реализована корректная обработка разрыва строки. Разрыва строки между "yield" и "*" быть не может. Такой код вызовет {{jsxref("SyntaxError")}}:
-    
      function* foo() {
+    
      function* foo() {
   yield
   *[];
 }
      
-- 
cgit v1.2.3-54-g00ecf