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) --- .../a_re-introduction_to_javascript/index.html | 154 ++++++++++----------- files/ru/web/javascript/closures/index.html | 32 ++--- files/ru/web/javascript/data_structures/index.html | 6 +- .../control_flow_and_error_handling/index.html | 38 ++--- files/ru/web/javascript/guide/modules/index.html | 76 +++++----- .../character_classes/index.html | 6 +- .../guide/regular_expressions/index.html | 38 ++--- .../inheritance_and_the_prototype_chain/index.html | 20 +-- .../ru/web/javascript/memory_management/index.html | 12 +- .../reference/classes/constructor/index.html | 20 +-- .../ru/web/javascript/reference/classes/index.html | 36 ++--- .../classes/private_class_fields/index.html | 16 +-- .../classes/public_class_fields/index.html | 26 ++-- .../reference/errors/bad_radix/index.html | 10 +- .../errors/cant_assign_to_property/index.html | 6 +- .../errors/cyclic_object_value/index.html | 8 +- .../missing_curly_after_property_list/index.html | 10 +- .../reference/functions/rest_parameters/index.html | 22 +-- .../reference/global_objects/array/flat/index.html | 14 +- .../reference/global_objects/array/map/index.html | 16 +-- .../global_objects/array/slice/index.html | 14 +- .../reference/global_objects/array/sort/index.html | 20 +-- .../global_objects/array/splice/index.html | 16 +-- .../global_objects/bigint/asuintn/index.html | 4 +- .../global_objects/date/getdate/index.html | 4 +- .../global_objects/date/getday/index.html | 6 +- .../global_objects/date/getfullyear/index.html | 4 +- .../global_objects/date/gethours/index.html | 4 +- .../global_objects/date/getmilliseconds/index.html | 4 +- .../global_objects/date/getminutes/index.html | 4 +- .../global_objects/date/getmonth/index.html | 4 +- .../global_objects/date/getseconds/index.html | 4 +- .../global_objects/date/gettime/index.html | 6 +- .../reference/global_objects/date/index.html | 14 +- .../reference/global_objects/eval/index.html | 22 +-- .../reference/global_objects/generator/index.html | 4 +- .../global_objects/intl/datetimeformat/index.html | 8 +- .../global_objects/number/issafeinteger/index.html | 6 +- .../global_objects/number/toexponential/index.html | 4 +- .../global_objects/number/tofixed/index.html | 4 +- .../global_objects/number/toprecision/index.html | 4 +- .../global_objects/number/tostring/index.html | 4 +- .../global_objects/object/create/index.html | 10 +- .../global_objects/object/entries/index.html | 10 +- .../global_objects/promise/then/index.html | 10 +- .../reference/global_objects/proxy/index.html | 18 +-- .../global_objects/proxy/proxy/apply/index.html | 4 +- .../global_objects/proxy/proxy/get/index.html | 6 +- .../global_objects/proxy/proxy/index.html | 4 +- .../global_objects/proxy/proxy/set/index.html | 4 +- .../reference/global_objects/reflect/index.html | 6 +- .../reference/global_objects/regexp/index.html | 22 +-- .../global_objects/regexp/lastmatch/index.html | 4 +- .../reference/global_objects/set/set/index.html | 4 +- .../global_objects/string/@@iterator/index.html | 6 +- .../global_objects/string/endswith/index.html | 6 +- .../reference/global_objects/string/index.html | 22 +-- .../global_objects/string/matchall/index.html | 10 +- .../global_objects/string/replaceall/index.html | 8 +- .../global_objects/string/slice/index.html | 12 +- .../global_objects/string/split/index.html | 20 +-- .../global_objects/string/startswith/index.html | 6 +- .../reference/global_objects/weakmap/index.html | 6 +- .../reference/lexical_grammar/index.html | 50 +++---- .../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 +- .../reference/statements/async_function/index.html | 10 +- .../reference/statements/class/index.html | 8 +- .../reference/statements/for...of/index.html | 36 ++--- 80 files changed, 591 insertions(+), 591 deletions(-) (limited to 'files/ru/web/javascript') diff --git a/files/ru/web/javascript/a_re-introduction_to_javascript/index.html b/files/ru/web/javascript/a_re-introduction_to_javascript/index.html index 7a93230090..617f628f8a 100644 --- a/files/ru/web/javascript/a_re-introduction_to_javascript/index.html +++ b/files/ru/web/javascript/a_re-introduction_to_javascript/index.html @@ -57,26 +57,26 @@ translation_of: Web/JavaScript/A_re-introduction_to_JavaScript

Числа в JavaScript — это "64-битные значения двойной точности формата IEEE 754", согласно спецификации. Это имеет интересные последствия. В JavaScript нет такой вещи, как целое число, поэтому с арифметикой нужно быть начеку, если вы привыкли к вычислениям в языках C или Java. Взгляните на пример:

-
0.1 + 0.2 == 0.30000000000000004
+
0.1 + 0.2 == 0.30000000000000004
 

 
 
На практике целые значения это 32-битные целые (и хранятся таким образом в некоторых браузерных реализациях), что может быть важно для побитовых операций.

 
 
Поддерживаются стандартные арифметические операторы, включая сложение, вычитание, остаток от деления и т.д. Есть ещё встроенный объект, который я забыл упомянуть, называемый Math, который содержит более продвинутые математические функции и константы:

 
-
Math.sin(3.5);
+
Math.sin(3.5);
 var circumference = Math.PI * (r + r);
 

 
 
Вы можете преобразовать строку в целое число, используя встроенную функцию parseInt(). Её необязательный второй параметр — основание системы счисления, которое следует всегда явно указывать:

 
-
parseInt("123", 10); // 123
+
parseInt("123", 10); // 123
 parseInt("010", 10); // 10
 

 
 
Если вы не предоставите основание, то можете получить неожиданные результаты:

 
-
parseInt("010");  // 8
+
parseInt("010");  // 8
 parseInt("0x10"); // 16
 

 
@@ -84,41 +84,41 @@ parseInt("0x10"); // 16
 
 
Если хотите преобразовать двоичное число в десятичное целое, просто смените основание:

 
-
parseInt("11", 2); // 3
+
parseInt("11", 2); // 3
 

 
 
Вы можете аналогично парсить дробные числа, используя встроенную функцию parseFloat(), которая использует всегда основание 10 в отличие от родственной parseInt().

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

 
-
+ "42";   // 42
+
+ "42";   // 42
 + "0x10"; // 16
 

 
 
Специальное значение NaN (сокращение от "Not a Number") возвращается, если строка не является числом:

 
-
parseInt("hello", 10); // NaN
+
parseInt("hello", 10); // NaN
 

 
 
NaN "заразителен": любая математическая операция над NaN возвращает NaN:

 
-
NaN + 5; // NaN
+
NaN + 5; // NaN
 

 
 
Проверить значение на NaN можно встроенной функцией isNaN():

 
-
isNaN(NaN); // true
+
isNaN(NaN); // true
 

 
 
JavaScript также имеет специальные значения Infinity (бесконечность) и -Infinity:

 
-
1 / 0; // Infinity
+
1 / 0; // Infinity
 -1 / 0; // -Infinity
 

 
 
Проверить значение на Infinity, -Infinity и NaN можно с помощью встроенной функции isFinite():

 
-
isFinite(1/0); // false
+
isFinite(1/0); // false
 isFinite(-Infinity); // false
 isFinite(NaN); // false
 

@@ -133,12 +133,12 @@ isFinite(NaN); // false
 
 
Чтобы выяснить длину строки (в кодовых единицах), используйте свойство length:

 
-
"hello".length; // 5
+
"hello".length; // 5
 

 
 
Это уже первый шаг для работы с объектами! Мы уже говорили, что и строки можно использовать как объекты? У них тоже есть методы:

 
-
"hello".charAt(0); // h
+
"hello".charAt(0); // h
 "hello, world".replace("hello", "goodbye"); // goodbye, world
 "hello".toUpperCase(); // HELLO
 

@@ -156,7 +156,7 @@ isFinite(NaN); // false
 
 
Преобразование значений можно осуществить явно, используя функцию Boolean():

 
-
Boolean(""); // false
+
Boolean(""); // false
 Boolean(234); // true
 

 
@@ -168,13 +168,13 @@ Boolean(234); // true
 
 
Для объявления новых переменных в  JavaScript используются ключевые слова let, const или var.

 
-
let a;
+
let a;
 let name = "Simon";
 

 
 
let  позволяет объявлять переменные, которые доступны только в блоке, в котором они объявлены:

 
-
// myLetVariable недоступна здесь
+
// myLetVariable недоступна здесь
 
 for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
   // myLetVariable доступна только здесь
@@ -184,17 +184,17 @@ for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
 
 
const позволяет создавать переменные, чьи значения не предполагают изменений. Переменная доступна из блока, в котором она объявлена.

 
-
const Pi = 3.14; // в переменную Pi записано значение.
+
const Pi = 3.14; // в переменную Pi записано значение.
 Pi = 1; // вызовет исключение, так как значение константы нельзя изменить.

 
 
var наиболее общее средство объявления переменной. Оно не имеет ограничений, которые имеют два вышеописанных способа. Это потому, что это был изначально единственный способ объявления переменной в JavaScript. Переменная, объявленная с помощью var, доступна в пределах функции, в которой она объявлена.

 
-
var a;
+
var a;
 var name = 'Simon';

 
 
Пример кода с переменной, объявленной с помощью var:

 
-
// myVarVariable доступна здесь
+
// myVarVariable доступна здесь
 
 for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
   // myVarVariable доступна для всей функции
@@ -210,7 +210,7 @@ for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
 
 
JavaScript поддерживает такие операторы, как +, -, *, / и %, который возвращает остаток от деления (не путать с модулем). Значения присваиваются с помощью оператора =, или с помощью составных операторов += и -=. Это сокращённая запись выражения x = x оператор y.

 
-
x += 5
+
x += 5
 x = x + 5
 

 
@@ -218,12 +218,12 @@ x = x + 5
 
 
Оператор + так же выполняет конкатенацию (объединение) строк:

 
-
"hello" + " world"; // "hello world"
+
"hello" + " world"; // "hello world"
 

 
 
При сложении строкового и числового значений происходит автоматическое преобразование в строку. Поначалу такое может запутать:

 
-
"3" + 4 + 5; // "345"
+
"3" + 4 + 5; // "345"
 3 + 4 + "5"; // "75"
 

 
@@ -231,12 +231,12 @@ x = x + 5
 
 
Для сравнения в JavaScript используются следующие операторы: <, >, <= и >=. Сравнивать можно не только числа, но и строки. Проверка на равенство немного сложнее. Для проверки используют двойной (==) или тройной (===) оператор присваивания. Двойной оператор == осуществляет автоматическое преобразование типов, что может приводить к интересным результатам:

 
-
123 == "123"; // true
+
123 == "123"; // true
 1 == true;    // true

 
 
Если преобразование нежелательно, то используют оператор строгого равенства:

 
-
1 === true; // false
+
1 === true; // false
 123 === "123"; // false
 true === true; // true

 
@@ -248,7 +248,7 @@ true === true; // true

 
 
Управляющие структуры в JavaScript очень похожи на таковые в языках семейства C. Условные операторы выражены ключевыми словами if и else, которые можно составлять в цепочки:

 
-
var name = "kittens";
+
var name = "kittens";
 if (name == "puppies") {
   name += "!";
 } else if (name == "kittens") {
@@ -261,7 +261,7 @@ name == "kittens!!"
 
 
В JavaScript есть три типа циклов: while, do-while и for. While используется для задания обычного цикла, а do-while  целесообразно применить в том случае, если вы хотите, чтобы цикл был выполнен хотя бы один раз:

 
-
while (true) {
+
while (true) {
   // бесконечный цикл!
 }
 
@@ -273,41 +273,41 @@ do {
 
 
Цикл for похож на такой же в языках C и Java: он позволяет задавать данные для контроля за выполнением цикла:

 
-
for (var i = 0; i < 5; i++) {
+
for (var i = 0; i < 5; i++) {
   // Выполнится 5 раз
 }
 

 
 
JavaScript также содержит две других известных конструкции: for...of

 
-
for (let value of array) {
+
for (let value of array) {
   // операции с value
 }

 
 
и for...in:

 
-
for (let property in object) {
+
for (let property in object) {
   // операции над свойствами объекта
 }

 
 
Логические операторы && и || используют "короткий цикл вычисления", это значит, что вычисление каждого последующего оператора зависит от предыдущего. Например, полезно проверить существует ли объект или нет, прежде чем пытаться получить доступ к его свойствам:

 
-
var name = o && o.getName();
+
var name = o && o.getName();
 

 
 
Таким способом удобно задавать значения по умолчанию:

 
-
var name = otherName || "default";
+
var name = otherName || "default";
 

 
 
К условным операторам в JavaScript принадлежит также тернарный оператор "?" :

 
-
var allowed = (age > 18) ? "yes" : "no";
+
var allowed = (age > 18) ? "yes" : "no";
 

 
 
Оператор switch используется при необходимости множественного сравнения:

 
-
switch(action) {
+
switch(action) {
     case 'draw':
         drawit();
         break;
@@ -321,7 +321,7 @@ do {
 
 
Если в конце инструкции case не добавить останавливающую инструкцию break, то выполнение перейдёт к следующей инструкции case. Как правило, такое поведение нежелательно, но если вдруг вы решили его использовать, настоятельно рекомендуем писать соответствующий комментарий для облегчения поиска ошибок:

 
-
switch(a) {
+
switch(a) {
     case 1: // fallthrough
     case 2:
         eatit();
@@ -333,7 +333,7 @@ do {
 
 
Вариант default опциональный. Допускается использование выражений как в условии switch, так и в cases. При проверке на равенство используется оператор строгого равенства ===:

 
-
switch(1 + 3) {
+
switch(1 + 3) {
     case 2 + 2:
         yay();
         break;
@@ -358,19 +358,19 @@ do {
 
 
Существует два основных способа создать объект:

 
-
var obj = new Object();
+
var obj = new Object();
 

 
 
А также:

 
-
var obj = {};
+
var obj = {};
 

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

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

 
-
var obj = {
+
var obj = {
   name: "Carrot",
   "for": "Max",
   details: {
@@ -382,12 +382,12 @@ do {
 
 
Доступ к свойствам объекта можно получить следующими способами:

 
-
obj.details.color; // orange
+
obj.details.color; // orange
 obj['details']['size']; // 12

 
 
Эти два метода равнозначны. Первый метод используется, если мы точно знаем к какому методу нам нужно обратиться. Второй метод принимает в качестве имени свойства строку, и позволяет вычислять имя в процессе вычислений. Следует отметить, что последний метод мешает некоторым движкам и минимизаторам оптимизировать код. Если появится необходимость назначить в качестве имён свойств объекта зарезервированные слова, то данный метод тоже может пригодиться:

 
-
// Вызовет Syntax error, ведь 'for' это зарезервированное слово
+
// Вызовет Syntax error, ведь 'for' это зарезервированное слово
 obj.for = "Simon";
 
 // А тут всё нормально
@@ -413,7 +413,7 @@ obj["for"] = "Simon";
 
 
Создать массив можно по старинке:

 
-
var a = new Array();
+
var a = new Array();
 a[0] = "dog";
 a[1] = "cat";
 a[2] = "hen";
@@ -422,13 +422,13 @@ a.length; // 3
 
 
Но гораздо удобнее использовать литерал массива:

 
-
var a = ["dog", "cat", "hen"];
+
var a = ["dog", "cat", "hen"];
 a.length; // 3
 

 
 
Запомните, свойство array.length не обязательно будет показывать количество элементов в массиве. Посмотрите пример:

 
-
var a = ["dog", "cat", "hen"];
+
var a = ["dog", "cat", "hen"];
 a[100] = "fox";
 a.length; // 101
 

@@ -437,19 +437,19 @@ a.length; // 101
 
 
Если попытаться получить доступ к несуществующему элементу массива, то получите undefined:

 
-
typeof a[90]; // undefined
+
typeof a[90]; // undefined
 

 
 
Для перебора элементов массива используйте такой способ:

 
-
for (var i = 0; i < a.length; i++) {
+
for (var i = 0; i < a.length; i++) {
     // Сделать что-нибудь с элементом a[i]
 }
 

 
 
ES2015 представляет более краткий for...of способ обхода по итерируемым объектам, в т.ч. массивам:

 
-
for (const currentValue of a) {
+
for (const currentValue of a) {
   // Сделать что-нибудь с currentValue
 }
 

@@ -458,13 +458,13 @@ a.length; // 101
 
 
И самый новый способ перебора свойств массива был добавлен в ECMAScript 5 — это метод forEach():

 
-
["dog", "cat", "hen"].forEach(function(currentValue, index, array) {
+
["dog", "cat", "hen"].forEach(function(currentValue, index, array) {
 // Сделать что-нибудь с currentValue или array[index]
 });

 
 
Для добавления данных в массив используйте метод push():

 
-
a.push(item);

+
a.push(item);

 
 
У массивов есть ещё множество полезных методов. С их полным списком вы можете ознакомиться по ссылке.

 
@@ -531,7 +531,7 @@ a.length; // 101
 
 
Наряду с объектами функции также являются ключевыми компонентами языка JavaScript. Базовые функции очень просты:

 
-
function add(x, y) {
+
function add(x, y) {
     var total = x + y;
     return total;
 }
@@ -541,17 +541,17 @@ a.length; // 101
 
 
Можно вызвать функцию, вообще не передавая ей параметры. В таком случае будет считаться, что их значения равны undefined:

 
-
add(); // NaN
+
add(); // NaN
 // Нельзя проводить сложение undefined и undefined

 
 
Можно передать больше аргументов, чем ожидает функция:

 
-
add(2, 3, 4); // 5
+
add(2, 3, 4); // 5
 // используются только первые два аргумента, "4" игнорируется

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

 
-
function add() {
+
function add() {
     var sum = 0;
     for (var i = 0, j = arguments.length; i < j; i++) {
         sum += arguments[i];
@@ -564,7 +564,7 @@ add(2, 3, 4, 5); // 14
 
 
Или создадим функцию для вычисления среднего значения:

 
-
function avg() {
+
function avg() {
     var sum = 0;
     for (var i = 0, j = arguments.length; i < j; i++) {
         sum += arguments[i];
@@ -576,7 +576,7 @@ avg(2, 3, 4, 5); // 3.5
 
 
Это довольно  полезно, но при этом кажется излишне подробным. Для уменьшения количества кода взглянем на замену использования массива аргументов синтаксисом остаточных параметров. В этом случае мы можем передавать в функцию любое количество аргументов, сохраняя код минималистичным. Оператор остаточных параметров используется в списке параметров функции в формате: ...variable и включает в себя целый список аргументов, с которыми функция будет вызвана. Мы будем также использовать замену цикла for  циклом for...of для получения значений, которые будет содержать наша переменная.

 
-
function avg(...args) {
+
function avg(...args) {
   var sum = 0;
   for (let value of args) {
     sum += value;
@@ -592,7 +592,7 @@ avg(2, 3, 4, 5); // 3.5

  Важно отметить, что где бы ни был  размещён rest parameter operator в объявлении функции, он будет содержать все аргументы  после его объявления, не раньше. например: function avg(firstValue, ...args) будет хранить первое переданное значение в переменной firstValue и оставшиеся в args. Это ещё одно полезное свойство языка, однако оно ведёт нас к новой проблеме.  avg() функция принимает список аргументов, разделённый запятыми. Но что если вы хотите найти среднее значение в массиве? Вы можете переписать функцию следующим образом:

 
 
-
function avgArray(arr) {
+
function avgArray(arr) {
   var sum = 0;
   for (var i = 0, j = arr.length; i < j; i++) {
     sum += arr[i];
@@ -604,7 +604,7 @@ avgArray([2, 3, 4, 5]); // 3.5

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

 
-
avg.apply(null, [2, 3, 4, 5]); // 3.5
+
avg.apply(null, [2, 3, 4, 5]); // 3.5
 

 
 
Вторым аргументом метода apply() передаётся массив, который будет передан функции в качестве аргументов. О первом аргументе мы поговорим позже. Наличие у функций методов также говорит о том, что на самом деле они являются объектами.

@@ -617,7 +617,7 @@ avgArray([2, 3, 4, 5]); // 3.5

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

 
-
var avg = function() {
+
var avg = function() {
     var sum = 0;
     for (var i = 0, j = arguments.length; i < j; i++) {
         sum += arguments[i];
@@ -628,7 +628,7 @@ avgArray([2, 3, 4, 5]); // 3.5

 
 
Данная запись семантически равнозначна записи function avg(). Это даёт возможность использовать разные интересные трюки. Вот посмотрите, как можно "спрятать" локальные переменные в функции:

 
-
var a = 1;
+
var a = 1;
 var b = 2;
 (function() {
     var b = 3;
@@ -640,7 +640,7 @@ b; // 2
 
 
В JavaScript есть возможность рекурсивного вызова функции. Это может оказаться полезным при работе с иерархическими (древовидными) структурами данных (например такие, которые встречаются при работе с DOM).

 
-
function countChars(elm) {
+
function countChars(elm) {
     if (elm.nodeType == 3) { // TEXT_NODE
         return elm.nodeValue.length;
     }
@@ -654,7 +654,7 @@ b; // 2
 
 
Тут мы сталкиваемся с проблемой: как вызвать функцию рекурсивно, если у неё нет имени? Для этого в JavaScript есть именованные функциональные выражения IIFEs (Immediately Invoked Function Expressions). Вот пример использования именованной самовызывающейся функции:

 
-
var charsInBody = (function counter(elm) {
+
var charsInBody = (function counter(elm) {
     if (elm.nodeType == 3) { // TEXT_NODE
         return elm.nodeValue.length;
     }
@@ -675,7 +675,7 @@ b; // 2
 
В классическом Объектно-Ориентированном Программировании (ООП) объекты — это коллекции данных и методов, которые этими данными оперируют. JavaScript - это язык, основанный на прототипах, и в его определении нет понятия классов, таких, как в языках C++ или Java. (Иногда это может запутать программистов, знакомых с языками, в которых есть классы.) Вместо классов JavaScript использует функции. Давайте представим объект с личными данными, содержащий поля с именем и фамилией. Есть два типа отображения имён: "Имя Фамилия" или "Фамилия, Имя". С помощью объектов и функций можно сделать следующее:

 
 

-
function makePerson(first, last) {
+
function makePerson(first, last) {
     return {
         first: first,
         last: last
@@ -698,7 +698,7 @@ personFullNameReversed(s); // Willison, Simon
 
 
Работает, но сам код никуда не годится. С таким подходом у вас будут десятки функций, засоряющих глобальный объект. Это можно исправить, прикрепив функцию к объекту. Это просто, ведь все функции и есть объекты:

 
-
function makePerson(first, last) {
+
function makePerson(first, last) {
     return {
         first: first,
         last: last,
@@ -717,7 +717,7 @@ s.fullNameReversed(); // Willison, Simon
 
 
А вот кое-что новенькое: ключевое слово 'this'. Когда 'this' используется внутри функции, оно ссылается на текущий объект. Значение ключевого слова зависит от способа вызова функции. Если вызвать функцию с обращением к объекту через точку или квадратные скобки, то 'this' получится равным данному объекту. В ином случае 'this' будет ссылаться на глобальный объект. Это часто приводит к ошибкам. Например:

 
-
s = makePerson("Simon", "Willison")
+
s = makePerson("Simon", "Willison")
 var fullName = s.fullName;
 fullName(); // undefined undefined
 

@@ -726,7 +726,7 @@ fullName(); // undefined undefined
 
 
Используя особенность ключевого слова 'this', можно улучшить код функции makePerson:

 
-
function Person(first, last) {
+
function Person(first, last) {
     this.first = first;
     this.last = last;
     this.fullName = function() {
@@ -745,7 +745,7 @@ var s = new Person("Simon", "Willison");
 
 
Каждый раз, когда с помощью конструктора создаётся новый объект, мы заново создаём и две новые функции. Гораздо удобнее создать эти функции отдельно и дать доступ к ним конструктору:

 
-
function personFullName() {
+
function personFullName() {
     return this.first + ' ' + this.last;
 }
 function personFullNameReversed() {
@@ -761,7 +761,7 @@ function Person(first, last) {
 
 
Уже лучше: мы создали функции-методы только один раз, а при новом вызове функции-конструктора просто ссылаемся на них. Можно сделать ещё лучше? Конечно:

 
-
function Person(first, last) {
+
function Person(first, last) {
     this.first = first;
     this.last = last;
 }
@@ -777,7 +777,7 @@ function Person(first, last) {
 
 
Это очень мощный инструмент. JavaScript позволяет изменять прототипы в любое время, это значит, что можно добавлять новые методы к существующим объектам во время выполнения программы:

 
-
s = new Person("Simon", "Willison");
+
s = new Person("Simon", "Willison");
 s.firstNameCaps();
 // TypeError on line 1: s.firstNameCaps is not a function
 
@@ -789,7 +789,7 @@ s.firstNameCaps(); // "SIMON"
 
 
Занимательно то, что добавлять свойства в прототип можно и для встроенных объектов JavaScript. Давайте добавим новый метод reversed классу String, этот метод будет возвращать строку задом наперёд:

 
-
var s = "Simon";
+
var s = "Simon";
 s.reversed(); // TypeError on line 1: s.reversed is not a function
 
 String.prototype.reversed = function reversed() {
@@ -804,13 +804,13 @@ s.reversed(); // "nomiS"
 
 
Данный метод будет работать даже на литералах строки!

 
-
"This can now be reversed".reversed();
+
"This can now be reversed".reversed();
 // desrever eb won nac sihT
 

 
 
Как уже упоминалось, prototype формирует часть цепочки. Конечным объектом этой цепочки прототипов является Object.prototype, методы которого включают и toString() — тот метод, который вызывается тогда, когда надо получить строковое отображение объекта. Вот что можно сделать с нашими объектами Person:

 
-
var s = new Person("Simon", "Willison");
+
var s = new Person("Simon", "Willison");
 s.toString(); // [object Object]
 
 Person.prototype.toString = function() {
@@ -821,7 +821,7 @@ s.toString(); // "<Person: Simon Willison>"

 
 
Помните, мы вызывали avg.apply() с первым аргументом равным null? Теперь мы можем сделать так: первым аргументом, переданным методу apply() будет объект, который примет значение 'this'. Вот к примеру упрощённая реализация 'new':

 
-
function trivialNew(constructor, ...args) {
+
function trivialNew(constructor, ...args) {
     var o = {}; // Создаём новый объект
     constructor.apply(o, args);
     return o;
@@ -832,15 +832,15 @@ s.toString(); // "<Person: Simon Willison>"

 
 
Вызов

 
-
var bill = trivialNew(Person, 'William', 'Orange');

+
var bill = trivialNew(Person, 'William', 'Orange');

 
 
практически полностью эквивалентен этому:

 
-
var bill = new Person('William', 'Orange');

+
var bill = new Person('William', 'Orange');

 
 
В JavaScript метод apply() имеет похожий метод call(), который тоже позволяет устанавливать 'this', но принимает список, а не массив аргументов.

 
-
function lastNameCaps() {
+
function lastNameCaps() {
     return this.last.toUpperCase();
 }
 var s = new Person("Simon", "Willison");
@@ -853,7 +853,7 @@ s.lastNameCaps(); // WILLISON

 
 
Объявлять новые функции можно и внутри других функций. Мы использовали этот приём чуть выше, создавая функцию makePerson(). Главная особенность вложенных функций в том, что они получают доступ к переменным, объявленным в их функции-родителе:

 
-
function parentFunc() {
+
function parentFunc() {
   var a = 1;
 
   function nestedFunc() {
@@ -871,7 +871,7 @@ s.lastNameCaps(); // WILLISON

 
 
Мы подошли к одному из самых мощных и непонятных инструментов JavaScript. Давайте разберёмся.

 
-
function makeAdder(a) {
+
function makeAdder(a) {
     return function(b) {
         return a + b;
     };
@@ -887,7 +887,7 @@ y(7); // ?
 
 
Такой же фокус мы наблюдали в предыдущем примере, когда внутренние функции получали доступ к переменным той функции, в которой были объявлены. Только в нашем примере основная функция возвращает вложенную. Поначалу может показаться, что локальные переменные при этом перестанут существовать. Но они продолжают существовать — иначе код попросту не сработал бы. Вдобавок ко всему у нас есть две разные "копии" функции makeAdder, присвоенные разным переменным (одна копия, в которой а - это 5, а во второй а - это 20). Вот что имеем в результате вызова:

 
-
x(6); // возвратит 11
+
x(6); // возвратит 11
 y(7); // возвратит 27
 

 
diff --git a/files/ru/web/javascript/closures/index.html b/files/ru/web/javascript/closures/index.html
index 5d8d80d292..c9d5c026fe 100644
--- a/files/ru/web/javascript/closures/index.html
+++ b/files/ru/web/javascript/closures/index.html
@@ -15,7 +15,7 @@ translation_of: Web/JavaScript/Closures
 
Рассмотрим следующий пример:

 
 

-
function init() {
+
function init() {
     var name = "Mozilla"; // name - локальная переменная, созданная в init
     function displayName() { // displayName() - внутренняя функция, замыкание
         alert (name); // displayName() использует переменную, объявленную в родительской функции
@@ -35,7 +35,7 @@ init();

 
 
Рассмотрим следующий пример:

 
-
function makeFunc() {
+
function makeFunc() {
   var name = "Mozilla";
   function displayName() {
     alert(name);
@@ -55,7 +55,7 @@ myFunc();
 
 
А вот немного более интересный пример — функция makeAdder:

 
-
function makeAdder(x) {
+
function makeAdder(x) {
   return function(y) {
     return x + y;
   };
@@ -84,7 +84,7 @@ console.log(add10(2)); // 12
 
 
Давайте рассмотрим практический пример: допустим, мы хотим добавить на страницу несколько кнопок, которые будут менять размер текста. Как вариант, мы можем указать свойство font-size на элементе body в пикселах, а затем устанавливать размер прочих элементов страницы (таких, как заголовки) с использованием относительных единиц em:

 
-
body {
+
body {
   font-family: Helvetica, Arial, sans-serif;
   font-size: 12px;
 }
@@ -102,7 +102,7 @@ h2 {
 
 
Используем следующий JavaScript:

 
-
function makeSizer(size) {
+
function makeSizer(size) {
   return function() {
     document.body.style.fontSize = size + 'px';
   };
@@ -115,12 +115,12 @@ var size16 = makeSizer(16);
 
 
Теперь size12, size14, и size16 - это функции, которые меняют размер текста в элементе body на значения 12, 14, и 16 пикселов, соответственно. После чего мы цепляем эти функции на кнопки примерно так:

 
-
document.getElementById('size-12').onclick = size12;
+
document.getElementById('size-12').onclick = size12;
 document.getElementById('size-14').onclick = size14;
 document.getElementById('size-16').onclick = size16;
 

 
-
<a href="#" id="size-12">12</a>
+
<a href="#" id="size-12">12</a>
 <a href="#" id="size-14">14</a>
 <a href="#" id="size-16">16</a>
 

@@ -135,7 +135,7 @@ document.getElementById('size-16').onclick = size16;
 
 
Код ниже иллюстрирует, как можно использовать замыкания для определения публичных функций, которые имеют доступ к закрытым от пользователя (private) функциям и переменным. Такая манера программирования называется модульное программирование: 

 
-
var Counter = (function() {
+
var Counter = (function() {
   var privateCounter = 0;
   function changeBy(val) {
     privateCounter += val;
@@ -169,7 +169,7 @@ alert(Counter.value()); /* Alerts 1 */
 
 
Заметьте, мы описываем анонимную функцию, создающую счётчик, и тут же запускаем её, присваивая результат исполнения переменной Counter. Но мы также можем не запускать эту функцию сразу, а сохранить её в отдельной переменной, чтобы использовать для дальнейшего создания нескольких счётчиков вот так:

 
-
var makeCounter = function() {
+
var makeCounter = function() {
   var privateCounter = 0;
   function changeBy(val) {
     privateCounter += val;
@@ -206,13 +206,13 @@ alert(Counter2.value()); /* Alerts 0 */
 
 
До того, как в версии ECMAScript 6 ввели ключевое слово let, постоянно возникала следующая проблема при создании замыканий внутри цикла. Рассмотрим пример:

 
-
<p id="help">Helpful notes will appear here</p>
+
<p id="help">Helpful notes will appear here</p>
 <p>E-mail: <input type="text" id="email" name="email"></p>
 <p>Name: <input type="text" id="name" name="name"></p>
 <p>Age: <input type="text" id="age" name="age"></p>
 

 
-
function showHelp(help) {
+
function showHelp(help) {
   document.getElementById('help').innerHTML = help;
 }
 
@@ -244,7 +244,7 @@ setupHelp();
 
 
В качестве решения в этом случае можно предложить использование функции, фабричной функции (function factory), как уже было описано выше в примерах:

 
-
function showHelp(help) {
+
function showHelp(help) {
   document.getElementById('help').innerHTML = help;
 }
 
@@ -282,7 +282,7 @@ setupHelp();
 
 
Давайте рассмотрим не очень практичный, но показательный пример:

 
-
function MyObject(name, message) {
+
function MyObject(name, message) {
   this.name = name.toString();
   this.message = message.toString();
   this.getName = function() {
@@ -297,7 +297,7 @@ setupHelp();
 
 
Поскольку вышеприведённый код никак не использует преимущества замыканий, его можно переписать следующим образом:

 
-
function MyObject(name, message) {
+
function MyObject(name, message) {
   this.name = name.toString();
   this.message = message.toString();
 }
@@ -313,7 +313,7 @@ MyObject.prototype = {
 
 
Методы вынесены в прототип. Тем не менее, переопределять прототип — само по себе является плохой привычкой, поэтому давайте перепишем всё так, чтобы новые методы просто добавились к уже существующему прототипу.

 
-
function MyObject(name, message) {
+
function MyObject(name, message) {
   this.name = name.toString();
   this.message = message.toString();
 }
@@ -327,7 +327,7 @@ MyObject.prototype.getMessage = function() {
 
 
Код выше можно сделать аккуратнее:

 
-
function MyObject(name, message) {
+
function MyObject(name, message) {
     this.name = name.toString();
     this.message = message.toString();
 }
diff --git a/files/ru/web/javascript/data_structures/index.html b/files/ru/web/javascript/data_structures/index.html
index 71eeb219ef..fee4fc9283 100644
--- a/files/ru/web/javascript/data_structures/index.html
+++ b/files/ru/web/javascript/data_structures/index.html
@@ -15,7 +15,7 @@ translation_of: Web/JavaScript/Data_structures
 
 
JavaScript является слабо типизированным или динамическим языком. Это значит, что вам не нужно определять тип переменной заранее. Тип определится автоматически во время выполнения программы. Также это значит, что вы можете использовать одну переменную для хранения данных различных типов:

 
-
var foo = 42; // сейчас foo типа Number
+
var foo = 42; // сейчас foo типа Number
 foo = "bar"; // а теперь foo типа String
 foo = true;  // foo становится типа Boolean
 

@@ -66,7 +66,7 @@ foo = true;  // foo становится типа Boolean
 
 
Ноль в JavaScript имеет два представления: -0 и +0. («0» это синоним +0). На практике это имеет малозаметный эффект. Например, выражение +0 === -0 является истинным. Однако, это может проявиться при делении на ноль:

 
-
> 42 / +0
+
> 42 / +0
 Infinity
 > 42 / -0
 -Infinity

@@ -106,7 +106,7 @@ Infinity
 
 
BigInt является встроенным объектом, который предоставляет способ представления целых чисел, которые больше 2 53, что является наибольшим числом, которое JavaScript может надёжно представить с помощью Number примитива.

 
-
> let bigInt = 19241924124n;
+
> let bigInt = 19241924124n;
 > console.log(bigInt);
 19241924124n
 > console.log(typeof bigInt);
diff --git a/files/ru/web/javascript/guide/control_flow_and_error_handling/index.html b/files/ru/web/javascript/guide/control_flow_and_error_handling/index.html
index 005a702243..4101047db0 100644
--- a/files/ru/web/javascript/guide/control_flow_and_error_handling/index.html
+++ b/files/ru/web/javascript/guide/control_flow_and_error_handling/index.html
@@ -24,13 +24,13 @@ translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling
 
 
Блок обычно используется с управляющими инструкциями (например, if, for, while).

 
-
while (x < 10) { x++; }

+
while (x < 10) { x++; }

 
 
В вышеприведённом примере { x++; } является блоком.

 
 
Обратите внимание: в JavaScript отсутствует область видимости блока до ECMAScript2015. Переменные, объявленные внутри блока, имеют область видимости функции (или скрипта), в которой находится данный блок, вследствие чего они сохранят свои значения при выходе за пределы блока. Другими словами, блок не создаёт новую область видимости. "Автономные" (standalone) блоки в JavaScript могут продуцировать полностью отличающийся результат, от результата в языках C или Java. Например:

 
-
var x = 1;
+
var x = 1;
 {
   var x = 2;
 }
@@ -48,7 +48,7 @@ console.Используйте оператор if для выполнения инструкции, если логическое условия истинно. Используйте опциональный else, для выполнения инструкции, если условие ложно. Оператор if выглядит так:

 
-
if (condition) {
+
if (condition) {
     statement_1;
 } else {
     statement_2;
@@ -58,7 +58,7 @@ console.Также вы можете объединить несколько инструкций, пользуясь else if для получения последовательности проверок условий:

 
-
if (condition_1) { statement_1;} else if (condition_2) { statement_2;} else if (condition_n) { statement_n; } else { statement_last;}

+
if (condition_1) { statement_1;} else if (condition_2) { statement_2;} else if (condition_n) { statement_n; } else { statement_last;}

 
 
В случае нескольких условий только первое логическое условие, которое вычислится истинным (true), будет выполнено. Используйте блок ( { ... } ) для группировки нескольких инструкций. Применение блоков является хорошей практикой, особенно когда используются вложенные инструкции if:

 
@@ -72,12 +72,12 @@ console.Нежелательно использовать простые присваивания в условном выражении, т.к. присваивание может быть спутано с равенством при быстром просмотре кода. Например, не используйте следующий код:

 
-
if (x = y) { /* ... */ }
+
if (x = y) { /* ... */ }
 

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

 
-
if ( (x = y) ) { /* ... */ }

+
if ( (x = y) ) { /* ... */ }

 
 
Ложные значения

 
@@ -96,14 +96,14 @@ console.Не путайте примитивные логические значения true и false со значениями true и false объекта {{jsxref("Boolean")}}. Например:

 
-
var b = new Boolean(false);
+
var b = new Boolean(false);
 if (b) // это условие true
 if (b == true) // это условие false
 

 
 
В следующем примере функция checkData возвращает true, если число символов в объекте Text равно трём; в противном случае функция отображает окно alert и возвращает false.

 
-
function checkData() {
+
function checkData() {
   if (document.form1.threeChar.value.length == 3) {
     return true;
   } else {
@@ -117,7 +117,7 @@ if (b == true) // это условие false
 
 
Инструкция switch позволяет сравнить значение выражения с различными вариантами и при совпадении выполнить соответствующий код. Инструкция имеет следующий вид:

 
-
switch (expression) {
+
switch (expression) {
    case label_1:
       statements_1
       [break;]
@@ -137,7 +137,7 @@ if (b == true) // это условие false
 
 
В следующем примере если fruittype имеет значение "Bananas", то будет выведено сообщение "Bananas are $0.48 a pound." и оператор break прекратит выполнение switch. Если бы оператор break отсутствовал, то был бы также выполнен код, соответствующий ветви "Cherries", т.е. выведено сообщение "Cherries are $3.00 a pound.".

 
-
switch (fruittype) {
+
switch (fruittype) {
   case "Oranges":
     console.log("Oranges are $0.59 a pound.");
     break;
@@ -182,7 +182,7 @@ console.Вы можете выбросить любое выражение, а не только выражения определённого типа. В следующем примере выбрасываются исключения различных типов:

 
-
throw "Error2";                                              // string
+
throw "Error2";                                              // string
 throw 42;                                                    // number
 throw true;                                                  // boolean
 throw { toString: function() { return "I'm an object!"; } }; // object

@@ -191,7 +191,7 @@ console.В следующем примере объект UserException выбрасывается как исключение:

 
-
function UserException (message) {
+
function UserException (message) {
   this.message = message;
   this.name = "UserException";
 }
@@ -208,7 +208,7 @@ console.В следующем примере вызывается функция getMonthName, которая возвращает название месяца по его номеру. Если месяца с указанным номером не существует, то функция выбросит исключение "InvalidMonthNo", которое будет перехвачено в блоке catch:

 
-
function getMonthName(mo) {
+
function getMonthName(mo) {
   mo = mo - 1; // Adjust month number for array index (1 = Jan, 12 = Dec)
   var months = ["Jan","Feb","Mar","Apr","May","Jun","Jul",
                 "Aug","Sep","Oct","Nov","Dec"];
@@ -239,7 +239,7 @@ catch (e) {
 
 
В следующем примере выбрасывается исключение, которое перехватывается в блоке catch:

 
-
try {
+
try {
   throw "myException"
 } catch (e) {
   console.error(e);
@@ -251,7 +251,7 @@ catch (e) {
 
 
В следующем примере открывается файл, затем в блоке try происходит вызов функции writeMyFile, который может выбросить исключение. Если возникает исключение, то оно обрабатывается в блоке catch. В любом случае файл будет закрыт функцией closeMyFile, вызов которой находится в блоке finally.

 
-
openMyFile();
+
openMyFile();
 try {
   writeMyFile(theData);
 } catch(e) {
@@ -262,7 +262,7 @@ catch (e) {
 
 
Если блок finally возвращает значение, то данное значение становится возвращаемым значением всей связки try-catch-finally. Значения, возвращаемые блоками try и catch, будут проигнорированы.

 
-
function f() {
+
function f() {
   try {
     console.log(0);
     throw "bogus";
@@ -282,7 +282,7 @@ catch (e) {
 
 
Замена возвращаемых значений блоком finally распространяется в том числе и на исключения, которые выбрасываются или перевыбрасываются в блоке catch:

 
-
function f() {
+
function f() {
   try {
     throw "bogus";
   } catch(e) {
@@ -314,7 +314,7 @@ catch (e) {
 
 
Если вы выбрасываете собственные исключения, то чтобы получить преимущество, которое предоставляют эти свойства (например, если ваш блок catch не делает различий между вашими исключениями и системными), используйте конструктор Error. Например:

 
-
function doSomethingErrorProne () {
+
function doSomethingErrorProne () {
   if ( ourCodeMakesAMistake() ) {
     throw ( new Error('The message') );
   } else {
@@ -348,7 +348,7 @@ catch (e) {
 
 
Простой пример использования объектов Promise и XMLHttpRequest для загрузки изображения доступен в репозитории MDN promise-test на GitHub. Вы также можете посмотреть его в действии. Каждый шаг прокомментирован, что позволяет вам разобраться в архитектуре Promise и XHR. Здесь приводится версия без комментариев:

 
-
function imgLoad(url) {
+
function imgLoad(url) {
   return new Promise(function(resolve, reject) {
     var request = new XMLHttpRequest();
     request.open('GET', url);
diff --git a/files/ru/web/javascript/guide/modules/index.html b/files/ru/web/javascript/guide/modules/index.html
index 8bf2b4af9c..8416503814 100644
--- a/files/ru/web/javascript/guide/modules/index.html
+++ b/files/ru/web/javascript/guide/modules/index.html
@@ -43,7 +43,7 @@ translation_of: Web/JavaScript/Guide/Modules
 
 
В первом примере (см. директорию basic-modules) у нас следующая структура файлов:

 
-
index.html
+
index.html
 main.js
 modules/
     canvas.js
@@ -106,7 +106,7 @@ modules/
 
 
Самый простой способ использовать экспорт — поместить конструкцию export перед любыми элементами, которые вы хотите экспортировать из модуля, например:

 
-
export const name = 'square';
+
export const name = 'square';
 
 export function draw(ctx, length, x, y, color) {
   ctx.fillStyle = color;
@@ -125,13 +125,13 @@ export function draw(ctx, length, x, y, color) {
 
 
Более удобный способ экспорта всех элементов, которые вы хотите экспортировать,— использовать одну конструкцию export в конце файла модуля, где указать переменные, функции, классы, который вы хотите экспортировать, через запятую в фигурных скобках. Например:

 
-
export { name, draw, reportArea, reportPerimeter };

+
export { name, draw, reportArea, reportPerimeter };

 
 
Импорт функционала в ваш скрипт

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

 
-
import { name, draw, reportArea, reportPerimeter } from './modules/square.js';

+
import { name, draw, reportArea, reportPerimeter } from './modules/square.js';

 
 
Используйте конструкцию {{JSxRef("Statements/import", "import")}}, за которой следует разделенный запятыми список функций, которые вы хотите импортировать, заключённый в фигурные скобки, за которым следует ключевое слово from, за которым следует путь к файлу модуля — путь относительно корня сайта, который для нашего примера basic-modules будет равен /js-examples/modules/basic-modules.

 
@@ -140,11 +140,11 @@ export function draw(ctx, length, x, y, color) {
 
 
Так например:

 
-
/js-examples/modules/basic-modules/modules/square.js

+
/js-examples/modules/basic-modules/modules/square.js

 
 
становится

 
-
./modules/square.js

+
./modules/square.js

 
 
Вы можете найти подобные строки кода в файле main.js.

 
@@ -155,7 +155,7 @@ export function draw(ctx, length, x, y, color) {
 
После того, как вы импортировали функции в свой скрипт, вы можете использовать их так же, как если бы они были определены в этом же файле. 
   Следующий пример можно найти в main.js, сразу за строками импорта:

 
-
let myCanvas = create('myCanvas', document.body, 480, 320);
+
let myCanvas = create('myCanvas', document.body, 480, 320);
 let reportList = createReportList(myCanvas.id);
 
 let square1 = draw(myCanvas.ctx, 50, 50, 100, 'blue');
@@ -177,11 +177,11 @@ reportPerimeter(square1.length, reportList);
 
 
Прежде всего, вам нужно добавить type="module" в <script>-элемент, чтобы объявить, что скрипт является модулем. Чтобы подключить модуль main.js, нужно написать следующее:

 
-
<script type="module" src="main.js"></script>

+
<script type="module" src="main.js"></script>

 
 
Вы также можете встроить скрипт модуля непосредственно в HTML-файл, поместив JavaScript-код внутрь <script>-элемента:

 
-
<script type="module">
+
<script type="module">
   /* код JavaScript модуля */
 </script>

 
@@ -213,25 +213,25 @@ reportPerimeter(square1.length, reportList);
 
Давайте посмотрим на пример, и мы объясним, как это работает.
   В модуле square.js из нашего примера вы можете найти функцию randomSquare(), которая создаёт квардрат случайного цвета и размера со случайными координатами. Мы хотим экпортировать эту функции по умолчанию, поэтому в конце файла пишем следующее:

 
-
export default randomSquare;

+
export default randomSquare;

 
 
Обратите внимание на отсутствие фигурных скобок.

 
 
Кстати, можно было бы определить функцию как анонимную и добавить к ней export default:

 
-
export default function(ctx) {
+
export default function(ctx) {
   ...
 }

 
 
В нашем файле main.js мы импортируем функцию по умолчанию, используя эту строку:

 
-
import randomSquare from './modules/square.js';

+
import randomSquare from './modules/square.js';

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

 
-
import {default as randomSquare} from './modules/square.js';

+
import {default as randomSquare} from './modules/square.js';

 
 

 
Примечание: «as» синтаксис для переименования экспортируемых элементов поясняется ниже в разделе Переименование импорта и экмпорта.

@@ -252,7 +252,7 @@ reportPerimeter(square1.length, reportList);
 
 
Так, например, оба следующих элемента будут выполнять одну и ту же работу, хотя и немного по-разному:

 
-
// внутри module.js
+
// внутри module.js
 export {
   function1 as newFunctionName,
   function2 as anotherNewFunctionName
@@ -261,7 +261,7 @@ export {
 // внутри main.js
 import { newFunctionName, anotherNewFunctionName } from './modules/module.js';

 
-
// внутри module.js
+
// внутри module.js
 export { function1, function2 };
 
 // внутри main.js
@@ -274,11 +274,11 @@ import { function1 as newFunctionName,
 
 
Внутри каждого из этих модулей у нас есть функции с одинаковыми именами, которые экспортируются, и поэтому у каждого из них есть один и тот же оператор export внизу файла:

 
-
export { name, draw, reportArea, reportPerimeter };

+
export { name, draw, reportArea, reportPerimeter };

 
 
Если бы в main.js при их импорте мы попытались использовать

 
-
import { name, draw, reportArea, reportPerimeter } from './modules/square.js';
+
import { name, draw, reportArea, reportPerimeter } from './modules/square.js';
 import { name, draw, reportArea, reportPerimeter } from './modules/circle.js';
 import { name, draw, reportArea, reportPerimeter } from './modules/triangle.js';

 
@@ -286,7 +286,7 @@ import { name, draw, reportArea, reportPerimeter } from './modules/triangle.js';
 
 
Вместо этого нам нужно переименовать импорт, чтобы он был уникальным:

 
-
import { name as squareName,
+
import { name as squareName,
          draw as drawSquare,
          reportArea as reportSquareArea,
          reportPerimeter as reportSquarePerimeter } from './modules/square.js';
@@ -303,13 +303,13 @@ import { name as triangleName,
 
 
Обратите внимание, что вместо этого вы можете решить проблему в файлах модуля, например.

 
-
// внутри square.js
+
// внутри square.js
 export { name as squareName,
          draw as drawSquare,
          reportArea as reportSquareArea,
          reportPerimeter as reportSquarePerimeter };

 
-
// внутри main.js
+
// внутри main.js
 import { squareName, drawSquare, reportSquareArea, reportSquarePerimeter } from './modules/square.js';

 
 
И это сработало бы точно так же.
@@ -322,11 +322,11 @@ import { squareName, drawSquare, reportSquareArea, reportSquarePerimeter } from
   Существует решение получше — импортировать функции каждого модуля внутри объекта модуля.
   Для этого используется следующая синтаксическая форма:

 
-
import * as Module from './modules/module.js';

+
import * as Module from './modules/module.js';

 
 
Эта конструкция берёт все экспорты, доступные внутри module.js и делает их доступными в качестве свойств объекта Module, фактически давая ему собственное пространство имен. Так например:

 
-
Module.function1()
+
Module.function1()
 Module.function2()
 

 и т.д.
@@ -335,11 +335,11 @@ Module.function2()
   вы снова увидите тот же самый пример, но переписанный с учётом преимуществ этого нового синтаксиса.
   В модулях все экспорты представлены в следующей простой форме:

 
-
export { name, draw, reportArea, reportPerimeter };

+
export { name, draw, reportArea, reportPerimeter };

 
 
С другой стороны, импорт выглядит так:

 
-
import * as Canvas from './modules/canvas.js';
+
import * as Canvas from './modules/canvas.js';
 
 import * as Square from './modules/square.js';
 import * as Circle from './modules/circle.js';
@@ -347,7 +347,7 @@ import * as Triangle from './modules/triangle.js';

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

 
-
let square1 = Square.draw(myCanvas.ctx, 50, 50, 100, 'blue');
+
let square1 = Square.draw(myCanvas.ctx, 50, 50, 100, 'blue');
 Square.reportArea(square1.length, reportList);
 Square.reportPerimeter(square1.length, reportList);

 
@@ -360,7 +360,7 @@ Square.reportPerimeter(square1.length, reportList);

 
Вы можете увидеть пример нашего модуля для рисования фигур, переписанного с помощью классов ES в нашей classes директории.
   В качестве примера, файд square.js теперь содержит всю свою функциональность в одном классе:

 
-
class Square {
+
class Square {
   constructor(ctx, listId, length, x, y, color) {
     ...
   }
@@ -374,15 +374,15 @@ Square.reportPerimeter(square1.length, reportList);

 
 
который мы затем экспортируем:

 
-
export { Square };

+
export { Square };

 
 
Далее в main.js, мы импортируем его так:

 
-
import { Square } from './modules/square.js';

+
import { Square } from './modules/square.js';

 
 
А затем используем импортированный класс, чтобы нарисовать наш квадрат:

 
-
let square1 = new Square(myCanvas.ctx, myCanvas.listId, 50, 50, 100, 'blue');
+
let square1 = new Square(myCanvas.ctx, myCanvas.listId, 50, 50, 100, 'blue');
 square1.draw();
 square1.reportArea();
 square1.reportPerimeter();

@@ -393,7 +393,7 @@ square1.reportPerimeter();

   У вас может быть несколько уровней зависимостей, где вы хотите упростить вещи, объединив несколько подмодулей в один родительский модуль.
   Это возможно с использованием следующего синтаксиса экспорта в родительском модуле:

 
-
export * from 'x.js'
+
export * from 'x.js'
 export { name } from 'x.js'

 
 
Для примера посмотрите на нашу директорию module-aggregation.
@@ -402,7 +402,7 @@ export { name } from 'x.js'

   Мы также переместили наши подмодули в дочернюю директорию внутри директории modules под названием shape.
   Итак, структура модуля в этом примере:

 
-
modules/
+
modules/
   canvas.js
   shapes.js
   shapes/
@@ -412,12 +412,12 @@ export { name } from 'x.js'

 
 
В каждом из подмодулей экспорт имеет одинаковую форму, например:

 
-
export { Square };

+
export { Square };

 
 
Далее идет агрегирование.
   Внутри shapes.js, мы добавляем следующие строки:

 
-
export { Square } from './shapes/square.js';
+
export { Square } from './shapes/square.js';
 export { Triangle } from './shapes/triangle.js';
 export { Circle } from './shapes/circle.js';

 
@@ -429,13 +429,13 @@ export { Circle } from './shapes/circle.js';

 
 
Итак, теперь в файле main.js мы можем получить доступ ко всем трём классам модулей, заменив:

 
-
import { Square } from './modules/square.js';
+
import { Square } from './modules/square.js';
 import { Circle } from './modules/circle.js';
 import { Triangle } from './modules/triangle.js';

 
 
на единственную строку кода:

 
-
import { Square, Circle, Triangle } from './modules/shapes.js';

+
import { Square, Circle, Triangle } from './modules/shapes.js';

 
 
Динамическая загрузка модулей

 
@@ -446,7 +446,7 @@ import { Triangle } from './modules/triangle.js';

 
Поддержка динамической загрузки модулей позволяет вызывать {{JSxRef("Statements/import", "import()", "#Dynamic_Imports")}} в качестве функции, передав ей аргументом путь к модулю.
  Данный вызов возвращает {{JSxRef("Promise")}}, который резолвится объектом модуля (см. Создание объекта модуля), предоставляя вам доступ к экспорту указанного модуля, например:

 
-
import('./modules/myModule.js')
+
import('./modules/myModule.js')
   .then((module) => {
     // делаем что-то с функционалом из импортированного модуля
   });

@@ -460,11 +460,11 @@ import { Triangle } from './modules/triangle.js';

 
 
Далее в main.js мы взяли ссылку на каждую кнопку, используя вызов document.querySelector():

 
-
let squareBtn = document.querySelector('.square');

+
let squareBtn = document.querySelector('.square');

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

 
-
squareBtn.addEventListener('click', () => {
+
squareBtn.addEventListener('click', () => {
   import('./modules/square.js').then((Module) => {
     let square1 = new Module.Square(myCanvas.ctx, myCanvas.listId, 50, 50, 100, 'blue');
     square1.draw();
diff --git a/files/ru/web/javascript/guide/regular_expressions/character_classes/index.html b/files/ru/web/javascript/guide/regular_expressions/character_classes/index.html
index f9e2b054a3..8a379e7653 100644
--- a/files/ru/web/javascript/guide/regular_expressions/character_classes/index.html
+++ b/files/ru/web/javascript/guide/regular_expressions/character_classes/index.html
@@ -149,7 +149,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions/Character_Classes
 
 
Поиск серии цифр

 
-
var randomData = "015 354 8787 687351 3512 8735";
+
var randomData = "015 354 8787 687351 3512 8735";
 var regexpFourDigits = /\b\d{4}\b/g;
 // \b определяет границу поиска (например, не начинает поиск с середины слова)
 // \d{4} определяет цифру, четыре раза
@@ -162,7 +162,7 @@ console.table(randomData.match(regexpFourDigits));
 
 
Поиск слов  (латинский алфавит), начинающих с A

 
-
var aliceExcerpt = "I’m sure I’m not Ada,’ she said, ‘for her hair goes in such long ringlets, and mine doesn’t go in ringlets at all.";
+
var aliceExcerpt = "I’m sure I’m not Ada,’ she said, ‘for her hair goes in such long ringlets, and mine doesn’t go in ringlets at all.";
 var regexpWordStartingWithA = /\b[aA]\w+/g;
 // \b определяет границу поиска (например, не начинает поиск с середины слова)
 // [aA] определяет букву a или A
@@ -176,7 +176,7 @@ console.table(aliceExcerpt.match(regexpWordStartingWithA));
 
 
Вместо латинского алфавита, мы может использовать диапазон Unicode символов для определения слова (благодаря этому мы можем работать с текстами написанным, например на русском или арабском языке or Arabic). Unicode содержит большинство символов используемых на планете, мы так же можем объединять их диапазоны и классы символов.

 
-
var nonEnglishText = "Приключения Алисы в Стране чудес";
+
var nonEnglishText = "Приключения Алисы в Стране чудес";
 var regexpBMPWord = /([\u0000-\u0019\u0021-\uFFFF])+/gu;
 // BMP goes through U+0000 to U+FFFF but space is U+0020
 
diff --git a/files/ru/web/javascript/guide/regular_expressions/index.html b/files/ru/web/javascript/guide/regular_expressions/index.html
index d6a9f157de..d92683f778 100644
--- a/files/ru/web/javascript/guide/regular_expressions/index.html
+++ b/files/ru/web/javascript/guide/regular_expressions/index.html
@@ -14,7 +14,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions
 
    
  
  • Используя литерал регулярного выражения, например:
   
    
-  
    var re = /ab+c/;
+  
    var re = /ab+c/;
 
    
   
    
 
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions
  
    • 
  
  • Вызывая функцию конструктор объекта RegExp, например:
   
    
-  
    var re = new RegExp("ab+c");
+  
    var re = new RegExp("ab+c");
 
    
   
    
 
@@ -321,7 +321,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions
 
 
    Экранирование пользовательского ввода, соответствующего буквенной строке внутри регулярного выражения, может быть достигнуто простой заменой: 
    
 
-
    function escapeRegExp(string){
+
    function escapeRegExp(string){
   return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
 }
    
 
@@ -379,18 +379,18 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions
 
 
    В след. примере, скрипт использует метод exec чтобы найти совпадения в строке.
    
 
-
    var myRe = /d(b+)d/g;
+
    var myRe = /d(b+)d/g;
 var myArray = myRe.exec("cdbbdbsbz");
 
    
 
 
    Если вам не нужен доступ к свойствам регулярного выражения, то альтернативный способ получить myArray можно так:
    
 
-
    var myArray = /d(b+)d/g.exec("cdbbdbsbz");
+
    var myArray = /d(b+)d/g.exec("cdbbdbsbz");
 
    
 
 
    Если вы хотите сконструировать регулярное выражение из строки, другой способ сделать это приведён ниже:
    
 
-
    var myRe = new RegExp("d(b+)d", "g");
+
    var myRe = new RegExp("d(b+)d", "g");
 var myArray = myRe.exec("cdbbdbsbz");
 
    
 
@@ -444,25 +444,25 @@ var myArray = myRe.exec("cdbbdbsbz");
 
 
    Как показано во втором варианте этого примера, вы можете использовать регулярное выражение, созданное при помощи инициализатора объекта, без присваивания его переменной. Таким образом, если вы используете данную форму записи без присваивания переменной, то в процессе дальнейшего использования вы не можете получить доступ к свойствам данного регулярного выражения. Например, у вас есть следующий скрипт:
    
 
-
    var myRe = /d(b+)d/g;
+
    var myRe = /d(b+)d/g;
 var myArray = myRe.exec("cdbbdbsbz");
 console.log("The value of lastIndex is " + myRe.lastIndex);
 
    
 
 
    Этот скрипт выведет:
    
 
-
    The value of lastIndex is 5
+
    The value of lastIndex is 5
 
    
 
 
    Однако, если у вас есть следующий скрипт:
    
 
-
    var myArray = /d(b+)d/g.exec("cdbbdbsbz");
+
    var myArray = /d(b+)d/g.exec("cdbbdbsbz");
 console.log("The value of lastIndex is " + /d(b+)d/g.lastIndex);
 
    
 
 
    Он выведет:
    
 
-
    The value of lastIndex is 0
+
    The value of lastIndex is 0
 
    
 
 
    Совпадения /d(b+)d/g в двух случаях являются разными объектами регулярного выражения и, следовательно, имеют различные значения для свойства lastIndex. Если вам необходим доступ к свойствам объекта, созданного при помощи инициализатора, то вы должны сначала присвоить его переменной.
    
@@ -477,7 +477,7 @@ console.log("The value of lastIndex is " + /d(b+)d/g.lastIndex);
 
 
    Следующий скрипт использует метод replace(), чтобы поменять местами слова (символы) в строке. Для замены текста скрипт использует обозначения  $1 и $2 для обозначения первого и второго совпадения скобочного выражения.
    
 
-
    var re = /(\w+)\s(\w+)/;
+
    var re = /(\w+)\s(\w+)/;
 var str = "John Smith";
 var newstr = str.replace(re, "$2, $1");
 console.log(newstr);
@@ -519,19 +519,19 @@ console.log(newstr);
 
 
    Чтобы использовать флаги в шаблоне регулярного выражения используйте следующий синтаксис:
    
 
-
    var re = /pattern/flags;
+
    var re = /pattern/flags;
 
    
 
 
    или
    
 
-
    var re = new RegExp("pattern", "flags");
+
    var re = new RegExp("pattern", "flags");
 
    
 
 
    Обратите внимание, что флаги являются неотъемлемой частью регулярного выражения. Флаги не могут быть добавлены или удалены позднее.
    
 
 
    Для примера, re = /\w+\s/g создаёт регулярное выражение, которое ищет один или более символов, после которых следует пробел и ищет данное совпадение на протяжении всей строки.
    
 
-
    var re = /\w+\s/g;
+
    var re = /\w+\s/g;
 var str = "fee fi fo fum";
 var myArray = str.match(re);
 console.log(myArray);
@@ -539,12 +539,12 @@ console.log(myArray);
 
 
    Выведет  ["fee ", "fi ", "fo "]. В этом примере вы бы могли заменить строку:
    
 
-
    var re = /\w+\s/g;
+
    var re = /\w+\s/g;
 
    
 
 
    на следующую:
    
 
-
    var re = new RegExp("\\w+\\s", "g");
+
    var re = new RegExp("\\w+\\s", "g");
 
    
 
 
    и получить тот же результат.
    
@@ -559,7 +559,7 @@ console.log(myArray);
 
 
    След. пример иллюстрирует формирование регулярного выражения и использование string.split() и string.replace(). Он очищает неправильно сформатированную исходную строку, которая содержит имена в неправильном порядке (имя идёт первым) разделённые пробелами, табуляцией и одной точкой с запятой. В конце, изменяется порядок следования имён (фамилия станет первой) и сортируется список.
    
 
-
    // The name string contains multiple spaces and tabs,
+
    // The name string contains multiple spaces and tabs,
 // and may have multiple spaces between first and last names.
 var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";
 
@@ -629,7 +629,7 @@ console.log(output.join("\n"));
 
 
    Событие "Изменить" активируется, когда пользователь подтвердит ввод значения регулярного выражения, нажав клавишу "Enter". 
    
 
-
    <!DOCTYPE html>
+
    <!DOCTYPE html>
 <html>
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
@@ -655,5 +655,5 @@ console.log(output.join("\n"));
 </html>
 
    
 
-
    autoPreviousNext("JSGChapters");
+
    autoPreviousNext("JSGChapters");
 
    
diff --git a/files/ru/web/javascript/inheritance_and_the_prototype_chain/index.html b/files/ru/web/javascript/inheritance_and_the_prototype_chain/index.html
index 5ed538ca47..eaca7bd05f 100644
--- a/files/ru/web/javascript/inheritance_and_the_prototype_chain/index.html
+++ b/files/ru/web/javascript/inheritance_and_the_prototype_chain/index.html
@@ -23,7 +23,7 @@ translation_of: Web/JavaScript/Inheritance_and_the_prototype_chain
 
    Объекты в JavaScript — динамические "контейнеры", наполненные свойствами (называемыми собственными свойствами). Каждый объект содержит ссылку на свой объект-прототип.
    
  При попытке получить доступ к какому-либо свойству объекта, свойство вначале ищется в самом объекте, затем в прототипе объекта, после чего в прототипе прототипа, и так далее. Поиск ведётся до тех пор, пока не найдено свойство с совпадающим именем или не достигнут конец цепочки прототипов.
    
 
-
    // В этом примере someObject.[[Prototype]] означает прототип someObject.
+
    // В этом примере someObject.[[Prototype]] означает прототип someObject.
 // Это упрощённая нотация (описанная в стандарте ECMAScript).
 // Она не может быть использована в реальных скриптах.
 
@@ -74,7 +74,7 @@ console.log(o.d); // undefined
 
 
    В области видимости унаследованной функции ссылка this указывает на наследующий объект (на наследника), а не на прототип, в котором данная функция является собственным свойством.
    
 
-
    var o = {
+
    var o = {
   a: 2,
   m: function(){
     return this.a + 1;
@@ -98,7 +98,7 @@ console.log(p.m()); // 13
 
 
    Создание объектов с помощью литералов
    
 
-
    var o = {a: 1};
+
    var o = {a: 1};
 
 // Созданный объект 'o' имеет Object.prototype в качестве своего [[Prototype]]
 // у 'o' нет собственного свойства 'hasOwnProperty'
@@ -127,7 +127,7 @@ function f(){
 
 
    В JavaScript "конструктор" — это "просто" функция, вызываемая с оператором new.
    
 
-
    function Graph() {
+
    function Graph() {
   this.vertexes = [];
   this.edges = [];
 }
@@ -147,7 +147,7 @@ var g = new Graph();
 
 
    В ECMAScript 5 представлен новый метод создания объектов: Object.create. Прототип создаваемого объекта указывается в первом аргументе этого метода:
    
 
-
    var a = {a: 1};
+
    var a = {a: 1};
 // a ---> Object.prototype ---> null
 
 var b = Object.create(a);
@@ -168,7 +168,7 @@ console.log(d.hasOwnProperty);
 
 
    С выходом ECMAScript 6 появился целый набор ключевых слов, реализующих классы. Они могут показаться знакомыми людям, изучавшим языки, основанные на классах, но есть существенные отличия. JavaScript был и остаётся прототипно-ориентированным языком. Новые ключевые слова: "class", "constructor", "static", "extends" и "super".
    
 
-
    "use strict";
+
    "use strict";
 
 class Polygon {
   constructor(height, width) {
@@ -217,7 +217,7 @@ var square = new Square(2);
    
 
 
    B наследует от A:
    
 
-
    function A(a){
+
    function A(a){
   this.varA = a;
 }
 
@@ -274,17 +274,17 @@ b.doSomething();
    
 
 
    [[Prototype]] работает рекурсивно, то есть при вызове:
    
 
-
    var o = new Foo();
    
+
    var o = new Foo();
    
 
 
    JavaScript на самом деле выполняет что-то подобное:
    
 
-
    var o = new Object();
+
    var o = new Object();
 o.[[Prototype]] = Foo.prototype;
 Foo.call(o);
    
 
 
    а когда вы делаете так:
    
 
-
    o.someProp;
    
+
    o.someProp;
    
 
 
    JavaScript проверяет, есть ли у o свойство someProp.
    
  и если нет, то проверяет Object.getPrototypeOf(o).someProp 
    
diff --git a/files/ru/web/javascript/memory_management/index.html b/files/ru/web/javascript/memory_management/index.html
index 4fa942b997..4399b25d64 100644
--- a/files/ru/web/javascript/memory_management/index.html
+++ b/files/ru/web/javascript/memory_management/index.html
@@ -28,7 +28,7 @@ translation_of: Web/JavaScript/Memory_Management
 
    Чтобы не утруждать программиста заботой о низкоуровневых операциях выделения памяти, интерпретатор JavaScript динамически выделяет необходимую память при объявлении переменных:
    
 
 
    
-
    var n = 123; // выделяет память для типа number
+
    var n = 123; // выделяет память для типа number
 var s = "azerty"; // выделяет память для типа string
 
 var o = {
@@ -53,13 +53,13 @@ someElement.addEventListener('click', function(){
 
 
    Вызовы некоторых функций также ведут к выделению памяти под объект:
    
 
-
    var d = new Date();
+
    var d = new Date();
 var e = document.createElement('div'); // выделяет память под DOM-элемент
 
    
 
 
    Некоторые методы выделяют память для новых значений или объектов:
    
 
-
    var s = "azerty";
+
    var s = "azerty";
 var s2 = s.substr(0, 3); // s2 это новый объект типа string
 // Т.к. строки - это постоянные значения, интерпретатор может решить, что память выделять не нужно, но нужно лишь сохранить диапазон [0, 3].
 
@@ -94,7 +94,7 @@ var a3 = a.concat(a2); // новый массив с 4 элементами в 
 
 
    Пример
    
 
-
    var o = {
+
    var o = {
   a: {
     b:2
   }
@@ -121,7 +121,7 @@ oa = null; // оригинальное значение поля объекта
 
 
    Основное ограничение данного наивного алгоритма заключается в том, что если два объекта ссылаются друг на друга (создавая таким образом циклическую ссылку), они не могут быть уничтожены сборщиком мусора, даже если "более не нужны".
    
 
-
    function f(){
+
    function f(){
   var o = {};
   var o2 = {};
   o.a = o2; // o ссылается на o2
@@ -139,7 +139,7 @@ f();
 
 
    Браузеры Internet Explorer версий 6, 7 имеют сборщик мусора для DOM-объектов, работающий по принципу подсчёта ссылок. Поэтому данные браузеры можно легко принудить к порождению систематических утечек памяти (memory leaks) следующим образом:
    
 
-
    var div;
+
    var div;
 window.onload = function(){
   div = document.getElementById("myDivElement");
   div.circularReference = div; // DOM-элемент "myDivElement" получает ссылку на себя
diff --git a/files/ru/web/javascript/reference/classes/constructor/index.html b/files/ru/web/javascript/reference/classes/constructor/index.html
index 3b0b38b700..81546fdb27 100644
--- a/files/ru/web/javascript/reference/classes/constructor/index.html
+++ b/files/ru/web/javascript/reference/classes/constructor/index.html
@@ -14,13 +14,13 @@ translation_of: Web/JavaScript/Reference/Classes/constructor
 
 
    Синтаксис
    
 
-
    constructor([arguments]) { ... }
    
+
    constructor([arguments]) { ... }
    
 
 
    Описание
    
 
 
    Конструктор позволяет произвести начальную инициализацию, которая должна быть выполнена до того, как остальные методы будут вызваны.
    
 
-
    class Person {
+
    class Person {
 
   constructor(name) {
     this.name = name;
@@ -38,17 +38,17 @@ otto.introduce();
    
 
 
    Если вы не определили метод constructor, то будет использован конструктор по умолчанию. Если ваш класс базовый, то конструктор по умолчанию пустой:
    
 
-
    constructor() {}
    
+
    constructor() {}
    
 
 
    Если ваш класс является производным классом, конструктор по умолчанию вызывает родительский конструктор, передавая любые аргументы, которые были предоставлены:
    
 
-
    constructor(...args) {
+
    constructor(...args) {
   super(...args);
 }
    
 
 
    Это позволяет работать следующему коду:
    
 
-
    class ValidationError extends Error {
+
    class ValidationError extends Error {
 
   printCustomerMessage() {
     return `Проверка не удалась :-( (подробности: ${this.message})`;
@@ -72,7 +72,7 @@ try {
 
 
    Однако, если определён ваш собственный конструктор и класс является производным от какого-либо родительского класса, то вы должны явно объявить конструктор родительского класса, используя super. К примеру:
    
 
-
    class ValidationError extends Error {
+
    class ValidationError extends Error {
 
   constructor(message) {
     super(message);  // вызов конструктора родительского класса
@@ -106,7 +106,7 @@ try {
 
 
    Данный фрагмент кода взят из classes sample (live demo).
    
 
-
    class Square extends Polygon {
+
    class Square extends Polygon {
   constructor(length) {
     // Здесь вызывается конструктор родительского класса,
     // в который передаётся length в качестве аргументов,
@@ -130,7 +130,7 @@ try {
 
 
    Посмотрите на этот отрывок кода.
    
 
-
    class Polygon {
+
    class Polygon {
   constructor() {
     this.name = "Polygon";
   }
@@ -158,11 +158,11 @@ console.log(newInstance.name); //Polygon
    
 
 
    Если вы не определите метод constructor, будет использован constructor по умолчанию. Для базовых классов, constructor по умолчанию:
    
 
-
    constructor() {}
    
+
    constructor() {}
    
 
 
    Для производных классов, constructor по умолчанию:
    
 
-
    constructor(...args) {
+
    constructor(...args) {
   super(...args);
 }
    
 
diff --git a/files/ru/web/javascript/reference/classes/index.html b/files/ru/web/javascript/reference/classes/index.html
index f8a63e92b2..742cd341ca 100644
--- a/files/ru/web/javascript/reference/classes/index.html
+++ b/files/ru/web/javascript/reference/classes/index.html
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Reference/Classes
 
 
    Первый способ определения класса — class declaration (объявление класса). Для этого необходимо воспользоваться ключевым словом class и указать имя класса (в примере — «Rectangle»).
    
 
-
    class Rectangle {
+
    class Rectangle {
   constructor(height, width) {
     this.height = height;
     this.width = width;
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Classes
 
 
    Разница между объявлением функции (function declaration) и объявлением класса (class declaration) в том, что объявление функции совершает подъём ({{Glossary("Hoisting", "hoisting")}}), в то время как объявление класса — нет. Поэтому вначале необходимо объявить ваш класс и только затем работать с ним, а код же вроде следующего сгенерирует исключение типа {{jsxref("ReferenceError")}}:
    
 
-
    var p = new Rectangle(); // ReferenceError
+
    var p = new Rectangle(); // ReferenceError
 
 class Rectangle {}
    
 
@@ -41,7 +41,7 @@ class Rectangle {}
    
 
 
    Второй способ определения класса — class expression (выражение класса). Можно создавать именованные и безымянные выражения. В первом случае имя выражения класса находится в локальной области видимости класса и может быть получено через свойства самого класса, а не его экземпляра.
    
 
-
    // безымянный
+
    // безымянный
 var Rectangle = class {
   constructor(height, width) {
     this.height = height;
@@ -84,7 +84,7 @@ console.log(Rectangle.name);
 
 
    Смотрите также определение методов.
    
 
-
    class Rectangle {
+
    class Rectangle {
   constructor(height, width) {
     this.height = height;
     this.width = width;
@@ -107,7 +107,7 @@ console.log(square.area); // 100
    
 
 
    Ключевое слово static, определяет статический метод или свойства для класса. Статические методы и свойства вызываются без инстанцирования их класса, и не могут быть вызваны у экземпляров (instance) класса. Статические методы, часто используются для создания служебных функций для приложения, в то время как статические свойства полезны для кеширования в рамках класса, фиксированной конфигурации или любых других целей, не связанных с реплецированием данных между экземплярами.
    
 
-
    class Point {
+
    class Point {
   constructor(x, y) {
     this.x = x;
     this.y = y;
@@ -136,7 +136,7 @@ console.log(Point.distance(p1, p2)); // 7.0710678118654755
    
 
 
    Когда статический или прототипный метод вызывается без привязки к this объекта (или когда this является типом boolean, string, number, undefined, null), тогда this будет иметь значение undefined внутри вызываемой функции. Автоупаковка не будет произведена. Поведение будет таким же как если бы мы писали код в нестрогом режиме.
    
 
-
    class Animal {
+
    class Animal {
   speak() {
     return this;
   }
@@ -156,7 +156,7 @@ eat(); // undefined
    
 
 
    Если мы напишем этот же код используя классы основанные на функциях, тогда произойдёт автоупаковка основанная на значении this, в течение которого функция была вызвана. В строгом режиме автоупаковка не произойдёт - значение this останется прежним.
    
 
-
    function Animal() { }
+
    function Animal() { }
 
 Animal.prototype.speak = function(){
   return this;
@@ -178,7 +178,7 @@ eat(); // глобальный объект (нестрогий режим)Свойства экземпляра должны быть определены в методе класса:
    
 
-
    class Rectangle {
+
    class Rectangle {
   constructor(height, width) {
     this.height = height;
     this.width = width;
@@ -187,7 +187,7 @@ eat(); // глобальный объект (нестрогий режим)Статические (class-side) свойства и свойства прототипа должны быть определены за рамками тела класса:
    
 
-
    Rectangle.staticWidth = 20;
+
    Rectangle.staticWidth = 20;
 Rectangle.prototype.prototypeWidth = 25;
 
    
 
@@ -201,7 +201,7 @@ Rectangle.prototype.prototypeWidth = 25;
 
 
    Используя Javascript синтаксис определения полей, приведённый выше пример может быть изменён следующим образом:
    
 
-
    class Rectangle {
+
    class Rectangle {
   height = 0;
   width;
   constructor(height, width) {
@@ -218,7 +218,7 @@ Rectangle.prototype.prototypeWidth = 25;
 
 
    Предыдущий пример может быть изменён следующим образом, используя приватные поля:
    
 
-
    class Rectangle {
+
    class Rectangle {
   #height = 0;
   #width;
   constructor(height, width) {
@@ -241,7 +241,7 @@ Rectangle.prototype.prototypeWidth = 25;
 
 
    Ключевое слово extends используется в объявлениях классов и выражениях классов для создания класса, дочернего относительно другого класса.
    
 
-
    class Animal {
+
    class Animal {
   constructor(name) {
     this.name = name;
   }
@@ -268,7 +268,7 @@ d.speak(); // Митци лает
    
 
 
    Аналогичным образом можно расширять традиционные, основанные на функциях "классы":
    
 
-
    function Animal (name) {
+
    function Animal (name) {
   this.name = name;
 }
 Animal.prototype.speak = function () {
@@ -288,7 +288,7 @@ d.speak(); // Митци лает
 
 
    Обратите внимание, что классы не могут расширять обычные (non-constructible) объекты. Если вам необходимо создать наследование от обычного объекта, в качестве замены можно использовать {{jsxref("Object.setPrototypeOf()")}}:
    
 
-
    var Animal = {
+
    var Animal = {
   speak() {
     console.log(`${this.name} издаёт звук.`);
   }
@@ -312,7 +312,7 @@ d.speak(); // Митци издаёт звук.
    
 
 
    Например, при использовании таких методов, как {{jsxref("Array.map", "map()")}}, который возвращает конструктор по умолчанию, вам хотелось бы, чтобы они возвращали родительский объект Array вместо объекта MyArray. Символ {{jsxref("Symbol.species")}} позволяет это реализовать:
    
 
-
    class MyArray extends Array {
+
    class MyArray extends Array {
   // Изменить species на родительский конструктор Array
   static get [Symbol.species]() { return Array; }
 }
@@ -326,7 +326,7 @@ console.log(mapped instanceof Array);   // true
    
 
 
    Ключевое слово super используется для вызова функций на родителе объекта.
    
 
-
    class Cat {
+
    class Cat {
   constructor(name) {
     this.name = name;
   }
@@ -355,7 +355,7 @@ l.speak();
 
 
    Для реализации mix-ins в ECMAScript можно использовать функцию, которая в качестве аргумента принимает родительский класс, а возвращает подкласс, его расширяющий:
    
 
-
    var calculatorMixin = Base => class extends Base {
+
    var calculatorMixin = Base => class extends Base {
   calc() { }
 };
 
@@ -365,7 +365,7 @@ var randomizerMixin = Base => class extends Base {
 
 
    Класс, использующий такие mix-ins, можно описать следующим образом:
    
 
-
    class Foo { }
+
    class Foo { }
 class Bar extends calculatorMixin(randomizerMixin(Foo)) { }
    
 
 
    Спецификации
    
diff --git a/files/ru/web/javascript/reference/classes/private_class_fields/index.html b/files/ru/web/javascript/reference/classes/private_class_fields/index.html
index 356e8b5517..597d98ebeb 100644
--- a/files/ru/web/javascript/reference/classes/private_class_fields/index.html
+++ b/files/ru/web/javascript/reference/classes/private_class_fields/index.html
@@ -10,7 +10,7 @@ original_slug: Web/JavaScript/Reference/Classes/Приватные_поля_кл
 
 
    Синтаксис
    
 
-
    class ClassWithPrivateField {
+
    class ClassWithPrivateField {
   #privateField
 }
 
@@ -33,7 +33,7 @@ class ClassWithPrivateStaticField {
 
 
    Ограничение статических переменных, вызываемых только статическими методами, все ещё сохраняется.
    
 
-
    class ClassWithPrivateStaticField {
+
    class ClassWithPrivateStaticField {
   static #PRIVATE_STATIC_FIELD
 
   static publicStaticMethod() {
@@ -50,7 +50,7 @@ console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42)
    
 
 
    Это может привести к неожиданному поведению при использовании this.
    
 
-
    class BaseClassWithPrivateStaticField {
+
    class BaseClassWithPrivateStaticField {
   static #PRIVATE_STATIC_FIELD
 
   static basePublicStaticMethod() {
@@ -76,7 +76,7 @@ console.assert(error instanceof TypeError)
 
 
    Инкапсуляция обеспечивается языком. Обращение к # именам вне области видимости является синтаксической ошибкой.
    
 
-
    class ClassWithPrivateField {
+
    class ClassWithPrivateField {
   #privateField
 
   constructor() {
@@ -99,7 +99,7 @@ instance.#privateField === 42 // Syntax error
 
 
    Приватные статические методы могут быть генераторами, асинхронными функциями и асинхронными функциями-генераторами.
    
 
-
    class ClassWithPrivateStaticMethod {
+
    class ClassWithPrivateStaticMethod {
     static #privateStaticMethod() {
         return 42
     }
@@ -119,7 +119,7 @@ console.assert(ClassWithPrivateStaticMethod.publicStaticMethod2() === 42);
 
 
    Это может привести к неожиданному поведению при его использовании this. В следующем примере this относится к классу Derived (а не к классу Base), когда мы пытаемся вызвать Derived.publicStaticMethod2(), и, таким образом, имеет такое же "ограничение по происхождению", как упоминалось выше:
    
 
-
    class Base {
+
    class Base {
     static #privateStaticMethod() {
         return 42;
     }
@@ -141,7 +141,7 @@ console.log(Derived.publicStaticMethod2()); // TypeError
 
 
    Приватные методы экземпляров это методы, доступные у экземпляров класса, доступ к которым запрещён также, как у приватных полей класса.
    
 
-
    class ClassWithPrivateMethod {
+
    class ClassWithPrivateMethod {
   #privateMethod() {
     return 'hello world'
   }
@@ -157,7 +157,7 @@ console.log(instance.getPrivateMessage())
 
 
    Приватные методы экземпляров могут быть генератором, async, или функциями async генератора. Приватные геттеры и сеттеры также возможны:
    
 
-
    class ClassWithPrivateAccessor {
+
    class ClassWithPrivateAccessor {
   #message
 
   get #decoratedMessage() {
diff --git a/files/ru/web/javascript/reference/classes/public_class_fields/index.html b/files/ru/web/javascript/reference/classes/public_class_fields/index.html
index 865babfded..0c4eb7a7ea 100644
--- a/files/ru/web/javascript/reference/classes/public_class_fields/index.html
+++ b/files/ru/web/javascript/reference/classes/public_class_fields/index.html
@@ -47,7 +47,7 @@ class ClassWithPublicInstanceMethod {
 
 
    Публичные статические поля объявляются при помощи ключевого слова static. Они добавляются в конструктор класса во время его создания с помощью {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}. Доступ также осуществляется через конструктор класса.
    
 
-
    class ClassWithStaticField {
+
    class ClassWithStaticField {
   static staticField = 'static field';
 }
 
@@ -57,7 +57,7 @@ console.log(ClassWithStaticField.staticField);
 
 
    Поля без инициализации имеют значение undefined.
    
 
-
    class ClassWithStaticField {
+
    class ClassWithStaticField {
   static staticField;
 }
 
@@ -67,7 +67,7 @@ console.log(ClassWithStaticField.staticField);
 
 
    Публичные статические поля не переопределяются в наследниках класса, а могут быть доступны через иерархию прототипов.
    
 
-
    class ClassWithStaticField {
+
    class ClassWithStaticField {
   static baseStaticField = 'base field';
 }
 
@@ -83,7 +83,7 @@ console.log(SubClassWithStaticField.baseStaticField);
 
 
    При определении полей this ссылается на конструктор класса. Также можно обратиться к нему по имени и использовать super для получения конструктора базового класса, если он существует.
    
 
-
    class ClassWithStaticField {
+
    class ClassWithStaticField {
   static baseStaticField = 'base static field';
   static anotherBaseStaticField = this.baseStaticField;
 
@@ -108,7 +108,7 @@ console.log(SubClassWithStaticField.subStaticField);
 
    Публичные поля экземпляра добавляются через {{jsxref("Global_Objects/Object/defineProperty",
   "Object.defineProperty()")}} либо перед тем, как будет исполнено тело конструктора в базовом классе, либо после того, как завершится super() в классе наследнике.
    
 
-
    class ClassWithInstanceField {
+
    class ClassWithInstanceField {
   instanceField = 'instance field';
 }
 
@@ -118,7 +118,7 @@ console.log(instance.instanceField);
 
 
    Поля без инициализации имеют значение undefined.
    
 
-
    class ClassWithInstanceField {
+
    class ClassWithInstanceField {
   instanceField;
 }
 
@@ -129,7 +129,7 @@ console.log(instance.instanceField);
 
 
    Как и свойства, названия полей могут вычисляться.
    
 
-
    const PREFIX = 'prefix';
+
    const PREFIX = 'prefix';
 
 class ClassWithComputedFieldName {
     [`${PREFIX}Field`] = 'prefixed field';
@@ -141,7 +141,7 @@ console.log(instance.prefixField);
 
 
    При определении полей this ссылается на создающийся экземпляр класса. Как и в публичных методах экземпляра, получить доступ к прототипу базового класса можно с помощью super.
    
 
-
    class ClassWithInstanceField {
+
    class ClassWithInstanceField {
   baseInstanceField = 'base field';
   anotherBaseInstanceField = this.baseInstanceField;
   baseInstanceMethod() { return 'base method output'; }
@@ -166,7 +166,7 @@ console.log(sub.subInstanceField);
 
 
    Ключевое слово static объявляет статический метод класса. Статические методы не вызываются из экземпляра, вместо этого они вызывается из самого класса. Чаще всего это какие-либо служебные функции, такие как функции создания или копирования объектов.
    
 
-
    class ClassWithStaticMethod {
+
    class ClassWithStaticMethod {
   static staticMethod() {
     return 'static method has been called.';
   }
@@ -182,7 +182,7 @@ console.log(ClassWithStaticMethod.staticMethod());
 
 
    Как и следует из названия, публичные методы экземпляра это методы, доступные для вызова из экземпляров.
    
 
-
    class ClassWithPublicInstanceMethod {
+
    class ClassWithPublicInstanceMethod {
   publicMethod() {
     return 'hello world';
   }
@@ -196,7 +196,7 @@ console.log(instance.publicMethod());
 
 
    Вы можете использовать генераторы, асинхронные функции и асинхронные генераторы.
    
 
-
    class ClassWithFancyMethods {
+
    class ClassWithFancyMethods {
   *generatorMethod() { }
   async asyncMethod() { }
   async *asyncGeneratorMethod() { }
@@ -205,7 +205,7 @@ console.log(instance.publicMethod());
 
    Внутри методов экземпляра, this ссылается на сам экземпляр.
    
  В классах наследниках, super даёт доступ к прототипу базового класса, позволяя вызывать его методы.
    
 
-
    class BaseClass {
+
    class BaseClass {
   msg = 'hello world';
   basePublicMethod() {
     return this.msg;
@@ -225,7 +225,7 @@ console.log(instance.subPublicMethod());
 
 
    Геттеры и сеттеры это специальные методы, которые привязаны к свойствам класса и которые вызываются, когда к свойству обращаются или записывают. Используйте get и set для объявления публичных геттеров и сеттеров экземпляра.
    
 
-
    class ClassWithGetSet {
+
    class ClassWithGetSet {
   #msg = 'hello world';
   get msg() {
     return this.#msg;
diff --git a/files/ru/web/javascript/reference/errors/bad_radix/index.html b/files/ru/web/javascript/reference/errors/bad_radix/index.html
index c4cc82a20b..002078bc54 100644
--- a/files/ru/web/javascript/reference/errors/bad_radix/index.html
+++ b/files/ru/web/javascript/reference/errors/bad_radix/index.html
@@ -21,11 +21,11 @@ RangeError: toString() radix argument must be between 2 and 36 (Chrome)
 
 
    Что пошло не так?
    
 
-
    Метод  {{jsxref("Number.prototype.toString()")}} был вызван с дополнительным параметром radix.  Его значение должно быть целым числом, принадлежащим промежутку от 2 до 36 и указывающим основание системы счисления, которая должна быть использована для представления численных значений.  Например, десятичное (основание 10) число 169 представляется в шестнадцатеричном виде (основание 16) как A9.
    
+
    Метод  {{jsxref("Number.prototype.toString()")}} был вызван с дополнительным параметром radix.  Его значение должно быть целым числом, принадлежащим промежутку от 2 до 36 и указывающим основание системы счисления, которая должна быть использована для представления численных значений.  Например, десятичное (основание 10) число 169 представляется в шестнадцатеричном виде (основание 16) как A9.
    
 
-
    Почему значение этого параметра не может быть больше, чем 36? Для оснований, превышающих 10, в качестве цифр используются алфавитные символы;  следовательно, основание не может быть больше 36, поскольку в латинском алфавите (используемом английским и многими другими языками) только 26 символов.
    
+
    Почему значение этого параметра не может быть больше, чем 36? Для оснований, превышающих 10, в качестве цифр используются алфавитные символы;  следовательно, основание не может быть больше 36, поскольку в латинском алфавите (используемом английским и многими другими языками) только 26 символов.
    
 
-
    Наиболее распространённые основания систем счисления:
    
+
    Наиболее распространённые основания систем счисления:
    
 
 
      
  
    • 2 для двоичных чисел,
      • 
@@ -36,7 +36,7 @@ RangeError: toString() radix argument must be between 2 and 36 (Chrome)
 
 
      Примеры
      
 
-
      Некорректное применение
      
+
      Некорректное применение
      
 
 
      (42).toString(0);
 (42).toString(1);
@@ -54,7 +54,7 @@ RangeError: toString() radix argument must be between 2 and 36 (Chrome)
 (100000).toString(16) // "186a0"  (шестнадцатеричная)
 
      
 
-
      Смотрите также
      
+
      Смотрите также
      
 
 
        
  
      • {{jsxref("Number.prototype.toString()")}}
        • 
diff --git a/files/ru/web/javascript/reference/errors/cant_assign_to_property/index.html b/files/ru/web/javascript/reference/errors/cant_assign_to_property/index.html
index 60d17cbcfb..d1316fe4f9 100644
--- a/files/ru/web/javascript/reference/errors/cant_assign_to_property/index.html
+++ b/files/ru/web/javascript/reference/errors/cant_assign_to_property/index.html
@@ -9,7 +9,7 @@ translation_of: Web/JavaScript/Reference/Errors/Cant_assign_to_property
 
 
        Message
        
 
-
        TypeError: can't assign to property "x" on {y}: not an object (Firefox)
+
        TypeError: can't assign to property "x" on {y}: not an object (Firefox)
 TypeError: Cannot create property 'x' on {y} (Chrome)
 
        
 
@@ -27,7 +27,7 @@ TypeError: Cannot create property 'x' on {y} (Chrome)
 
 
        Invalid cases
        
 
-
        'use strict';
+
        'use strict';
 
 var foo = "my string";
 // The following line does nothing if not in strict mode.
@@ -38,7 +38,7 @@ foo.bar = {}; // primitive from being used in such places, or fix the issue is to create the object equivalent {{jsxref("Object")}}.
        
 
-
        'use strict';
+
        'use strict';
 
 var foo = new String("my string");
 foo.bar = {};
diff --git a/files/ru/web/javascript/reference/errors/cyclic_object_value/index.html b/files/ru/web/javascript/reference/errors/cyclic_object_value/index.html
index 7eecd4634b..246bb98a4c 100644
--- a/files/ru/web/javascript/reference/errors/cyclic_object_value/index.html
+++ b/files/ru/web/javascript/reference/errors/cyclic_object_value/index.html
@@ -10,7 +10,7 @@ translation_of: Web/JavaScript/Reference/Errors/Cyclic_object_value
 
 
        Сообщения
        
 
-
        TypeError: циклическое значение объекта (Firefox)
+
        TypeError: циклическое значение объекта (Firefox)
 TypeError: преобразование круговой структуры в JSON (Chrome и Opera)
 TypeError: циклическая ссылка в аргументе значения не поддерживается (Edge)
 
        
@@ -27,13 +27,13 @@ TypeError: циклическая ссылка в аргументе значе
 
 
        В круговой структуре как эта
        
 
-
        var circularReference = {otherData: 123};
+
        var circularReference = {otherData: 123};
 circularReference.myself = circularReference;
 
        
 
 
        {{jsxref("JSON.stringify()")}} закончится неудачей
        
 
-
        JSON.stringify(circularReference);
+
        JSON.stringify(circularReference);
 // TypeError: циклическое значение объекта
 
        
 
@@ -45,7 +45,7 @@ circularReference.myself = circularReference;
 
 
 
-
        const getCircularReplacer = () => {
+
        const getCircularReplacer = () => {
   const seen = new WeakSet();
   return (key, value) => {
     if (typeof value === "object" && value !== null) {
diff --git a/files/ru/web/javascript/reference/errors/missing_curly_after_property_list/index.html b/files/ru/web/javascript/reference/errors/missing_curly_after_property_list/index.html
index d1a9834174..cd14e4a559 100644
--- a/files/ru/web/javascript/reference/errors/missing_curly_after_property_list/index.html
+++ b/files/ru/web/javascript/reference/errors/missing_curly_after_property_list/index.html
@@ -20,13 +20,13 @@ translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_property_lis
 
 
        Что пошло не так?
        
 
-
        Произошла ошибка в синтаксисе инициализатора объекта. Причиной может быть отсутствующая фигурная скобка или, к примеру, недостающая запятая.  Также проверьте, в правильном ли порядке расположены закрывающие круглые и фигурные скобки. Добавление отступов или форматирование кода в более благоприятный вид также могут помочь разобраться в беспорядке.
        
+
        Произошла ошибка в синтаксисе инициализатора объекта. Причиной может быть отсутствующая фигурная скобка или, к примеру, недостающая запятая.  Также проверьте, в правильном ли порядке расположены закрывающие круглые и фигурные скобки. Добавление отступов или форматирование кода в более благоприятный вид также могут помочь разобраться в беспорядке.
        
 
 
        Примеры
        
 
-
        Забытая запятая
        
+
        Забытая запятая
        
 
-
        Зачастую в коде инициализатора объекта есть недостающая запятая:
        
+
        Зачастую в коде инициализатора объекта есть недостающая запятая:
        
 
 
        var obj = {
   a: 1,
@@ -44,8 +44,8 @@ translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_property_lis
 };
 
        
 
-
        Смотрите также
        
+
        Смотрите также
        
 
 
diff --git a/files/ru/web/javascript/reference/functions/rest_parameters/index.html b/files/ru/web/javascript/reference/functions/rest_parameters/index.html
index 73598d94b7..2ec6bf462a 100644
--- a/files/ru/web/javascript/reference/functions/rest_parameters/index.html
+++ b/files/ru/web/javascript/reference/functions/rest_parameters/index.html
@@ -15,7 +15,7 @@ translation_of: Web/JavaScript/Reference/Functions/rest_parameters
 
 
        Синтаксис
        
 
-
        function(a, b, ...theArgs) {
+
        function(a, b, ...theArgs) {
   // ...
 }
 
        
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Functions/rest_parameters
 
 
        Если последний именованный аргумент функции имеет префикс ..., он автоматически становится массивом с элементами от 0 до theArgs.length-1 в соответствии с актуальным количеством аргументов, переданных в функцию.
        
 
-
        function myFun(a, b, ...manyMoreArgs) {
+
        function myFun(a, b, ...manyMoreArgs) {
   console.log("a", a);
   console.log("b", b);
   console.log("manyMoreArgs", manyMoreArgs);
@@ -52,7 +52,7 @@ myFun("один", "два", "три", "четыре", "пять", "шесть");
 
 
        Остаточные параметры были введены для уменьшения количества шаблонного кода:
        
 
-
        // До появления остаточных параметров "arguments" конвертировали в обычный массив используя:
+
        // До появления остаточных параметров "arguments" конвертировали в обычный массив используя:
 
 function f(a, b) {
 
@@ -78,7 +78,7 @@ function f(...args) {
 
 
        Остаточные параметры могут быть деструктурированы (только массивы). Это означает, что их данные могут быть заданы как отдельные значения. Смотрите Деструктурирующее присваивание.
        
 
-
        function f(...[a, b, c]) {
+
        function f(...[a, b, c]) {
   return a + b + c;
 }
 
@@ -90,7 +90,7 @@ f(1, 2, 3, 4) // 6 (четвёртый параметр не деструкту
 
 
        В этом примере первый аргумент задан как "a", второй как "b", так что эти аргументы используются как обычно. Однако третий аргумент "manyMoreArgs" будет массивом, который содержит 3-й, 4-й, 5-й, 6-й ... n-й аргументы, которые передаст пользователь.
        
 
-
        function myFun(a, b, ...manyMoreArgs) {
+
        function myFun(a, b, ...manyMoreArgs) {
   console.log("a", a);
   console.log("b", b);
   console.log("manyMoreArgs", manyMoreArgs);
@@ -104,7 +104,7 @@ myFun("один", "два", "три", "четыре", "пять", "шесть");
 
 
        Ниже... даже если передано одно значение последним аргументом, оно всё равно помещается в массив.
        
 
-
        // использование той же функции, что и в примере выше
+
        // использование той же функции, что и в примере выше
 
 myFun("один", "два", "три");
 
@@ -114,7 +114,7 @@ myFun("один", "два", "три");
 
 
        Ниже... третий аргумент не был передан, но "manyMoreArgs" всё ещё массив (хотя и пустой).
        
 
-
        // использование той же функции, что и в примере выше
+
        // использование той же функции, что и в примере выше
 
 myFun("один", "два");
 
@@ -124,7 +124,7 @@ myFun("один", "два");
 
 
        Поскольку theArgs является массивом, количество элементов в нём определяется свойством length:
        
 
-
        function fun1(...theArgs) {
+
        function fun1(...theArgs) {
   console.log(theArgs.length);
 }
 
@@ -134,7 +134,7 @@ fun1(5, 6, 7); // 3
        
 
 
        В следующем примере, остаточные параметры используются для сбора всех аргументов после первого в массив. Каждый из них умножается на первый параметр и возвращается массив:
        
 
-
        function multiply(multiplier, ...theArgs) {
+
        function multiply(multiplier, ...theArgs) {
   return theArgs.map(function(element) {
     return multiplier * element;
   });
@@ -145,7 +145,7 @@ console.log(arr); // [2, 4, 6]
        
 
 
        Методы Array могут быть использованы на остаточных параметрах, но не на объекте arguments: 
        
 
-
        function sortRestArgs(...theArgs) {
+
        function sortRestArgs(...theArgs) {
   var sortedArgs = theArgs.sort();
   return sortedArgs;
 }
@@ -162,7 +162,7 @@ console.log(sortArguments(5, 3, 7, 1)); // TypeError (arguments.sort is not a fu
 
 
        Чтобы использовать методы Array на объекте arguments, нужно преобразовать его в настоящий массив.
        
 
-
        function sortArguments() {
+
        function sortArguments() {
   var args = Array.from(arguments);
   var sortedArgs = args.sort();
   return sortedArgs;
diff --git a/files/ru/web/javascript/reference/global_objects/array/flat/index.html b/files/ru/web/javascript/reference/global_objects/array/flat/index.html
index eaa8167868..202898bb9d 100644
--- a/files/ru/web/javascript/reference/global_objects/array/flat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/flat/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat
 
 
        Синтаксис
        
 
-
        var newArray = arr.flat(depth);
        
+
        var newArray = arr.flat(depth);
        
 
 
        Параметры
        
 
@@ -37,7 +37,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat
 
 
        Упрощение вложенных массивов
        
 
-
        var arr1 = [1, 2, [3, 4]];
+
        var arr1 = [1, 2, [3, 4]];
 arr1.flat();
 // [1, 2, 3, 4]
 
@@ -57,7 +57,7 @@ arr4.flat(Infinity);
 
 
        Метод flat удаляет пустые слоты из массива:
        
 
-
        var arr4 = [1, 2, , 4, 5];
+
        var arr4 = [1, 2, , 4, 5];
 arr4.flat();
 // [1, 2, 4, 5]
 
        
@@ -66,7 +66,7 @@ arr4.flat();
 
 
        reduce и concat
        
 
-
        var arr1 = [1, 2, [3, 4]];
+
        var arr1 = [1, 2, [3, 4]];
 arr1.flat();
 
 // В одномерный массив
@@ -76,7 +76,7 @@ arr1.reduce((acc, val) => acc.concat(val), []);// [1, 2, 3, 4]
 const flatSingle = arr => [].concat(...arr);
 
        
 
-
        // Для развёртывания многомерных массивов используем рекурсию, reduce и concat
+
        // Для развёртывания многомерных массивов используем рекурсию, reduce и concat
 const arr = [1, 2, [3, 4, [5, 6]]];
 
 function flatDeep(arr, d = 1) {
@@ -87,7 +87,7 @@ function flatDeep(arr, d = 1) {
 flatDeep(arr, Infinity);
 // [1, 2, 3, 4, 5, 6]
        
 
-
        //не рекурсивное упрощение с использованием стэка
+
        //не рекурсивное упрощение с использованием стэка
 var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];
 function flatten(input) {
   const stack = [...input];
@@ -108,7 +108,7 @@ function flatten(input) {
 flatten(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
 
        
 
-
        //рекурсивно упрощаем массив
+
        //рекурсивно упрощаем массив
 function flatten(array) {
   var flattend = [];
   (function flat(array) {
diff --git a/files/ru/web/javascript/reference/global_objects/array/map/index.html b/files/ru/web/javascript/reference/global_objects/array/map/index.html
index a5ac485843..226fe12470 100644
--- a/files/ru/web/javascript/reference/global_objects/array/map/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/map/index.html
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
 
 
        Синтаксис
        
 
-
        let new_array = arr.map(function callback( currentValue[, index[, array]]) {
+
        let new_array = arr.map(function callback( currentValue[, index[, array]]) {
     // Возвращает элемент для new_array
 }[, thisArg])
        
 
@@ -69,7 +69,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
 
 
        Следующий код берёт массив чисел и создаёт новый массив, содержащий квадратные корни чисел из первого массива.
        
 
-
        var numbers = [1, 4, 9];
+
        var numbers = [1, 4, 9];
 var roots = numbers.map(Math.sqrt);
 // теперь roots равен [1, 2, 3], а numbers всё ещё равен [1, 4, 9]
 
        
@@ -78,7 +78,7 @@ var roots = numbers.map(Math.sqrt);
 
 
        Следующий код показывает, как работает отображение, когда функция требует один аргумент. Аргумент будет автоматически присваиваться каждому элементу массива, когда map проходит по оригинальному массиву.
        
 
-
        var numbers = [1, 4, 9];
+
        var numbers = [1, 4, 9];
 var doubles = numbers.map(function(num) {
   return num * 2;
 });
@@ -89,7 +89,7 @@ var doubles = numbers.map(function(num) {
 
 
        Этот пример показывает, как использовать map на объекте строки {{jsxref("Global_Objects/String", "String")}} для получения массива байт в кодировке ASCII, представляющего значения символов:
        
 
-
        var map = Array.prototype.map;
+
        var map = Array.prototype.map;
 var a = map.call('Hello World', function(x) { return x.charCodeAt(0); });
 // теперь a равен [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
 
        
@@ -98,7 +98,7 @@ var a = map.call('Hello World', function(x) { return x.charCodeAt(0); });
 
 
        Этот пример показывает, как пройтись по коллекции объектов, собранных с помощью querySelectorAll. В данном случае мы получаем все выбранные опции на экране и печатаем их в консоль:
        
 
-
        var elems = document.querySelectorAll('select option:checked');
+
        var elems = document.querySelectorAll('select option:checked');
 var values = [].map.call(elems, function(obj) {
   return obj.value;
 });
@@ -108,7 +108,7 @@ var values = [].map.call(elems, function(obj) {
 
 
        Пример: использование map для переворачивания строки
        
 
-
        var str = '12345';
+
        var str = '12345';
 [].map.call(str, function(x) {
   return x;
 }).reverse().join('');
@@ -125,7 +125,7 @@ var values = [].map.call(elems, function(obj) {
 
 
        Распространённой практикой является использование колбэк-функции с одним аргументом (элемент, над которым производится операция). Некоторые функции также широко используется с одним аргументом, хотя они принимают дополнительные необязательные аргументы. Эти привычки могут привести к неожиданному поведению программы.
        
 
-
        // Рассмотрим пример:
+
        // Рассмотрим пример:
 ['1', '2', '3'].map(parseInt);
 // Хотя ожидаемый результат вызова равен [1, 2, 3],
 // в действительности получаем [1, NaN, NaN]
@@ -152,7 +152,7 @@ function returnInt(element) {
 
 
        Метод map был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать map в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}} и {{jsxref("Global_Objects/Array", "Array")}} имеют свои первоначальные значения и что callback.call вычисляется в оригинальное значение {{jsxref("Function.prototype.call")}}.
        
 
-
        // Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.19
+
        // Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.19
 // Ссылка (en): http://es5.github.com/#x15.4.4.19
 // Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.19
 if (!Array.prototype.map) {
diff --git a/files/ru/web/javascript/reference/global_objects/array/slice/index.html b/files/ru/web/javascript/reference/global_objects/array/slice/index.html
index d5c9f8b897..86299563c0 100644
--- a/files/ru/web/javascript/reference/global_objects/array/slice/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/slice/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
 
 
        Синтаксис
        
 
-
        arr.slice([begin[, end]])
        
+
        arr.slice([begin[, end]])
        
 
 
        Параметры
        
 
@@ -56,7 +56,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
 
 
        Пример: возврат части существующего массива
        
 
-
        // Пример: наши хорошие друзья цитрусовые среди фруктов
+
        // Пример: наши хорошие друзья цитрусовые среди фруктов
 var fruits = ['Банан', 'Апельсин', 'Лимон', 'Яблоко', 'Манго'];
 var citrus = fruits.slice(1, 3);
 
@@ -67,7 +67,7 @@ var citrus = fruits.slice(1, 3);
 
 
        В следующем примере метод slice() создаёт новый массив, newCar, из массива myCar. Оба содержат ссылку на объект myHonda. Когда цвет в объекте myHonda изменяется на багровый, оба массива замечают это изменение.
        
 
-
        // Используя slice, создаём newCar из myCar.
+
        // Используя slice, создаём newCar из myCar.
 var myHonda = { color: 'красный', wheels: 4, engine: { cylinders: 4, size: 2.2 } };
 var myCar = [myHonda, 2, 'в хорошем состоянии', 'приобретена в 1997'];
 var newCar = myCar.slice(0, 2);
@@ -90,7 +90,7 @@ console.log('newCar[0].color = ' + newCar[0].color);
 
 
        Этот скрипт выведет:
        
 
-
        myCar = [{color:'красный', wheels:4, engine:{cylinders:4, size:2.2}}, 2,
+
        myCar = [{color:'красный', wheels:4, engine:{cylinders:4, size:2.2}}, 2,
          'в хорошем состоянии', 'приобретена в 1997']
 newCar = [{color:'красный', wheels:4, engine:{cylinders:4, size:2.2}}, 2]
 myCar[0].color = красный
@@ -104,7 +104,7 @@ newCar[0].color = багровый
 
 
        Метод slice() также может использоваться для преобразования массивоподобных объектов / коллекций в новый массив Array. Вам просто нужно привязать метод к объекту. Псевдомассив {{jsxref("Functions_and_function_scope/arguments", "arguments")}} внутри функции как раз является примером «массивоподобного объекта».
        
 
-
        function list() {
+
        function list() {
   return Array.prototype.slice.call(arguments, 0);
 }
 
@@ -113,7 +113,7 @@ var list1 = list(1, 2, 3); // [1, 2, 3]
 
 
        Привязка может быть осуществлена посредством функции .call() из прототипа функции {{jsxref("Function.prototype")}}, также запись может быть сокращена до [].slice.call(arguments) вместо использования Array.prototype.slice.call(). В любом случае, она может быть упрощена посредством использования функции {{jsxref("Function.prototype.bind()", "bind()")}}.
        
 
-
        var unboundSlice = Array.prototype.slice;
+
        var unboundSlice = Array.prototype.slice;
 var slice = Function.prototype.call.bind(unboundSlice);
 
 function list() {
@@ -127,7 +127,7 @@ var list1 = list(1, 2, 3); // [1, 2, 3]
 
 
        Хотя спецификация не требует от хост-объектов (например, объектов DOM) следовать поведению Mozilla при преобразовании с помощью Array.prototype.slice() и IE < 9 так не делает, версии IE, начиная с 9-й это умеют. «Прокладывание» позволяет добиться надёжного кросс-браузерного поведения. Пока другие современные браузеры будут поддерживать эту способность, что и делают в настоящее время IE, Mozilla, Chrome, Safari и Opera, разработчики, читая (поддерживающий DOM) код функции slice(), опирающийся на эту прокладку, не будут вводиться в заблуждение его семантикой; они могут смело полагаться на текущую семантику, являющуюся, видимо, де-факто стандартным поведением. (Прокладка также исправляет поведение IE, позволяя работать со вторым аргументом slice(), явно определённым как {{jsxref("Global_Objects/null", "null")}}/{{jsxref("Global_Objects/undefined", "undefined")}}, поскольку более ранние версии IE такое не позволяют, но все современные браузеры, в том числе IE >= 9, поддерживают данное поведение.)
        
 
-
        /**
+
        /**
  * Прокладка для "исправления" отсутствия поддержки в IE < 9 применения slice
  * к хост-объектам вроде NamedNodeMap, NodeList и HTMLCollection
  * (технически, поскольку хост-объекты зависят от реализации,
diff --git a/files/ru/web/javascript/reference/global_objects/array/sort/index.html b/files/ru/web/javascript/reference/global_objects/array/sort/index.html
index 6408c3d51f..a1ddae9c5c 100644
--- a/files/ru/web/javascript/reference/global_objects/array/sort/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/sort/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort
 
 
        Синтаксис
        
 
-
        arr.sort([compareFunction])
        
+
        arr.sort([compareFunction])
        
 
 
        Параметры
        
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort
 
 
        Если функция сравнения compareFunction не предоставляется, элементы сортируются путём преобразования их в строки и сравнения строк в порядке следования кодовых точек Unicode. Например, слово "Вишня" идёт перед словом "бананы". При числовой сортировке, 9 идёт перед 80, но поскольку числа преобразуются в строки, то "80" идёт перед "9" в соответствии с порядком в Unicode.
        
 
-
        var fruit = ['арбузы', 'бананы', 'Вишня'];
+
        var fruit = ['арбузы', 'бананы', 'Вишня'];
 fruit.sort(); // ['Вишня', 'арбузы', 'бананы']
 
 var scores = [1, 2, 10, 21];
@@ -56,7 +56,7 @@ things.sort(); // ['1 Слово', '2 Слова', 'Слово', 'слово']
 
 
        Итак, функция сравнения имеет следующую форму:
        
 
-
        function compare(a, b) {
+
        function compare(a, b) {
   if (a меньше b по некоторому критерию сортировки) {
     return -1;
   }
@@ -70,14 +70,14 @@ things.sort(); // ['1 Слово', '2 Слова', 'Слово', 'слово']
 
 
        Для числового сравнения, вместо строкового, функция сравнения может просто вычитать b из a. Следующая функция будет сортировать массив по возрастанию:
        
 
-
        function compareNumbers(a, b) {
+
        function compareNumbers(a, b) {
   return a - b;
 }
 
        
 
 
        Метод sort можно удобно использовать с {{jsxref("Operators/function", "функциональными выражениями", "", 1)}} (и замыканиями):
        
 
-
        var numbers = [4, 2, 5, 1, 3];
+
        var numbers = [4, 2, 5, 1, 3];
 numbers.sort(function(a, b) {
   return a - b;
 });
@@ -86,7 +86,7 @@ console.log(numbers); // [1, 2, 3, 4, 5]
 
 
        Объекты могут быть отсортированы по значению одного из своих свойств.
        
 
-
        var items = [
+
        var items = [
   { name: 'Edward', value: 21 },
   { name: 'Sharpe', value: 37 },
   { name: 'And', value: 45 },
@@ -112,7 +112,7 @@ items.sort(function (a, b) {
 
 
        В следующем примере создаётся четыре массива, сначала отображается первоначальный массив, а затем они сортируются. Числовые массивы сортируются сначала без, а потом с функцией сравнения.
        
 
-
        var stringArray = ['Голубая', 'Горбатая', 'Белуга'];
+
        var stringArray = ['Голубая', 'Горбатая', 'Белуга'];
 var numericStringArray = ['80', '9', '700'];
 var numberArray = [40, 1, 5, 200];
 var mixedNumericArray = ['80', '9', '700', 40, 1, 5, 200];
@@ -140,7 +140,7 @@ console.log('Сортировка с функцией compareNumbers:', mixedNum
 
 
        Этот пример произведёт следующий вывод. Как показывает вывод, когда используется функция сравнения, числа сортируются корректно вне зависимости от того, являются ли они собственно числами или строками с числами.
        
 
-
        stringArray: Голубая,Горбатая,Белуга
+
        stringArray: Голубая,Горбатая,Белуга
 Сортировка: Белуга,Голубая,Горбатая
 
 numberArray: 40,1,5,200
@@ -160,7 +160,7 @@ mixedNumericArray: 80,9,700,40,1,5,200
 
 
        Для сортировки строк с не-ASCII символами, то есть строк с символами акцента (e, é, è, a, ä и т.д.), строк, с языками, отличными от английского: используйте {{jsxref("String.localeCompare")}}. Эта функция может сравнивать эти символы, чтобы они становились в правильном порядке.
        
 
-
        var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
+
        var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
 items.sort(function (a, b) {
   return a.localeCompare(b);
 });
@@ -172,7 +172,7 @@ items.sort(function (a, b) {
 
 
        Функция сравнения (compareFunction) может вызываться несколько раз для каждого элемента в массиве. В зависимости от природы функции сравнения, это может привести к высоким расходам ресурсов. Чем более сложна функция сравнения и чем больше элементов требуется отсортировать, тем разумнее использовать map для сортировки. Идея состоит в том, чтобы обойти массив один раз, чтобы извлечь фактические значения, используемые для сортировки, во временный массив, отсортировать временный массив, а затем обойти временный массив для получения правильного порядка.
        
 
-
        // массив для сортировки
+
        // массив для сортировки
 var list = ['Дельта', 'альфа', 'ЧАРЛИ', 'браво'];
 
 // временный массив содержит объекты с позицией и значением сортировки
diff --git a/files/ru/web/javascript/reference/global_objects/array/splice/index.html b/files/ru/web/javascript/reference/global_objects/array/splice/index.html
index e92751abf6..e562c12bcc 100644
--- a/files/ru/web/javascript/reference/global_objects/array/splice/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/splice/index.html
@@ -18,7 +18,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice
 
 
        Синтаксис
        
 
-
        array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
+
        array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
 
        
 
 
        Параметры
        
@@ -44,7 +44,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice
 
 
        Удаляет 0 элементов по индексу 2 и вставляет "drum"
        
 
-
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
 var removed = myFish.splice(2, 0, 'drum');
 
 // myFish равен ["angel", "clown", "drum", "mandarin", "sturgeon"]
@@ -52,7 +52,7 @@ var removed = myFish.splice(2, 0, 'drum');
 
 
        Удаляет 1 элемент по индексу 3
        
 
-
        var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
+
        var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
 var removed = myFish.splice(3, 1);
 
 // removed равен ["mandarin"]
@@ -60,7 +60,7 @@ var removed = myFish.splice(3, 1);
 
 
        Удаляет 1 элемент по индексу 2 и вставляет "trumpet"
        
 
-
        var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
+
        var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
 var removed = myFish.splice(2, 1, 'trumpet');
 
 // myFish равен ["angel", "clown", "trumpet", "sturgeon"]
@@ -68,7 +68,7 @@ var removed = myFish.splice(2, 1, 'trumpet');
 
 
        Удаляет 2 элемента начиная с индекса 0 и вставляет "parrot", "anemone" и "blue"
        
 
-
        var myFish = ['angel', 'clown', 'trumpet', 'sturgeon'];
+
        var myFish = ['angel', 'clown', 'trumpet', 'sturgeon'];
 var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');
 
 // myFish равен ["parrot", "anemone", "blue", "trumpet", "sturgeon"]
@@ -76,7 +76,7 @@ var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');
 
 
        Удаляет 2 элемента начиная с индекса 2
        
 
-
        var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon'];
+
        var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon'];
 var removed = myFish.splice(myFish.length - 3, 2);
 
 // myFish равен ["parrot", "anemone", "sturgeon"]
@@ -84,7 +84,7 @@ var removed = myFish.splice(myFish.length - 3, 2);
 
 
        Удаляет 1 элемент по индексу -2
        
 
-
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
 var removed = myFish.splice(-2, 1);
 
 // myFish равен ["angel", "clown", "sturgeon"]
@@ -92,7 +92,7 @@ var removed = myFish.splice(-2, 1);
 
 
        Удаляет все элементы после индекса 2 (включительно)
        
 
-
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
 var removed = myFish.splice(2);
 
 // myFish равен ["angel", "clown"]
diff --git a/files/ru/web/javascript/reference/global_objects/bigint/asuintn/index.html b/files/ru/web/javascript/reference/global_objects/bigint/asuintn/index.html
index 6f3c09ba56..98395a3c5c 100644
--- a/files/ru/web/javascript/reference/global_objects/bigint/asuintn/index.html
+++ b/files/ru/web/javascript/reference/global_objects/bigint/asuintn/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN
 
 
        Syntax
        
 
-
        BigInt.asUintN(width, bigint);
        
+
        BigInt.asUintN(width, bigint);
        
 
 
        Parameters
        
 
@@ -34,7 +34,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN
 
 
        The BigInt.asUintN() method can be useful to stay in the range of 64-bit arithmetic.
        
 
-
        const max = 2n ** 64n - 1n;
+
        const max = 2n ** 64n - 1n;
 
 BigInt.asUintN(64, max);
 // ↪ 18446744073709551615n
diff --git a/files/ru/web/javascript/reference/global_objects/date/getdate/index.html b/files/ru/web/javascript/reference/global_objects/date/getdate/index.html
index 52e0d9eefa..9c6667995c 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getdate/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getdate/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate
 
 
        Синтаксис
        
 
-
        dateObj.getDate()
        
+
        dateObj.getDate()
        
 
 
        Параметры
        
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate
 
 
        Вторая инструкция в примере ниже присваивает значение 25 переменной day из значения объекта {{jsxref("Global_Objects/Date", "Date")}} date.
        
 
-
        let date = new Date('December 25, 1995 23:15:30');
+
        let date = new Date('December 25, 1995 23:15:30');
 let day = date.getDate();
 
 console.log(day); // 25
diff --git a/files/ru/web/javascript/reference/global_objects/date/getday/index.html b/files/ru/web/javascript/reference/global_objects/date/getday/index.html
index 654e43455f..c2c2bd4e8a 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getday/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getday/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay
 
 
        Синтаксис
        
 
-
        dateObj.getDay()
        
+
        dateObj.getDay()
        
 
 
        Параметры
        
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay
 
 
        Вторая инструкция в примере ниже присваивает значение 1 переменной weekday из значения объекта {{jsxref("Global_Objects/Date", "Date")}} date. 25 декабря 1995 года было понедельником.
        
 
-
        let date = new Date('December 25, 1995 23:15:30');
+
        let date = new Date('December 25, 1995 23:15:30');
 let weekday = date.getDay();
 
 console.log(weekday); // 1
@@ -42,7 +42,7 @@ console.log(weekday); // 1
 
        
 
        Примечание: При необходимости полное название дня (например, "Понедельник") можно получить, используя {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} с параметром options parameter. С помощью этого метода упрощается интернационализация:
        
 
-
        let options = { weekday: 'long'};
+
        let options = { weekday: 'long'};
 
 console.log(new Intl.DateTimeFormat('en-US', options).format(date));
 // Monday
diff --git a/files/ru/web/javascript/reference/global_objects/date/getfullyear/index.html b/files/ru/web/javascript/reference/global_objects/date/getfullyear/index.html
index 5a7d09c7bf..60aeb1a1ac 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getfullyear/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getfullyear/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear
 
 
        Синтаксис
        
 
-
        dateObj.getFullYear()
        
+
        dateObj.getFullYear()
        
 
 
        Параметры
        
 
@@ -35,7 +35,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear
 
 
        В следующем примере переменной year присваивается четырёхзначное значение текущего года.
        
 
-
        let today = new Date(); // Mon Nov 23 2020 15:23:46 GMT+0300 (Москва, стандартное время)
+
        let today = new Date(); // Mon Nov 23 2020 15:23:46 GMT+0300 (Москва, стандартное время)
 let year = today.getFullYear(); // 2020
 
        
 
diff --git a/files/ru/web/javascript/reference/global_objects/date/gethours/index.html b/files/ru/web/javascript/reference/global_objects/date/gethours/index.html
index 4e927a3454..2f0c788d1a 100644
--- a/files/ru/web/javascript/reference/global_objects/date/gethours/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/gethours/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours
 
 
        Синтаксис
        
 
-
        dateObj.getHours()
        
+
        dateObj.getHours()
        
 
 
        Параметры
        
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours
 
 
        Вторая инструкция в примере ниже присваивает значение 23 переменной hours из значения объекта {{jsxref("Global_Objects/Date", "Date")}} date.
        
 
-
        let date = new Date('December 25, 1995 23:15:30');
+
        let date = new Date('December 25, 1995 23:15:30');
 let hours = date.getHours();
 
 console.log(hours); // 23
diff --git a/files/ru/web/javascript/reference/global_objects/date/getmilliseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/getmilliseconds/index.html
index 4d848fc5e8..3d9d51b204 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getmilliseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getmilliseconds/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds
 
 
        Синтаксис
        
 
-
        dateObj.getMilliseconds()
        
+
        dateObj.getMilliseconds()
        
 
 
        Параметры
        
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds
 
 
        В следующем примере переменной milliseconds присваиваются миллисекунды текущего времени:
        
 
-
        let today = new Date();
+
        let today = new Date();
 let milliseconds = today.getMilliseconds();
 
 console.log(milliseconds); // 709
diff --git a/files/ru/web/javascript/reference/global_objects/date/getminutes/index.html b/files/ru/web/javascript/reference/global_objects/date/getminutes/index.html
index 533cba2dc5..0b97f5e1f7 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getminutes/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getminutes/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes
 
 
        Синтаксис
        
 
-
        dateObj.getMinutes()
        
+
        dateObj.getMinutes()
        
 
 
        Параметры
        
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes
 
 
        Вторая инструкция в примере ниже присваивает значение 15 переменной minutes из значения объекта {{jsxref("Global_Objects/Date", "Date")}} date.
        
 
-
        let date = new Date('December 25, 1995 23:15:30');
+
        let date = new Date('December 25, 1995 23:15:30');
 let minutes = date.getMinutes();
 
 console.log(minutes); // 15
diff --git a/files/ru/web/javascript/reference/global_objects/date/getmonth/index.html b/files/ru/web/javascript/reference/global_objects/date/getmonth/index.html
index 5b42ea933a..001f258a2c 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getmonth/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getmonth/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth
 
 
        Синтаксис
        
 
-
        dateObj.getMonth()
        
+
        dateObj.getMonth()
        
 
 
        Параметры
        
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth
 
 
        Вторая инструкция в примере ниже присваивает значение 11 переменной month из значения переменной date объекта {{jsxref("Global_Objects/Date", "Date")}}.
        
 
-
        let date = new Date('December 25, 1995 23:15:30');
+
        let date = new Date('December 25, 1995 23:15:30');
 let month = date.getMonth();
 
 console.log(month); // 11
diff --git a/files/ru/web/javascript/reference/global_objects/date/getseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/getseconds/index.html
index 6027da393b..e2e5fecaac 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getseconds/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds
 
 
        Синтаксис
        
 
-
        dateObj.getSeconds()
        
+
        dateObj.getSeconds()
        
 
 
        Параметры
        
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds
 
 
        Вторая инструкция в примере ниже присваивает значение 30 переменной seconds из значения переменной date объекта {{jsxref("Global_Objects/Date", "Date")}}.
        
 
-
        let date = new Date('December 25, 1995 23:15:30');
+
        let date = new Date('December 25, 1995 23:15:30');
 let seconds = date.getSeconds();
 
 console.log(seconds); // 30
diff --git a/files/ru/web/javascript/reference/global_objects/date/gettime/index.html b/files/ru/web/javascript/reference/global_objects/date/gettime/index.html
index 8f380c6208..f4b2c740b6 100644
--- a/files/ru/web/javascript/reference/global_objects/date/gettime/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/gettime/index.html
@@ -23,7 +23,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime
 
 
        Синтаксис
        
 
-
        dateObj.getTime()
        
+
        dateObj.getTime()
        
 
 
        Параметры
        
 
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime
 
 
        Конструирует новый объект даты с идентичным значением времени.
        
 
-
        let birthday = new Date(2020, 12, 20);
+
        let birthday = new Date(2020, 12, 20);
 let copy = new Date();
 copy.setTime(birthday.getTime());
 
@@ -50,7 +50,7 @@ console.log(copy.setTime(birthday.getTime())); // 1611090000000
 
 
        Вычитанием двух последовательных вызовов метода getTime() на заново сконструированных объектах {{jsxref("Global_Objects/Date", "Date")}} можно замерить промежуток времени, произошедший между двумя этими вызовами. Это можно использовать для вычисления времени выполнения неких операций.
        
 
-
        let end, start;
+
        let end, start;
 
 start = new Date();
 for (let i = 0; i < 1000; i++) {
diff --git a/files/ru/web/javascript/reference/global_objects/date/index.html b/files/ru/web/javascript/reference/global_objects/date/index.html
index bf3ce884dd..0f8ddf6b79 100644
--- a/files/ru/web/javascript/reference/global_objects/date/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/index.html
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date
 
 
        Синтаксис
        
 
-
        new Date();
+
        new Date();
 new Date(value);
 new Date(dateString);
 new Date(year, month[, day[, hour[, minute[, second[, millisecond]]]]]);
@@ -118,7 +118,7 @@ new Date(year, month[, day[, hour[,
 
        Обратите внимание: разбор строкового представления дат с помощью конструктора Date (так же как эквивалентный ему метод Date.parse) может иметь различия и несоответствия в браузерах.
        
 
        
 
-
        var today = new Date();
+
        var today = new Date();
 var birthday = new Date('December 17, 1995 03:24:00');
 var birthday = new Date('1995-12-17T03:24:00');
 var birthday = new Date(1995, 11, 17);
@@ -129,7 +129,7 @@ var birthday = new Date(1995, 11, 17, 3, 24, 0);
 
 
        Для того, чтобы создать и получить даты между 0 и 99 годом, нужно использовать методы {{jsxref("Date.prototype.setFullYear()")}} и {{jsxref("Date.prototype.getFullYear()")}}.
        
 
-
        var date = new Date(98, 1); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
+
        var date = new Date(98, 1); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
 
 // Устаревший метод, 98 отображается на 1998 год
 date.setYear(98);           // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
@@ -141,7 +141,7 @@ date.setFullYear(98);       // Sat Feb 01 0098 00:00:00 GMT+0000 (BST)
 
 
        Следующие примеры показывают, как определить разницу во времени между двумя датами в JavaScript:
        
 
-
        // Используя объекты Date
+
        // Используя объекты Date
 var start = Date.now();
 
 // Событие, для которого замеряется время, происходит тут:
@@ -150,7 +150,7 @@ var end = Date.now();
 var elapsed = end - start; // затраченное время в миллисекундах
 
        
 
-
        // Используя встроенные методы
+
        // Используя встроенные методы
 var start = new Date();
 
 // Событие, для которого замеряется время, происходит тут:
@@ -159,7 +159,7 @@ var end = new Date();
 var elapsed = end.getTime() - start.getTime(); // затраченное время в миллисекундах
 
        
 
-
        // Проверяет функцию и возвращает её возвращаемое значение
+
        // Проверяет функцию и возвращает её возвращаемое значение
 function printElapsedTime(fTest) {
   var nStartTime = Date.now(),
       vReturn = fTest(),
@@ -179,7 +179,7 @@ yourFunctionReturn = printElapsedTime(yourFunction);
 
 
        Получить количество секунд с начала эпохи Unix
        
 
-
        var seconds = Math.floor(Date.now() / 1000);
        
+
        var seconds = Math.floor(Date.now() / 1000);
        
 
 
        В этом случае важно возвращать только целое число (так что простое деление не подойдёт), а также возвращать только фактически прошедшие секунды (поэтому этот код использует {{jsxref ("Math.floor ()")}} а не {{jsxref ("Math.round ()")}}).
        
 
diff --git a/files/ru/web/javascript/reference/global_objects/eval/index.html b/files/ru/web/javascript/reference/global_objects/eval/index.html
index f3bad3a0e3..b5cfcb75ca 100644
--- a/files/ru/web/javascript/reference/global_objects/eval/index.html
+++ b/files/ru/web/javascript/reference/global_objects/eval/index.html
@@ -23,7 +23,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/eval
 
 
        Синтаксис
        
 
-
        eval(string)
        
+
        eval(string)
        
 
 
        Параметры
        
 
@@ -46,19 +46,19 @@ translation_of: Web/JavaScript/Reference/Global_Objects/eval
 
 
        Если аргумент, переданный eval(), не является строкой, eval() возвращает его неизменным. В следующем примере определён конструктор String, и eval() не вычисляет значение выражения, записанного в строковом виде, а возвращает объект типа String.
        
 
-
        eval(new String("2 + 2")); // возвращает объект типа String, содержащий "2 + 2"
+
        eval(new String("2 + 2")); // возвращает объект типа String, содержащий "2 + 2"
 eval("2 + 2");             // возвращает 4
 
        
 
 
        Это ограничение легко обойти при помощи toString().
        
 
-
        var expression = new String("2 + 2");
+
        var expression = new String("2 + 2");
 eval(expression.toString());
 
        
 
 
        Если вы используете eval косвенно, вызовом его через ссылку, а не просто eval, в ECMAScript 5 это работает в глобальной области видимости, а не в локальной; это значит, что eval будет вызван в глобальной области видимости, а код будет выполнен с отсутствием доступа к локальным переменным в пределах области видимости, где он был вызван.
        
 
-
        function test() {
+
        function test() {
   var x = 2, y = 4;
   console.log(eval("x + y"));  // Прямой вызов, использует локальную области видимости, результат - 6
   var geval = eval;
@@ -78,7 +78,7 @@ eval(expression.toString());
 
 
        Вам не следует использовать eval(), чтобы конвертировать имена свойств в свойства. Рассматривая следующий пример, где свойство объекта используемое для доступа неизвестно до выполнения кода. Это можно сделать с  eval:
        
 
-
        var obj = { a: 20, b: 30 };
+
        var obj = { a: 20, b: 30 };
 var propname = getPropName();  // возвращает "a" или "b"
 
 eval( "var result = obj." + propname );
@@ -86,7 +86,7 @@ eval( "var result = obj." + propname );
 
 
        Однако, eval() здесь не нужен. По факту, использование здесь его удивляет. Вместо него используйте доступ к свойствам, который быстрее и безопаснее:
        
 
-
        var obj = { a: 20, b: 30 };
+
        var obj = { a: 20, b: 30 };
 var propname = getPropName();  // возвращает "a" или "b"
 var result = obj[ propname ];  //  obj[ "a" ] то же, что и obj.a
 
        
@@ -95,7 +95,7 @@ var result = obj[ propname ];  //  obj[ "a" ] то же, что и obj.a
 
 
        У JavaScript функции первого класса, что значит, что вы можете передавать функции как аргументы, хранить их в переменных или свойствах объектов и так далее. Многие DOM API созданы с учётом этого, так что вы можете (и вам следует) писать:
        
 
-
        // вместо setTimeout(" ... ", 1000) :
+
        // вместо setTimeout(" ... ", 1000) :
 setTimeout(function() { ... }, 1000);
 
 // вместо elt.setAttribute("onclick", "...") использовать:
@@ -123,7 +123,7 @@ elt.addEventListener("click", function() { ... } , false); 
        
 
 
        В следующем коде оба выражения содержат eval(), возвращающий 42. Первое определяется строкой "x + y + 1"; второе - строкой "42".
        
 
-
        var x = 2;
+
        var x = 2;
 var y = 39;
 var z = "42";
 eval("x + y + 1"); // возвращает 42
@@ -134,7 +134,7 @@ eval(z);           // вернёт 42
 
 
        Следующий пример использует eval() для получения значения выражения str. Эта строка состоит из JavaScript выражений, печатающих в консоль, и, если x равен пяти, призывающих z значение 42, или 0 в противном случае. Когда второе выражение будет исполнено, eval() будет считать выражения выполненными, а также это установит значение выражению переменной z и вернёт его.
        
 
-
        var x = 5;
+
        var x = 5;
 var str = "if (x == 5) {console.log('z is 42'); z = 42;} else z = 0; ";
 
 console.log("z is ", eval(str));
        
@@ -143,7 +143,7 @@ console.log("z is ", eval(str));
        
 
 
        eval() вернёт значение последнего выполняемого выражения
        
 
-
        var str = "if ( a ) { 1+1; } else { 1+2; }";
+
        var str = "if ( a ) { 1+1; } else { 1+2; }";
 var a = true;
 var b = eval(str);  // вернёт 2
 
@@ -156,7 +156,7 @@ console.log("b is : " + b);
        
 
 
        eval как строковое определение функции, включающее "(" и ")" как префикс и суффикс
        
 
-
        var fctStr1 = "function a() {}"
+
        var fctStr1 = "function a() {}"
 var fctStr2 = "(function a() {})"
 var fct1 = eval(fctStr1)  // вернёт undefined
 var fct2 = eval(fctStr2)  // вернёт функцию
diff --git a/files/ru/web/javascript/reference/global_objects/generator/index.html b/files/ru/web/javascript/reference/global_objects/generator/index.html
index 2eec389c7e..8d5768c60c 100644
--- a/files/ru/web/javascript/reference/global_objects/generator/index.html
+++ b/files/ru/web/javascript/reference/global_objects/generator/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Generator
 
 
        Этот объект не может быть инстанциирован напрямую. Вместо этого, экземпляр Generator может быть возвращён из функции-генератора:
        
 
-
        function* generator() {
+
        function* generator() {
   yield 1;
   yield 2;
   yield 3;
@@ -47,7 +47,7 @@ console.log(generator().next().value); // 1
        
 
 
        Бесконечный Итератор
        
 
-
        function* idMaker() {
+
        function* idMaker() {
     var index = 0;
     while(true)
         yield index++;
diff --git a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/index.html b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/index.html
index f7836af5e0..c210237b7a 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/index.html
@@ -15,7 +15,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat
 
 
        Синтаксис
        
 
-
        new Intl.DateTimeFormat([locales[, options]])
+
        new Intl.DateTimeFormat([locales[, options]])
 Intl.DateTimeFormat.call(this[, locales[, options]])
        
 
 
        Параметры
        
@@ -122,7 +122,7 @@ Intl.DateTimeFormat.call(this[, locales[, optionsПри базовом использовании без определения локали DateTimeFormat использует локаль и опции по умолчанию.
        
 
-
        var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
        var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // Вывод format без аргументов зависит от реализации,
 // локали по умолчанию и часового пояса по умолчанию
@@ -134,7 +134,7 @@ console.log(new Intl.DateTimeFormat().format(date));
 
 
        Этот пример показывает некоторые локализованные форматы даты и времени. Для получения формата языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент locales:
        
 
-
        var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
        var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // Форматирование ниже предполагает, что местный часовой пояс равен
 // America/Los_Angeles для локали США
@@ -170,7 +170,7 @@ console.log(new Intl.DateTimeFormat(['ban', 'id']).format(date));
 
 
        Формат даты и времени может быть настроен с помощью аргумента options:
        
 
-
        var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
        var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // Запрашиваем день недели вместе с длинным форматом даты
 var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
diff --git a/files/ru/web/javascript/reference/global_objects/number/issafeinteger/index.html b/files/ru/web/javascript/reference/global_objects/number/issafeinteger/index.html
index b9be2bbc60..a6c3eaff7a 100644
--- a/files/ru/web/javascript/reference/global_objects/number/issafeinteger/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/issafeinteger/index.html
@@ -31,7 +31,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
 
 
        Синтаксис
        
 
-
        Number.isSafeInteger(testValue)
        
+
        Number.isSafeInteger(testValue)
        
 
 
        Параметры
        
 
@@ -46,7 +46,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
 
 
        Примеры
        
 
-
        Number.isSafeInteger(3);                    // true
+
        Number.isSafeInteger(3);                    // true
 Number.isSafeInteger(Math.pow(2, 53));      // false
 Number.isSafeInteger(Math.pow(2, 53) - 1);  // true
 Number.isSafeInteger(NaN);                  // false
@@ -58,7 +58,7 @@ Number.isSafeInteger(3.0);                  // true
 
 
        Полифил
        
 
-
        Number.isSafeInteger = Number.isSafeInteger || function (value) {
+
        Number.isSafeInteger = Number.isSafeInteger || function (value) {
    return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
 };
        
 
diff --git a/files/ru/web/javascript/reference/global_objects/number/toexponential/index.html b/files/ru/web/javascript/reference/global_objects/number/toexponential/index.html
index 918f0ba864..1e7fbca3dc 100644
--- a/files/ru/web/javascript/reference/global_objects/number/toexponential/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/toexponential/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential
 
 
        Синтаксис
        
 
-
        numObj.toExponential([fractionDigits])
        
+
        numObj.toExponential([fractionDigits])
        
 
 
        Параметры
        
 
@@ -46,7 +46,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential
 
 
        Пример: использование toExponential
        
 
-
        var numObj = 77.1234;
+
        var numObj = 77.1234;
 
 
 console.log(numObj.toExponential());  // выведет 7.71234e+1
diff --git a/files/ru/web/javascript/reference/global_objects/number/tofixed/index.html b/files/ru/web/javascript/reference/global_objects/number/tofixed/index.html
index 2d68871d4c..cc4718ae06 100644
--- a/files/ru/web/javascript/reference/global_objects/number/tofixed/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/tofixed/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed
 
 
        Синтаксис
        
 
-
        numObj.toFixed([digits])
        
+
        numObj.toFixed([digits])
        
 
 
        Параметры
        
 
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed
 
 
        Пример: использование toFixed
        
 
-
        var numObj = 12345.6789;
+
        var numObj = 12345.6789;
 
 numObj.toFixed();       // Вернёт '12346': обратите внимание на округление, дробной части нет
 numObj.toFixed(1);      // Вернёт '12345.7': обратите внимание на округление
diff --git a/files/ru/web/javascript/reference/global_objects/number/toprecision/index.html b/files/ru/web/javascript/reference/global_objects/number/toprecision/index.html
index da8d601c7d..fd39f6dd5a 100644
--- a/files/ru/web/javascript/reference/global_objects/number/toprecision/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/toprecision/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision
 
 
        Синтаксис
        
 
-
        numObj.toPrecision([precision])
        
+
        numObj.toPrecision([precision])
        
 
 
        Параметры
        
 
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision
 
 
        Пример: использование toPrecision
        
 
-
        var numObj = 5.123456;
+
        var numObj = 5.123456;
 
 console.log(numObj.toPrecision());    // выведет '5.123456'
 console.log(numObj.toPrecision(5));   // выведет '5.1235'
diff --git a/files/ru/web/javascript/reference/global_objects/number/tostring/index.html b/files/ru/web/javascript/reference/global_objects/number/tostring/index.html
index 86cd5b3b60..3f8103311d 100644
--- a/files/ru/web/javascript/reference/global_objects/number/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/tostring/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString
 
 
        Синтаксис
        
 
-
        numObj.toString([radix])
        
+
        numObj.toString([radix])
        
 
 
        Параметры
        
 
@@ -46,7 +46,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString
 
 
        Пример: использование toString
        
 
-
        var count = 10;
+
        var count = 10;
 
 console.log(count.toString());    // Выведет '10'
 console.log((17).toString());     // Выведет '17'
diff --git a/files/ru/web/javascript/reference/global_objects/object/create/index.html b/files/ru/web/javascript/reference/global_objects/object/create/index.html
index f7b4d2c69b..09ac00405a 100644
--- a/files/ru/web/javascript/reference/global_objects/object/create/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/create/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/create
 
 
        Синтаксис
        
 
-
        Object.create(proto[, propertiesObject])
        
+
        Object.create(proto[, propertiesObject])
        
 
 
        Параметры
        
 
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/create
 
 
        Ниже показан пример использования Object.create() для имитации классического наследования. Это пример одиночного наследования, поскольку только его поддерживает JavaScript.
        
 
-
        // Shape — суперкласс
+
        // Shape — суперкласс
 function Shape() {
   this.x = 0;
   this.y = 0;
@@ -73,7 +73,7 @@ rect.move(1, 1); // выведет 'Фигура переместилась.'
 
 
        Если вы хотите наследоваться от нескольких объектов, то это возможно сделать при помощи примесей.
        
 
-
        function MyClass() {
+
        function MyClass() {
   SuperClass.call(this);
   OtherSuperClass.call(this);
 }
@@ -90,7 +90,7 @@ MyClass.prototype.myMethod = function() {
 
 
        Пример: использование аргумента propertiesObject с Object.create()
        
 
-
        var o;
+
        var o;
 
 // создаём объект с нулевым прототипом
 o = Object.create(null);
@@ -159,7 +159,7 @@ o2 = Object.create({}, {
 
 
        Для этого полифила необходима правильно работающая Object.prototype.hasOwnProperty.
        
 
-
        if (typeof Object.create != 'function') {
+
        if (typeof Object.create != 'function') {
   // Этапы производства ECMA-262, издание 5, 15.2.3.5
   // Ссылка: http://es5.github.io/#x15.2.3.5
   Object.create = (function() {
diff --git a/files/ru/web/javascript/reference/global_objects/object/entries/index.html b/files/ru/web/javascript/reference/global_objects/object/entries/index.html
index fd74a6a286..5cba32dbc5 100644
--- a/files/ru/web/javascript/reference/global_objects/object/entries/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/entries/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/entries
 
 
        Синтаксис
        
 
-
        Object.entries(obj)
        
+
        Object.entries(obj)
        
 
 
        Параметры
        
 
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/entries
 
 
        Примеры
        
 
-
        var obj = { foo: "bar", baz: 42 };
+
        var obj = { foo: "bar", baz: 42 };
 console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]
 
 // массив как объект
@@ -49,7 +49,7 @@ console.log(Object.entries(my_obj)); // [ ['foo', 'bar'] ]
 // non-object argument will be coerced to an object
 console.log(Object.entries("foo")); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]
        
 
-
        // returns an empty array for any primitive type, since primitives have no own properties
+
        // returns an empty array for any primitive type, since primitives have no own properties
 console.log(Object.entries(100)); // [ ]
 
 // iterate through key-value gracefully
@@ -67,7 +67,7 @@ Object.entries(obj).forEach(([key, value]) => {
 
 
        Конструктор {{jsxref("Map", "new Map()")}} принимает повторение значений. С Object.entries вы легко можете преобразовать {{jsxref("Object")}} в {{jsxref("Map")}}:
        
 
-
        var obj = { foo: "bar", baz: 42 };
+
        var obj = { foo: "bar", baz: 42 };
 var map = new Map(Object.entries(obj));
 console.log(map); // Map { foo: "bar", baz: 42 }
        
 
@@ -75,7 +75,7 @@ console.log(map); // Map { foo: "bar", baz: 42 }
        
 
 
        Используя метод Разбора Массивов Вы можете легко итерировать объекты.
        
 
-
        const obj = { foo: 'bar', baz: 42 };
+
        const obj = { foo: 'bar', baz: 42 };
 Object.entries(obj).forEach(([key, value]) => console.log(`${key}: ${value}`)); // "foo: bar", "baz: 42"
        
 
 
        Полифил
        
diff --git a/files/ru/web/javascript/reference/global_objects/promise/then/index.html b/files/ru/web/javascript/reference/global_objects/promise/then/index.html
index 5bdc241aa9..797adc9171 100644
--- a/files/ru/web/javascript/reference/global_objects/promise/then/index.html
+++ b/files/ru/web/javascript/reference/global_objects/promise/then/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Promise/then
 
 
        Синтаксис
        
 
-
        p.then(onFulfilled[, onRejected]);
+
        p.then(onFulfilled[, onRejected]);
 
 p.then(value => {
   // выполнение
@@ -43,7 +43,7 @@ p.then(value => {
 
 
        Использование метода then
        
 
-
        var p1 = new Promise(function(resolve, reject) {
+
        var p1 = new Promise(function(resolve, reject) {
   resolve("Успех!");
   // или
   // reject("Ошибка!");
@@ -60,7 +60,7 @@ p1.then(function(value) {
 
 
        Так как метод then возвращает промис (Promise), вы можете объединить несколько вызовов then в цепочку. Значения возвращаемые из колбэков onFulfilled или onRejected будут автоматически обёрнуты в промис.
        
 
-
        var p2 = new Promise(function(resolve, reject) {
+
        var p2 = new Promise(function(resolve, reject) {
   resolve(1);
 });
 
@@ -78,7 +78,7 @@ p2.then(function(value) {
 
 
        Вы также можете соединить одну функцию, имеющую подобный с промисами API, с другой функцией.
        
 
-
        function fetch_current_data() {
+
        function fetch_current_data() {
   // API функции fetch() возвращает промис. Эта функция
   // имеет аналогичный API, за исключением значения в случае выполнения
   return fetch("current-data.json").then((response) => {
@@ -95,7 +95,7 @@ p2.then(function(value) {
 
 
        Если onFulfilled возвращает промис, возвращаемое значение может быть выполнено (resolved) / отклонено (rejected) промисом.
        
 
-
        function resolveLater(resolve, reject) {
+
        function resolveLater(resolve, reject) {
   setTimeout(function () {
     resolve(10);
   }, 1000);
diff --git a/files/ru/web/javascript/reference/global_objects/proxy/index.html b/files/ru/web/javascript/reference/global_objects/proxy/index.html
index 12f1cfc36f..3611061bef 100644
--- a/files/ru/web/javascript/reference/global_objects/proxy/index.html
+++ b/files/ru/web/javascript/reference/global_objects/proxy/index.html
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Proxy
 
 
        Прокси - это новые объекты; невозможно выполнить "проксирование" существующего объекта. Пример создания прокси:
        
 
-
        var p = new Proxy(target, handler);
+
        var p = new Proxy(target, handler);
 
        
 
 
        Где:
        
@@ -150,7 +150,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Proxy
 
 
        Объект, возвращающий значение 37, в случае отсутствия свойства с указанным именем:
        
 
-
        var handler = {
+
        var handler = {
     get: function(target, name){
         return name in target?
             target[name] :
@@ -170,7 +170,7 @@ console.log('c' in p, p.c); // false, 37
 
 
        В данном примере мы используем JavaScript объект, к которому наш прокси направляет все запросы:
        
 
-
        var target = {};
+
        var target = {};
 var p = new Proxy(target, {});
 
 p.a = 37; // операция перенаправлена прокси
@@ -182,7 +182,7 @@ console.log(target.a); // 37. Операция была успешно пере
 
 
        При помощи Proxy вы можете легко проверять передаваемые объекту значения:
        
 
-
        let validator = {
+
        let validator = {
   set: function(obj, prop, value) {
     if (prop === 'age') {
       if (!Number.isInteger(value)) {
@@ -213,7 +213,7 @@ person.age = 300; // Вызовет исключение
 
 
        Функция прокси может легко дополнить конструктор новым:
        
 
-
        function extend(sup, base) {
+
        function extend(sup, base) {
     var descriptor = Object.getOwnPropertyDescriptor(
         base.prototype, 'constructor',
     );
@@ -260,7 +260,7 @@ console.log(Peter.age); // 13
 
 
        Иногда возникает необходимость переключить атрибут или имя класса у двух разных элементов:
        
 
-
        let view = new Proxy({
+
        let view = new Proxy({
   selected: null
 },
 {
@@ -293,7 +293,7 @@ console.log(i2.getAttribute('aria-selected')); // 'true'
 
 
        Прокси объект products проверяет передаваемые значения и преобразует их в массив в случае необходимости. Объект также поддерживает дополнительное свойство latestBrowser на чтение и запись.
        
 
-
        let products = new Proxy({
+
        let products = new Proxy({
   browsers: ['Internet Explorer', 'Netscape']
 },
 {
@@ -336,7 +336,7 @@ console.log(products.latestBrowser); // 'Chrome'
 
 
        Данный прокси расширяет массив дополнительными возможностями. Как вы видите, вы можете гибко "задавать" свойства без использования Object.defineProperties. Данный пример также может быть использован для поиска строки таблицы по её ячейке. В этом случае целью будет table.rows.
        
 
-
        let products = new Proxy([
+
        let products = new Proxy([
   { name: 'Firefox', type: 'browser' },
   { name: 'SeaMonkey', type: 'browser' },
   { name: 'Thunderbird', type: 'mailer' }
@@ -397,7 +397,7 @@ console.log(products.number); // 3
 
 
        В данном примере, использующем все виды перехватчиков, мы попытаемся проксировать не нативный объект, который частично приспособлен для этого - docCookies, созданном в разделе "little framework" и опубликованном на странице document.cookie.
        
 
-
        /*
+
        /*
   var docCookies = ... получить объект "docCookies" можно здесь:
   https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support
 */
diff --git a/files/ru/web/javascript/reference/global_objects/proxy/proxy/apply/index.html b/files/ru/web/javascript/reference/global_objects/proxy/proxy/apply/index.html
index 50c940dd66..b9981c3d0f 100644
--- a/files/ru/web/javascript/reference/global_objects/proxy/proxy/apply/index.html
+++ b/files/ru/web/javascript/reference/global_objects/proxy/proxy/apply/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply
 
 
        Синтаксис
        
 
-
        const p = new Proxy(target, {
+
        const p = new Proxy(target, {
   apply: function(target, thisArg, argumentsList) {
   }
 });
@@ -66,7 +66,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply
 
 
        Следующий код ловит вызов функции.
        
 
-
        const p = new Proxy(function() {}, {
+
        const p = new Proxy(function() {}, {
   apply: function(target, thisArg, argumentsList) {
     console.log('called: ' + argumentsList.join(', '));
     return argumentsList[0] + argumentsList[1] + argumentsList[2];
diff --git a/files/ru/web/javascript/reference/global_objects/proxy/proxy/get/index.html b/files/ru/web/javascript/reference/global_objects/proxy/proxy/get/index.html
index 07c349853f..9c8dc59f4e 100644
--- a/files/ru/web/javascript/reference/global_objects/proxy/proxy/get/index.html
+++ b/files/ru/web/javascript/reference/global_objects/proxy/proxy/get/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/get
 
 
        Syntax
        
 
-
        const p = new Proxy(target, {
+
        const p = new Proxy(target, {
   get: function(target, property, receiver) {
   }
 });
@@ -65,7 +65,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/get
 
 
        Следующий код перехватывает получение значения свойства.
        
 
-
        const p = new Proxy({}, {
+
        const p = new Proxy({}, {
   get: function(target, property, receiver) {
     console.log('called: ' + property);
     return 10;
@@ -78,7 +78,7 @@ console.log(p.a); // "called: a"
 
 
        Следующий код нарушает инвариант.
        
 
-
        const obj = {};
+
        const obj = {};
 Object.defineProperty(obj, 'a', {
   configurable: false,
   enumerable: false,
diff --git a/files/ru/web/javascript/reference/global_objects/proxy/proxy/index.html b/files/ru/web/javascript/reference/global_objects/proxy/proxy/index.html
index 1bf6b70b43..0e3ba67f53 100644
--- a/files/ru/web/javascript/reference/global_objects/proxy/proxy/index.html
+++ b/files/ru/web/javascript/reference/global_objects/proxy/proxy/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy
 
 
        Syntax
        
 
-
        new Proxy(target, handler)
        
+
        new Proxy(target, handler)
        
 
 
        Parameters
        
 
@@ -77,7 +77,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy
 
 
        In this example the target has two properties, notProxied and proxied. We define a handler that returns a different value for proxied, and lets any other accesses through to the target.
        
 
-
        const target = {
+
        const target = {
   notProxied: "original value",
   proxied: "original value"
 };
diff --git a/files/ru/web/javascript/reference/global_objects/proxy/proxy/set/index.html b/files/ru/web/javascript/reference/global_objects/proxy/proxy/set/index.html
index 7c1eade6a7..2f1d58fa1b 100644
--- a/files/ru/web/javascript/reference/global_objects/proxy/proxy/set/index.html
+++ b/files/ru/web/javascript/reference/global_objects/proxy/proxy/set/index.html
@@ -18,7 +18,7 @@ original_slug: Web/JavaScript/Reference/Global_Objects/Proxy/handler/set
 
 
        Синтаксис
        
 
-
        var p = new Proxy(target, {
+
        var p = new Proxy(target, {
   set: function(target, property, value, receiver) {
   }
 });
@@ -82,7 +82,7 @@ original_slug: Web/JavaScript/Reference/Global_Objects/Proxy/handler/set
 
 
        Следующий код перехватывает установку значения свойству.
        
 
-
        var p = new Proxy({}, {
+
        var p = new Proxy({}, {
   set: function(target, prop, value, receiver) {
     target[prop] = value
     console.log('property set: ' + prop + ' = ' + value)
diff --git a/files/ru/web/javascript/reference/global_objects/reflect/index.html b/files/ru/web/javascript/reference/global_objects/reflect/index.html
index 1764ba8aac..62463ed859 100644
--- a/files/ru/web/javascript/reference/global_objects/reflect/index.html
+++ b/files/ru/web/javascript/reference/global_objects/reflect/index.html
@@ -50,7 +50,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Reflect
 
 
        Проверка наличия конкретных свойств у объекта
        
 
-
        const duck = {
+
        const duck = {
   name: 'Maurice',
   color: 'white',
   greeting: function() {
@@ -65,12 +65,12 @@ Reflect.has(duck, 'haircut');
 
 
        Возврат собственных ключей объекта
        
 
-
        Reflect.ownKeys(duck);
+
        Reflect.ownKeys(duck);
 // [ "name", "color", "greeting" ]
        
 
 
        Добавление нового свойства в объект
        
 
-
        Reflect.set(duck, 'eyes', 'black');
+
        Reflect.set(duck, 'eyes', 'black');
 // вернётся "true" если вызов успешен
 // объект "duck" теперь содержит свойство "eyes" со значением "black"
        
 
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/index.html b/files/ru/web/javascript/reference/global_objects/regexp/index.html
index a6eb782e72..601b6d84ed 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/index.html
@@ -26,7 +26,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
 
 
        Возможны как литеральная запись, так и запись через конструктор:
        
 
-
        /pattern/flags
+
        /pattern/flags
 new RegExp(pattern, flags)
 
        
 
@@ -56,7 +56,7 @@ new RegExp(pattern, flags)        
 
 
        Существует два способа создания объекта RegExp: литеральная запись и использование конструктора. При записи строк параметры в литеральной записи не используют символы кавычек, в то время как параметры функции-конструктора используют кавычки. Так что следующие выражения создают одинаковые регулярные выражения:
        
 
-
        /ab+c/i;
+
        /ab+c/i;
 new RegExp('ab+c', 'i');
 
        
 
@@ -66,7 +66,7 @@ new RegExp('ab+c', 'i');
 
 
        При использовании функции-конструктора необходимо использовать обычные правила экранирования в строках (предварять специальные символы символом обратного слеша «\»). Например, следующие выражения эквивалентны:
        
 
-
        var re = /\w+/;
+
        var re = /\w+/;
 var re = new RegExp('\\w+');
 
        
 
@@ -456,7 +456,7 @@ var re = new RegExp('\\w+');
 
 
        Следующий скрипт использует метод {{jsxref("String.prototype.replace()", "replace()")}} экземпляра строки {{jsxref("Global_Objects/String", "String")}} для сопоставления с именем в формате имя фамилия и выводит его в формате фамилия, имя. В тесте замены скрипт использует заменители $1 и $2, которые заменяются на результаты соответствующих сопоставившихся подгрупп регулярного выражения.
        
 
-
        var re = /(\w+)\s(\w+)/;
+
        var re = /(\w+)\s(\w+)/;
 var str = 'John Smith';
 var newstr = str.replace(re, '$2, $1');
 console.log(newstr);
@@ -474,7 +474,7 @@ console.log(newstr);
 
 
        Символы конца строки различаются на различных платформах (Unix, Windows и так далее). Разбиение строк из этого примера работает на всех платформах.
        
 
-
        var text = 'Некоторый текст\nЕщё текст\r\nИ ещё\rЭто конец';
+
        var text = 'Некоторый текст\nЕщё текст\r\nИ ещё\rЭто конец';
 var lines = text.split(/\r\n|\r|\n/);
 console.log(lines); // выведет [ 'Некоторый текст', 'Ещё текст', 'И ещё', 'Это конец' ]
 
        
@@ -483,7 +483,7 @@ console.log(lines); // выведет [ 'Некоторый текст', 'Ещё
 
 
        Пример: использование регулярных выражений на нескольких строках
        
 
-
        var s = 'Please yes\nmake my day!';
+
        var s = 'Please yes\nmake my day!';
 s.match(/yes.*day/);
 // Вернёт null
 s.match(/yes[^]*day/);
@@ -494,7 +494,7 @@ s.match(/yes[^]*day/);
 
 
        Этот пример демонстрирует, как можно использовать флаг «липучести» регулярных выражений для сопоставления с отдельными строками многострочного ввода.
        
 
-
        var text = 'Первая строка\nВторая строка';
+
        var text = 'Первая строка\nВторая строка';
 var regex = /(\S+) строка\n?/y;
 
 var match = regex.exec(text);
@@ -511,7 +511,7 @@ console.log(match3 === null); // напечатает 'true'
 
 
        Во время выполнения можно проверить, поддерживается ли флаг «липучести», при помощи блока try { … } catch { … }. Для этого надо использовать либо выражение с eval(…), либо конструктор RegExp(строка-регулярки, строка-с-флагами) (поскольку нотация /регулярка/флаги обрабатывается во время компиляции, исключение будет выброшено до того, как выполнение достигнет блока catch). Например:
        
 
-
        var supports_sticky;
+
        var supports_sticky;
 try { RegExp('', 'y'); supports_sticky = true; }
 catch(e) { supports_sticky = false; }
 console.log(supports_sticky); // напечатает 'true'
@@ -521,7 +521,7 @@ console.log(supports_sticky); // напечатает 'true'
 
 
        Как уже сказано выше, символьные классы \w и \W сопоставляются только с базовыми символами ASCII; то есть, с символами от «a» до «z», от «A» до «Z», от «0» до «9» и символом «_». Для сопоставления с символами из других языков, например, с кириллическими или иврита, используйте форму \uhhhh, где «hhhh» — это значение символа Юникода, записанное в шестнадцатеричной форме. Этот пример демонстрирует, как можно выделить символы Юникода, составляющие слова.
        
 
-
        var text = 'Образец text на русском языке';
+
        var text = 'Образец text на русском языке';
 var regex = /[\u0400-\u04FF]+/g;
 
 var match = regex.exec(text);
@@ -539,7 +539,7 @@ console.log(regex.lastIndex); // напечатает '15'
 
 
        Пример: извлечение имени поддомена из URL
        
 
-
        var url = 'http://xxx.domain.com';
+
        var url = 'http://xxx.domain.com';
 console.log(/[^.]+/.exec(url)[0].substr(7)); // напечатает 'xxx'
 
        
 
@@ -578,7 +578,7 @@ console.log(/[^.]+/.exec(url)[0].substr(7)); // напечатает 'xxx'
 
 
        Начиная с Gecko 34 {{geckoRelease(34)}}, в случае захвата группы с квантификаторами, предотвращающими появление группы в результате сопоставления, сопоставившийся текст для захваченной группы теперь имеет значение undefined вместо пустой строки:
        
 
-
        // Firefox 33 или более ранние
+
        // Firefox 33 или более ранние
 'x'.replace(/x(.)?/g, function(m, group) {
   console.log("'group:" + group + "'");
 }); // 'group:'
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/lastmatch/index.html b/files/ru/web/javascript/reference/global_objects/regexp/lastmatch/index.html
index 89551d517b..fd3232f351 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/lastmatch/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/lastmatch/index.html
@@ -9,7 +9,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/lastMatch
 
 
        Синтаксис
        
 
-
        RegExp.lastMatch
+
        RegExp.lastMatch
 RegExp['$&']
 
        
 
@@ -25,7 +25,7 @@ RegExp['$&']
 
 
        Использование lastMatch и $&
        
 
-
        var re = /hi/g;
+
        var re = /hi/g;
 re.test('hi there!');
 RegExp.lastMatch; // "hi"
 RegExp['$&'];     // "hi"
diff --git a/files/ru/web/javascript/reference/global_objects/set/set/index.html b/files/ru/web/javascript/reference/global_objects/set/set/index.html
index 8febad1cee..2720aafa80 100644
--- a/files/ru/web/javascript/reference/global_objects/set/set/index.html
+++ b/files/ru/web/javascript/reference/global_objects/set/set/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Set/Set
 
 
        Синтаксис
        
 
-
        new Set([iterable])
        
+
        new Set([iterable])
        
 
 
        Параметры
        
 
@@ -32,7 +32,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Set/Set
 
 
        Использование объекта Set
        
 
-
        let mySet = new Set()
+
        let mySet = new Set()
 
 mySet.add(1)           // Set [ 1 ]
 mySet.add(5)           // Set [ 1, 5 ]
diff --git a/files/ru/web/javascript/reference/global_objects/string/@@iterator/index.html b/files/ru/web/javascript/reference/global_objects/string/@@iterator/index.html
index 9b26c886e7..203c8a97f0 100644
--- a/files/ru/web/javascript/reference/global_objects/string/@@iterator/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/@@iterator/index.html
@@ -22,13 +22,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/@@iterator
 
 
        Синтаксис
        
 
-
        string[Symbol.iterator]
        
+
        string[Symbol.iterator]
        
 
 
        Примеры
        
 
 
        Пример: использование метода [@@iterator]()
        
 
-
        var string = 'A\uD835\uDC68';
+
        var string = 'A\uD835\uDC68';
 
 var strIter = string[Symbol.iterator]();
 
@@ -38,7 +38,7 @@ console.log(strIter.next().value); // "\uD835\uDC68"
 
 
        Пример: использование метода [@@iterator]() вместе с циклом for..of
        
 
-
        var string = 'A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A';
+
        var string = 'A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A';
 
 for (var v of string) {
   console.log(v);
diff --git a/files/ru/web/javascript/reference/global_objects/string/endswith/index.html b/files/ru/web/javascript/reference/global_objects/string/endswith/index.html
index 1fa53bd180..fe4795f959 100644
--- a/files/ru/web/javascript/reference/global_objects/string/endswith/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/endswith/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith
 
 
        Синтаксис
        
 
-
        str.endsWith(searchString[, length])
        
+
        str.endsWith(searchString[, length])
        
 
 
        Параметры
        
 
@@ -40,7 +40,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith
 
 
        Пример: использование метода endsWith()
        
 
-
        var str = 'Быть или не быть, вот в чём вопрос.';
+
        var str = 'Быть или не быть, вот в чём вопрос.';
 
 console.log(str.endsWith('вопрос.'));   // true
 console.log(str.endsWith('быть'));      // false
@@ -51,7 +51,7 @@ console.log(str.endsWith('быть', 16));  // true
 
 
        Этот метод был добавлен к спецификации ECMAScript 6 и может быть доступен ещё не во всех реализациях JavaScript. Однако, вы можете легко эмулировать этот метод при помощи следующего кода:
        
 
-
        if (!String.prototype.endsWith) {
+
        if (!String.prototype.endsWith) {
   Object.defineProperty(String.prototype, 'endsWith', {
     value: function(searchString, position) {
       var subjectString = this.toString();
diff --git a/files/ru/web/javascript/reference/global_objects/string/index.html b/files/ru/web/javascript/reference/global_objects/string/index.html
index 5db7b5e416..80c7293c4d 100644
--- a/files/ru/web/javascript/reference/global_objects/string/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String
 
 
        Строковые литералы могут быть следующих форм:
        
 
-
        'строка текста'
+
        'строка текста'
 "строка текста"
 "中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ்"
 
        
@@ -84,7 +84,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String
 
 
        Либо можно использовать глобальный объект String напрямую:
        
 
-
        String(thing)
+
        String(thing)
 new String(thing)
 
        
 
@@ -103,12 +103,12 @@ new String(thing)
 
 
        Существует два способа добраться до конкретного символа в строке. В первом способе используется метод {{jsxref("String.prototype.charAt()", "charAt()")}}:
        
 
-
        return 'кот'.charAt(1); // вернёт "о"
+
        return 'кот'.charAt(1); // вернёт "о"
 
        
 
 
        Другим способом (введённым в ECMAScript 5) является рассмотрение строки как массивоподобного объекта, в котором символы имеют соответствующие числовые индексы:
        
 
-
        return 'кот'[1]; // вернёт "о"
+
        return 'кот'[1]; // вернёт "о"
 
        
 
 
        При доступе к символам посредством нотации с квадратными скобками, попытка удалить символ, или присвоить значение числовому свойству закончится неудачей, поскольку эти свойства являются незаписываемыми и ненастраиваемыми. Смотрите документацию по методу {{jsxref("Object.defineProperty()")}} для дополнительной информации.
        
@@ -117,7 +117,7 @@ new String(thing)
 
 
        Разработчики на C имеют для сравнения строк функцию strcmp(). В JavaScript вы просто используете операторы меньше и больше:
        
 
-
        var a = 'a';
+
        var a = 'a';
 var b = 'b';
 if (a < b) { // true
   print(a + ' меньше чем ' + b);
@@ -136,7 +136,7 @@ if (a < b) { // true
 
 
        Строковые литералы (обозначаемые двойными или одинарными кавычками) и строки, возвращённые вызовом String в неконструкторном контексте (то есть, без использования ключевого слова {{jsxref("Operators/new", "new")}}) являются строковыми примитивами. JavaScript автоматически преобразует примитивы в объекты String, так что на строковых примитивах возможно использовать методы объекта String. В контекстах, когда на примитивной строке вызывается метод или происходит поиск свойства, JavaScript автоматически оборачивает строковый примитив объектом и вызывает на нём метод или ищет в нём свойство.
        
 
-
        var s_prim = 'foo';
+
        var s_prim = 'foo';
 var s_obj = new String(s_prim);
 
 console.log(typeof s_prim); // выведет 'string'
@@ -145,7 +145,7 @@ console.log(typeof s_obj);  // выведет 'object'
 
 
        Строковые примитивы и объекты String также дают разные результаты при использовании глобальной функции {{jsxref("Global_Objects/eval", "eval()")}}. Примитивы, передаваемые в eval(), трактуются как исходный код; объекты же String трактуются так же, как и все остальные объекты, а именно: возвращается сам объект. Например:
        
 
-
        var s1 = '2 + 2';             // создаёт строковый примитив
+
        var s1 = '2 + 2';             // создаёт строковый примитив
 var s2 = new String('2 + 2'); // создаёт объект String
 console.log(eval(s1));        // выведет число 4
 console.log(eval(s2));        // выведет строку '2 + 2'
@@ -155,7 +155,7 @@ console.log(eval(s2));        // выведет строку '2 + 2'
 
 
        Объект String также всегда может быть преобразован в его примитивный аналог при помощи метода {{jsxref("String.prototype.valueOf()", "valueOf()")}}.
        
 
-
        console.log(eval(s2.valueOf())); // выведет число 4
+
        console.log(eval(s2.valueOf())); // выведет число 4
 
        
 
 
        Примечание: для того, чтобы узнать больше о другом возможном подходе к строкам в JavaScript, прочитайте статью о StringView — C-подобном представлении строк на основе типизированных массивов.
        
@@ -186,7 +186,7 @@ console.log(eval(s2));        // выведет строку '2 + 2'
 
 
        Методы экземпляров String также доступны в Firefox как часть JavaScript 1.6 (который не является частью стандарта ECMAScript) на объекте String, что позволяет применять эти методы к любому объекту:
        
 
-
        var num = 15;
+
        var num = 15;
 console.log(String.replace(num, /5/, '2'));
 
        
 
@@ -194,7 +194,7 @@ console.log(String.replace(num, /5/, '2'));
 
 
        Следующая прослойка позволяет использовать их во всех браузерах:
        
 
-
        /*globals define*/
+
        /*globals define*/
 // Предполагаем, что все требуемые методы экземпляров String уже присутствуют
 // (для них так же можно использовать полифилы, если их нет)
 (function() {
@@ -249,7 +249,7 @@ console.log(String.replace(num, /5/, '2'));
 
 
        Объект String можно использовать как «безопасную» альтернативу методу {{jsxref("String.prototype.toString()", "toString()")}}, так как хотя он обычно и вызывает соответствующий метод toString(), он также работает и для значений {{jsxref("Global_Objects/null", "null")}} и {{jsxref("Global_Objects/undefined", "undefined")}}. Например:
        
 
-
        var outputStrings = [];
+
        var outputStrings = [];
 for (var i = 0, n = inputValues.length; i < n; ++i) {
   outputStrings.push(String(inputValues[i]));
 }
diff --git a/files/ru/web/javascript/reference/global_objects/string/matchall/index.html b/files/ru/web/javascript/reference/global_objects/string/matchall/index.html
index 1ffad309c2..f314d2f18c 100644
--- a/files/ru/web/javascript/reference/global_objects/string/matchall/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/matchall/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll
 
 
        Синтаксис
        
 
-
        str.matchAll(regexp)
        
+
        str.matchAll(regexp)
        
 
 
        Параметры
        
 
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll
 
 
        До добавления метода matchAll в JavaScript, можно было использовать метод regexp.exec (и регулярные выражения с флагом /g ) в цикле для получения доступа к совпадениям:
        
 
-
        const regexp = RegExp('foo*','g');
+
        const regexp = RegExp('foo*','g');
 const str = 'table football, foosball';
 
 while ((matches = regexp.exec(str)) !== null) {
@@ -52,7 +52,7 @@ while ((matches = regexp.exec(str)) !== null) {
 
        С появлением matchAll, нет необходимости использовать цикл while и метод exec с флагом /g.
        
  Используя вместо этого метод matchAll, вы получаете итератор, который вы можете использовать более удобно с конструкциями for...of, array spread, или {{jsxref("Array.from()")}} :
        
 
-
        const regexp = RegExp('foo*','g');
+
        const regexp = RegExp('foo*','g');
 const str = 'table football, foosball';
 let matches = str.matchAll(regexp);
 
@@ -74,7 +74,7 @@ Array.from(matches, m => m[0]);
 
 
        Ещё одна веская причина использовать matchAll это улучшенный доступ к группам захвата. Группы захвата игнорируются при использовании match() с глобальным флагом /g:
        
 
-
        var regexp = /t(e)(st(\d?))/g;
+
        var regexp = /t(e)(st(\d?))/g;
 var str = 'test1test2';
 
 str.match(regexp);
@@ -82,7 +82,7 @@ str.match(regexp);
 
 
        С matchAll у вас появляется к ним доступ:
        
 
-
        let array = [...str.matchAll(regexp)];
+
        let array = [...str.matchAll(regexp)];
 
 array[0];
 // ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4]
diff --git a/files/ru/web/javascript/reference/global_objects/string/replaceall/index.html b/files/ru/web/javascript/reference/global_objects/string/replaceall/index.html
index 318e9a30c3..3c4ce6551f 100644
--- a/files/ru/web/javascript/reference/global_objects/string/replaceall/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/replaceall/index.html
@@ -15,7 +15,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/replaceAll
 
 
        Syntax
        
 
-
        const newStr = str.replaceAll(regexp|substr, newSubstr|function)
+
        const newStr = str.replaceAll(regexp|substr, newSubstr|function)
 
        
 
 
        
@@ -119,20 +119,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/replaceAll
 
 
        Using replaceAll
        
 
-
        'aabbcc'.replaceAll('b', '.');
+
        'aabbcc'.replaceAll('b', '.');
 // 'aa..cc'
        
 
 
        Non-global regex throws
        
 
 
        Поиск с регулярными выражениями должен быть с ("g"). Это не работает:
        
 
-
        'aabbcc'.replaceAll(/b/, '.');
+
        'aabbcc'.replaceAll(/b/, '.');
 TypeError: replaceAll must be called with a global RegExp
 
        
 
 
        Это работает:
        
 
-
        'aabbcc'.replaceAll(/b/g, '.');
+
        'aabbcc'.replaceAll(/b/g, '.');
 "aa..cc"
 
        
 
diff --git a/files/ru/web/javascript/reference/global_objects/string/slice/index.html b/files/ru/web/javascript/reference/global_objects/string/slice/index.html
index 1750d01614..07a1f6b523 100644
--- a/files/ru/web/javascript/reference/global_objects/string/slice/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/slice/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/slice
 
 
        Синтаксис
        
 
-
        str.slice(beginIndex[, endIndex])
        
+
        str.slice(beginIndex[, endIndex])
        
 
 
        Параметры
        
 
@@ -51,7 +51,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/slice
 
 
        В следующем примере метод slice() используется для создания новой строки.
        
 
-
        let str1 = 'Приближается утро.';
+
        let str1 = 'Приближается утро.';
 let str2 = str1.slice(1, 8);
 let str3 = str1.slice(4, -2);
 let str4 = str1.slice(12);
@@ -67,7 +67,7 @@ console.log(str5); // ВЫВОД: ""
 
 
        В следующем примере метод slice() используется вместе с отрицательными индексами.
        
 
-
        let str = 'Приближается утро.';
+
        let str = 'Приближается утро.';
 str.slice(-3);     // вернёт 'ро.'
 str.slice(-3, -1); // вернёт 'ро'
 str.slice(0, -1);  // вернёт 'Приближается утро'
@@ -75,15 +75,15 @@ str.slice(0, -1);  // вернёт 'Приближается утро'
 
 
        В этом примере начальным индексом считается 11-й символ с конца строки, а конечным - 16-й с начала.
        
 
-
        str.slice(-11, 16); // вернёт 'ается утр'
        
+
        str.slice(-11, 16); // вернёт 'ается утр'
        
 
 
        Здесь начальным индексом считается 6-й символ от начала строки, а конечным - 7-й с конца.
        
 
-
        str.slice(6, -7); // вернёт 'жаетс'
        
+
        str.slice(6, -7); // вернёт 'жаетс'
        
 
 
        В этом примере оба индекса считаются с конца строки: 5-й для начального индекса, 1-й для конечного.
        
 
-
        str.slice(-5, -1); // вернёт 'утро'
        
+
        str.slice(-5, -1); // вернёт 'утро'
        
 
 
        Спецификации
        
 
diff --git a/files/ru/web/javascript/reference/global_objects/string/split/index.html b/files/ru/web/javascript/reference/global_objects/string/split/index.html
index 984fe07e85..32eae7b9c0 100644
--- a/files/ru/web/javascript/reference/global_objects/string/split/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/split/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/split
 
 
        Синтаксис
        
 
-
        str.split([separator[, limit]])
        
+
        str.split([separator[, limit]])
        
 
 
        Параметры
        
 
@@ -46,7 +46,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/split
 
 
        В следующем примере определяется функция, которая разбивает строку на массив строк, используя указанный разделитель. После разбиения строки, функция отображает сообщения, показывающие оригинальную строку (до разбиения), используемый разделитель, количество элементов в массиве и сами эти элементы.
        
 
-
        function splitString(stringToSplit, separator) {
+
        function splitString(stringToSplit, separator) {
   var arrayOfStrings = stringToSplit.split(separator);
 
   console.log('Оригинальная строка: "' + stringToSplit + '"');
@@ -68,7 +68,7 @@ splitString(monthString, comma);
 
 
        Пример сгенерирует следующий вывод:
        
 
-
        Оригинальная строка: "И как хорош тот новый мир, где есть такие люди!"
+
        Оригинальная строка: "И как хорош тот новый мир, где есть такие люди!"
 Разделитель: " "
 Массив содержит 10 элементов: И / как / хорош / тот / новый / мир, / где / есть / такие / люди!
 
@@ -85,7 +85,7 @@ splitString(monthString, comma);
 
 
        В следующем примере метод split() ищет 0 или более пробелов, за которыми следует точка с запятой, за которой снова следуют 0 или более пробелов, и, если этот шаблон найден, удаляет пробелы из строки. Переменная nameList является массивом, возвращённым в результате работы метода split().
        
 
-
        var names = 'Гарри Трамп ;Фрэд Барни; Хелен Ригби ; Билл Абель ;Крис Ханд ';
+
        var names = 'Гарри Трамп ;Фрэд Барни; Хелен Ригби ; Билл Абель ;Крис Ханд ';
 
 console.log(names);
 
@@ -97,7 +97,7 @@ console.log(nameList);
 
 
        Пример напечатает две строки; на первой строке напечатана оригинальная строчка, а на второй — получившийся массив.
        
 
-
        Гарри Трамп ;Фред Барни; Хелен Ригби ; Билл Абель ;Крис Ханд
+
        Гарри Трамп ;Фред Барни; Хелен Ригби ; Билл Абель ;Крис Ханд
 Гарри Трамп,Фред Барни,Хелен Ригби,Билл Абель,Крис Ханд
 
        
 
@@ -105,7 +105,7 @@ console.log(nameList);
 
 
        В следующем примере метод split() ищет 0 или более пробелов в строке и возвращает первые три найденных подстроки.
        
 
-
        var myString = 'Привет, мир. Как дела?';
+
        var myString = 'Привет, мир. Как дела?';
 var splits = myString.split(' ', 3);
 
 console.log(splits);
@@ -113,14 +113,14 @@ console.log(splits);
 
 
        Вывод скрипта будет следующим:
        
 
-
        Привет,,мир.,Как
+
        Привет,,мир.,Как
 
        
 
 
        Пример: захват подгрупп
        
 
 
        Если параметр separator содержит подгруппы, сопоставившиеся результаты также будут присутствовать в возвращённом массиве.
        
 
-
        var myString = 'Привет 1 мир. Предложение номер 2.';
+
        var myString = 'Привет 1 мир. Предложение номер 2.';
 var splits = myString.split(/(\d)/);
 
 console.log(splits);
@@ -128,12 +128,12 @@ console.log(splits);
 
 
        Вывод скрипта будет следующим:
        
 
-
        Привет ,1, мир. Предложение номер ,2,.
+
        Привет ,1, мир. Предложение номер ,2,.
 
        
 
 
        Пример: обращение строки при помощи метода split()
        
 
-
        var str = 'фывапролд';
+
        var str = 'фывапролд';
 var strReverse = str.split('').reverse().join(''); // 'длорпавыф'
 // split() возвращает массив, к которому применяются методы reverse() и join()
 
        
diff --git a/files/ru/web/javascript/reference/global_objects/string/startswith/index.html b/files/ru/web/javascript/reference/global_objects/string/startswith/index.html
index 25084d3d35..9601687858 100644
--- a/files/ru/web/javascript/reference/global_objects/string/startswith/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/startswith/index.html
@@ -18,7 +18,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith
 
 
        Синтаксис
        
 
-
        str.startsWith(searchString[, position])
        
+
        str.startsWith(searchString[, position])
        
 
 
        Параметры
        
 
@@ -37,7 +37,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith
 
 
        Пример: использование метода startsWith()
        
 
-
        var str = 'Быть или не быть, вот в чём вопрос.';
+
        var str = 'Быть или не быть, вот в чём вопрос.';
 
 console.log(str.startsWith('Быть'));        // true
 console.log(str.startsWith('не быть'));     // false
@@ -48,7 +48,7 @@ console.log(str.startsWith('не быть', 9));  // true
 
 
        Этот метод был добавлен к спецификации ECMAScript 6 и может быть доступен ещё не во всех реализациях JavaScript. Однако, вы можете легко эмулировать этот метод при помощи следующего кода:
        
 
-
        if (!String.prototype.startsWith) {
+
        if (!String.prototype.startsWith) {
   Object.defineProperty(String.prototype, 'startsWith', {
     enumerable: false,
     configurable: false,
diff --git a/files/ru/web/javascript/reference/global_objects/weakmap/index.html b/files/ru/web/javascript/reference/global_objects/weakmap/index.html
index 9b1f77b853..2ce67df673 100644
--- a/files/ru/web/javascript/reference/global_objects/weakmap/index.html
+++ b/files/ru/web/javascript/reference/global_objects/weakmap/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap
 
 
        Синтаксис
        
 
-
        new WeakMap([iterable])
+
        new WeakMap([iterable])
 
        
 
 
        Параметры
        
@@ -60,7 +60,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap
 
 
        Использование объекта WeakMap
        
 
-
        const wm1 = new WeakMap(),
+
        const wm1 = new WeakMap(),
     wm2 = new WeakMap(),
     wm3 = new WeakMap();
 const o1 = {},
@@ -92,7 +92,7 @@ wm1.has(o1);     // false
 
 
        Пример: Реализация класса WeakMap-like классов с методом .clear()
        
 
-
        class ClearableWeakMap {
+
        class ClearableWeakMap {
     constructor(init) {
         this._wm = new WeakMap(init)
     }
diff --git a/files/ru/web/javascript/reference/lexical_grammar/index.html b/files/ru/web/javascript/reference/lexical_grammar/index.html
index 64a70d311e..f70c017e14 100644
--- a/files/ru/web/javascript/reference/lexical_grammar/index.html
+++ b/files/ru/web/javascript/reference/lexical_grammar/index.html
@@ -166,7 +166,7 @@ ECMAScript также определяет ключевые слова и лит
 
 
        Первый способ // комментарий; в этом случае весь текст в строке после двойного слеша будет комментарием, например:
        
 
-
        function comment() {
+
        function comment() {
   // Это комментарий в строке
   console.log("Hello world!");
 }
@@ -177,7 +177,7 @@ comment();
 
 
        Например, вы можете использовать его в одной строке:
        
 
-
        function comment() {
+
        function comment() {
   /* Это однострочный комментарий */
   console.log("Hello world!");
 }
@@ -185,7 +185,7 @@ comment();
        
 
 
        Либо вы можете сделать многострочный комментарий, как показано здесь:
        
 
-
        function comment() {
+
        function comment() {
   /* Этот комментарий располагается на нескольких линиях.
      Обратите внимание, что вам не нужно обрывать комментарий, пока вы его не закончите*/
   console.log("Hello world!");
@@ -194,14 +194,14 @@ comment(); 
        
 
 
        Также, если пожелаете, то вы можете использовать такое комментирование посреди строки кода. Хотя это может ухудшить читабельность кода:
        
 
-
        function comment(x) {
+
        function comment(x) {
   console.log("Hello " + x /* вставьте значение x */ + " !");
 }
 comment("world");
        
 
 
        Чтобы отключить выполнение кода, просто оберните код в комментарий, как здесь:
        
 
-
        function comment() {
+
        function comment() {
   /* console.log("Hello world!"); */
 }
 comment();
        
@@ -216,7 +216,7 @@ comment();
        
 
 
        Шебанг комментарий определяет путь к  JavaScript интерпретатору, скрипт которого вы хотите выполнить. Пример, как это работает:
        
 
-
        #!/usr/bin/env node
+
        #!/usr/bin/env node
 
 console.log("Hello world");
 
        
@@ -329,14 +329,14 @@ console.log("Hello world");
 
 
        Зарезервированные слова действительно применяются только к идентификаторам (vs. IdentifierNames). Как описано в es5.github.com/#A.1, это все имена IdentifierNames, которые не исключают зарезервированных слов.
        
 
-
        a.import
+
        a.import
 a["import"]
 a = { import: "test" }.
 
        
 
 
        С другой стороны, следующее выражение неправильно, т.к. Идентификатор IdentifierName не содержит зарезервированных слов. Идентификаторы используются для FunctionDeclaration, FunctionExpression, VariableDeclaration и т.п., в то время, как IdentifierNames используются для  MemberExpression, CallExpression и т.п.
        
 
-
        function import() {} // неправильно.
        
+
        function import() {} // неправильно.
        
 
 
        Литералы
        
 
@@ -344,20 +344,20 @@ a = { import: "test" }.
 
 
        Подробнее о {{jsxref('Global_Objects/null','null')}}null.
        
 
-
        null
        
+
        null
        
 
 
        Литерал Boolean
        
 
 
        Подробнее о {{jsxref('Global_Objects/Boolean','Boolean')}}.
        
 
-
        true
+
        true
 false
        
 
 
        Литералы чисел
        
 
 
        Decimal (десятичные числа)
        
 
-
        1234567890
+
        1234567890
 42
 
 // Будьте осторожны с использованием нуля вначале числа:
@@ -372,7 +372,7 @@ false
        
 
 
        Синтаксис двоичных чисел состоит из цифры ноль, за которой следует маленькая или большая латинская буква "B" (0b или 0B). Этот синтаксис новый и появился только в ECMAScript 2015, пожалуйста посмотрите таблицу совместимости с браузерами. Это может производить ошибку {{jsxref('Global_Objects/SyntaxError','SyntaxError')}}: "Missing binary digits after 0b", Если цифры не 0 или 1.
        
 
-
        var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
+
        var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
 var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
 var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607
        
 
@@ -380,7 +380,7 @@ var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607
        
 
 
        Восьмеричный числовой синтаксис, который использует 0 с последующей, в нижнем или верхнем регистре, латинскую букву "О" (0o или 0O). Этот синтаксис появился в ECMAScript 2015, пожалуйста, посмотрите таблицу совместимости с браузерами. Это может производить ошибку SyntaxError: "Missing octal digits after 0o", если цифры не между 0 и 7.
        
 
-
        var n = 0O755; // 493
+
        var n = 0O755; // 493
 var m = 0o644; // 420
 
 // Так же возможно с лидирующими нулями (см. заметку о десятичных дробях выше)
@@ -392,7 +392,7 @@ var m = 0o644; // 420
 
 
        Шестнадцатеричный числовой синтаксис, который использует 0 с последующей, в нижнем или верхнем регистре, латинскую букву "X" (0x или 0X). Если числа после 0x вне диапазона (0123456789ABCDEF), то может последовать за этим {{jsxref("SyntaxError")}}: "Identifier starts immediately after numeric literal".
        
 
-
        0xFFFFFFFFFFFFFFFFF // 295147905179352830000
+
        0xFFFFFFFFFFFFFFFFF // 295147905179352830000
 0x123456789ABCDEF   // 81985529216486900
 0XA                 // 10
 
        
@@ -401,7 +401,7 @@ var m = 0o644; // 420
 
 
        Смотрите также {{jsxref("Object")}} и {{jsxref('Operators/Object_initializer','Object initializer')}} для получения более подробной информации.
        
 
-
        var o = { a: "foo", b: "bar", c: 42 };
+
        var o = { a: "foo", b: "bar", c: 42 };
 
 // сокращённая нотация. Появилась в ES2015
 var a = "foo", b = "bar", c = 42;
@@ -414,23 +414,23 @@ var o = { a: a, b: b, c: c };
 
 
        Смотрите также {{jsxref("Array")}} для получения более подробной информации.
        
 
-
        [1954, 1974, 1990, 2014]
        
+
        [1954, 1974, 1990, 2014]
        
 
 
        Литерал String (Строка)
        
 
-
        'foo'
+
        'foo'
 "bar"
        
 
 
        Экранирование шестнадцатеричной последовательности
        
 
-
        '\xA9' // "©"
+
        '\xA9' // "©"
 
        
 
 
        Экранирование Юникод символов
        
 
 
        Для экранирования Юникод символов обязательно нужно указать по крайней мере 4 символа после \u.
        
 
-
        '\u00A9' // "©"
        
+
        '\u00A9' // "©"
        
 
 
        Unicode code point escapes
        
 
@@ -438,7 +438,7 @@ var o = { a: a, b: b, c: c };
 
 
        See also {{jsxref("String.fromCodePoint()")}} or {{jsxref("String.prototype.codePointAt()")}}.
        
 
-
        '\u{2F804}'
+
        '\u{2F804}'
 
 // the same with simple Unicode escapes
 '\uD87E\uDC04'
        
@@ -447,7 +447,7 @@ var o = { a: a, b: b, c: c };
 
 
        Смотрите также {{jsxref('Global_Objects/RegExp','RegExp')}} для получения более подробной информации.
        
 
-
        /ab+c/g
+
        /ab+c/g
 
 // An "empty" regular expression literal
 // The empty non-capturing group is necessary
@@ -458,7 +458,7 @@ var o = { a: a, b: b, c: c };
 
 
        Смотрите также {{jsxref('template_strings','template strings')}} для получения более подробной информации.
        
 
-
        `string text`
+
        `string text`
 
 `string text line 1
  string text line 2`
@@ -485,7 +485,7 @@ tag `string text ${expression} string text`
        
 
 
        1. Точка с запятой ставится до, когда ограничитель строки или "}" is encountered that is not allowed by the grammar.
        
 
-
        { 1 2 } 3
+
        { 1 2 } 3
 
 // согласно ASI, будет преобразовано в
 
@@ -495,7 +495,7 @@ tag `string text ${expression} string text`
        
 
 
        Here ++ is not treated as a {{jsxref('Operators/Arithmetic_Operators','postfix operator','Increment')}} applying to variable b, because a line terminator occurs between b and ++.
        
 
-
        a = b
+
        a = b
 ++c
 
 // согласно ASI, будет преобразовано в
@@ -515,7 +515,7 @@ a = b;
  
      • module
        • 
 
      
 
-
      return
+
      return
 a + b
 
 // согласно ASI, будет преобразовано в
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
   *[];
 }
        
diff --git a/files/ru/web/javascript/reference/statements/async_function/index.html b/files/ru/web/javascript/reference/statements/async_function/index.html
index 7e07f940cf..d46b1039e3 100644
--- a/files/ru/web/javascript/reference/statements/async_function/index.html
+++ b/files/ru/web/javascript/reference/statements/async_function/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Statements/async_function
 
 
        Синтаксис
        
 
-
        async function name([param[, param[, ... param]]]) {
+
        async function name([param[, param[, ... param]]]) {
    statements
 }
 
        
@@ -49,7 +49,7 @@ translation_of: Web/JavaScript/Reference/Statements/async_function
 
 
        Простой пример
        
 
-
        function resolveAfter2Seconds(x) {
+
        function resolveAfter2Seconds(x) {
   return new Promise(resolve => {
     setTimeout(() => {
       resolve(x);
@@ -86,7 +86,7 @@ add2(10).then(v => {
 
 
        Когда функция async выбрасывает исключение
        
 
-
        async function throwsValue() {
+
        async function throwsValue() {
     throw new Error('oops');
 }
 throwsValue()
@@ -112,7 +112,7 @@ throwsValue()
 
 
        API, которое возвращает {{jsxref("Promise")}}, будет возвращать значение в цепочке, тем самым разбивая функцию на много частей. Рассматривая следующий код:
        
 
-
        function getProcessedData(url) {
+
        function getProcessedData(url) {
   return downloadData(url) // returns a promise
     .catch(e => {
       return downloadFallbackData(url) // returns a promise
@@ -125,7 +125,7 @@ throwsValue()
 
 
        он может быть переписан с одним использованием функции async:
        
 
-
        async function getProcessedData(url) {
+
        async function getProcessedData(url) {
   let v;
   try {
     v = await downloadData(url);
diff --git a/files/ru/web/javascript/reference/statements/class/index.html b/files/ru/web/javascript/reference/statements/class/index.html
index f2caebe0fe..e0c1dbd9f2 100644
--- a/files/ru/web/javascript/reference/statements/class/index.html
+++ b/files/ru/web/javascript/reference/statements/class/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Statements/class
 
 
        Синтаксис
        
 
-
        class name [extends] {
+
        class name [extends] {
   // тело класса
 }
 
        
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Statements/class
 
 
        В следующем примере сначала определяется класс с именем Polygon, затем он наследуется для создания класса Square. Заметьте, что super(), используемый в конструкторе, может быть использован только в конструкторе и должен быть вызван до того, как будет использовано ключевое слово this.
        
 
-
        class Polygon {
+
        class Polygon {
   constructor(height, width) {
     this.name = 'Polygon';
     this.height = height;
@@ -50,13 +50,13 @@ class Square extends Polygon {
 
 
        Переопределение класса с помощью class declaration вызовет ошибку типа.
        
 
-
        class Foo {};
+
        class Foo {};
 class Foo {}; // Uncaught TypeError: Identifier 'Foo' has already been declared
 
        
 
 
        Та же ошибка будет вызвана, если класс был определён перед использованием class declaration.
        
 
-
        var Foo = class {};
+
        var Foo = class {};
 class Foo {}; // Uncaught TypeError: Identifier 'Foo' has already been declared
 
 
        
diff --git a/files/ru/web/javascript/reference/statements/for...of/index.html b/files/ru/web/javascript/reference/statements/for...of/index.html
index 5d056de8c4..7641d14bad 100644
--- a/files/ru/web/javascript/reference/statements/for...of/index.html
+++ b/files/ru/web/javascript/reference/statements/for...of/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Statements/for...of
 
 
        Синтаксис
        
 
-
        for (variable of iterable) {
+
        for (variable of iterable) {
   statement
 }
 
        
@@ -32,7 +32,7 @@ translation_of: Web/JavaScript/Reference/Statements/for...of
 
 
        Обход {{jsxref("Array")}}
        
 
-
        let iterable = [10, 20, 30];
+
        let iterable = [10, 20, 30];
 
 for (let value of iterable) {
   value += 1;
@@ -44,7 +44,7 @@ for (let value of iterable) {
 
 
        Можно также использовать const вместо let, если не нужно переназначать переменные внутри блока.
        
 
-
        let iterable = [10, 20, 30];
+
        let iterable = [10, 20, 30];
 
 for (const value of iterable) {
   console.log(value);
@@ -55,7 +55,7 @@ for (const value of iterable) {
 
 
        Обход {{jsxref("String")}}
        
 
-
        let iterable = 'boo';
+
        let iterable = 'boo';
 
 for (let value of iterable) {
   console.log(value);
@@ -66,7 +66,7 @@ for (let value of iterable) {
 
 
        Обход {{jsxref("TypedArray")}}
        
 
-
        let iterable = new Uint8Array([0x00, 0xff]);
+
        let iterable = new Uint8Array([0x00, 0xff]);
 
 for (let value of iterable) {
   console.log(value);
@@ -76,7 +76,7 @@ for (let value of iterable) {
 
 
        Обход {{jsxref("Map")}}
        
 
-
        let iterable = new Map([['a', 1], ['b', 2], ['c', 3]]);
+
        let iterable = new Map([['a', 1], ['b', 2], ['c', 3]]);
 
 for (let entry of iterable) {
   console.log(entry);
@@ -94,7 +94,7 @@ for (let [key, value] of iterable) {
 
 
        Обход {{jsxref("Set")}}
        
 
-
        let iterable = new Set([1, 1, 2, 2, 3, 3]);
+
        let iterable = new Set([1, 1, 2, 2, 3, 3]);
 
 for (let value of iterable) {
   console.log(value);
@@ -105,7 +105,7 @@ for (let value of iterable) {
 
 
        Обход объекта {{jsxref("arguments")}} 
        
 
-
        (function() {
+
        (function() {
   for (let argument of arguments) {
     console.log(argument);
   }
@@ -119,7 +119,7 @@ for (let value of iterable) {
 
 
        Обход DOM коллекций наподобие {{domxref("NodeList")}}: следующий пример добавляет класс read параграфам, являющимся непосредственными потомками статей:
        
 
-
        // Примечание: работает только на платформах, где
+
        // Примечание: работает только на платформах, где
 // реализован NodeList.prototype[Symbol.iterator]
 let articleParagraphs = document.querySelectorAll('article > p');
 
@@ -131,7 +131,7 @@ for (let paragraph of articleParagraphs) {
 
 
        В циклах for...of  аварийный выход осуществляется через break, throw или return. Во всех вариантах итератор завершается.
        
 
-
        function* foo(){
+
        function* foo(){
   yield 1;
   yield 2;
   yield 3;
@@ -147,7 +147,7 @@ for (let o of foo()) {
 
 
        Вы можете выполнять обход генераторов, вот пример:
        
 
-
        function* fibonacci() { // функция-генератор
+
        function* fibonacci() { // функция-генератор
     let [prev, curr] = [0, 1];
     for (;;) {
         [prev, curr] = [curr, prev + curr];
@@ -167,7 +167,7 @@ for (let n of fibonacci()) {
 
 
        Генераторы нельзя использовать дважды, даже если цикл for...of  завершится аварийно, например, через оператор {{jsxref("Statements/break", "break")}} . При выходе из цикла генератор завершается, и любые попытки получить из него значение обречены.
        
 
-
        var gen = (function *(){
+
        var gen = (function *(){
   yield 1;
   yield 2;
   yield 3;
@@ -186,7 +186,7 @@ for (let o of gen) {
 
 
        Кроме того, можно сделать обход объекта, явно реализующего iterable:
        
 
-
        var iterable = {
+
        var iterable = {
   [Symbol.iterator]() {
     return {
       i: 0,
@@ -217,7 +217,7 @@ for (var value of iterable) {
 
 
        Следующий пример показывает различия в работе циклов for...of и for...in при обходе {{jsxref("Array")}}.
        
 
-
        Object.prototype.objCustom = function() {};
+
        Object.prototype.objCustom = function() {};
 Array.prototype.arrCustom = function() {};
 
 let iterable = [3, 5, 7];
@@ -239,7 +239,7 @@ for (let i of iterable) {
 
 
        Разберёмся шаг за шагом в вышеописанном коде.
        
 
-
        Object.prototype.objCustom = function() {};
+
        Object.prototype.objCustom = function() {};
 Array.prototype.arrCustom = function() {};
 
 let iterable = [3, 5, 7];
@@ -247,13 +247,13 @@ iterable.foo = 'hello';
        
 
 
        Каждый объект унаследует метод objCustom и каждый массив {{jsxref("Array")}} унаследует метод arrCustom благодаря созданию их в {{jsxref("Object.prototype")}} и {{jsxref("Array.prototype")}}. Объект iterable унаследует методы objCustom и arrCustom из-за наследования через прототип.
        
 
-
        for (let i in iterable) {
+
        for (let i in iterable) {
   console.log(i); // выведет 0, 1, 2, "foo", "arrCustom", "objCustom"
 }
        
 
 
        Цикл выводит только перечисляемые свойства объекта iterable, в порядке их создания. Он не выводит значения 3, 5, 7 и hello поскольку они не являются перечисляемыми, фактически они вообще не являются свойствами, они являются значениями. Выводятся же имена свойств и методов, например arrCustom и objCustom. Если вы ещё не совсем поняли, по каким свойствам осуществляется обход, вот дополнительное объяснение того, как работает {{jsxref("Statements/for...in", "array iteration and for...in", "#Array_iteration_and_for...in")}} .
        
 
-
        for (let i in iterable) {
+
        for (let i in iterable) {
   if (iterable.hasOwnProperty(i)) {
     console.log(i); // выведет 0, 1, 2, "foo"
   }
@@ -261,7 +261,7 @@ iterable.foo = 'hello';
        
 
 
        Цикл аналогичен предыдущему, но использует {{jsxref("Object.prototype.hasOwnProperty()", "hasOwnProperty()")}} для проверки того, собственное ли это свойство объекта или унаследованное. Выводятся только собственные свойства. Имена 0, 1, 2 и foo принадлежат только экземпляру объекта (не унаследованы). Методы arrCustom и objCustom не выводятся, поскольку они унаследованы.
        
 
-
        for (let i of iterable) {
+
        for (let i of iterable) {
   console.log(i); // выведет 3, 5, 7
 }
        
 
-- 
cgit v1.2.3-54-g00ecf