diff --git a/files/ru/web/javascript/closures/index.md b/files/ru/web/javascript/closures/index.md
index 1add873b952b71..2bd9cdac70c4d7 100644
--- a/files/ru/web/javascript/closures/index.md
+++ b/files/ru/web/javascript/closures/index.md
@@ -6,6 +6,7 @@ tags:
- Замыкание
translation_of: Web/JavaScript/Closures
---
+
{{jsSidebar("Intermediate")}}
Замыкание — это комбинация функции и лексического окружения, в котором эта функция была определена. Другими словами, замыкание даёт вам доступ к [Scope](/ru/docs/Glossary/Scope) внешней функции из внутренней функции. В JavaScript замыкания создаются каждый раз при создании функции, во время её создания.
@@ -16,11 +17,12 @@ translation_of: Web/JavaScript/Closures
```js
function init() {
- var name = "Mozilla"; // name - локальная переменная, созданная в init
- function displayName() { // displayName() - внутренняя функция, замыкание
- alert (name); // displayName() использует переменную, объявленную в родительской функции
- }
- displayName();
+ var name = "Mozilla"; // name - локальная переменная, созданная в init
+ function displayName() {
+ // displayName() - внутренняя функция, замыкание
+ alert(name); // displayName() использует переменную, объявленную в родительской функции
+ }
+ displayName();
}
init();
```
@@ -44,7 +46,7 @@ function makeFunc() {
}
return displayName;
-};
+}
var myFunc = makeFunc();
myFunc();
@@ -60,15 +62,15 @@ myFunc();
```js
function makeAdder(x) {
- return function(y) {
+ return function (y) {
return x + y;
};
-};
+}
var add5 = makeAdder(5);
var add10 = makeAdder(10);
-console.log(add5(2)); // 7
+console.log(add5(2)); // 7
console.log(add10(2)); // 12
```
@@ -109,10 +111,10 @@ h2 {
```js
function makeSizer(size) {
- return function() {
- document.body.style.fontSize = size + 'px';
+ return function () {
+ document.body.style.fontSize = size + "px";
};
-};
+}
var size12 = makeSizer(12);
var size14 = makeSizer(14);
@@ -122,9 +124,9 @@ var size16 = makeSizer(16);
Теперь `size12`, `size14`, и `size16` - это функции, которые меняют размер текста в элементе body на значения 12, 14, и 16 пикселов, соответственно. После чего мы цепляем эти функции на кнопки примерно так:
```js
-document.getElementById('size-12').onclick = size12;
-document.getElementById('size-14').onclick = size14;
-document.getElementById('size-16').onclick = size16;
+document.getElementById("size-12").onclick = size12;
+document.getElementById("size-14").onclick = size14;
+document.getElementById("size-16").onclick = size16;
```
```html
@@ -144,7 +146,7 @@ JavaScript не имеет встроенной возможности сдел
Код ниже иллюстрирует, как можно использовать замыкания для определения публичных функций, которые имеют доступ к закрытым от пользователя (private) функциям и переменным. Такая манера программирования называется [модульное программирование](http://www.google.com/search?q=javascript+module+pattern):
```js
-var Counter = (function() {
+var Counter = (function () {
var privateCounter = 0;
function changeBy(val) {
@@ -152,15 +154,15 @@ var Counter = (function() {
}
return {
- increment: function() {
+ increment: function () {
changeBy(1);
},
- decrement: function() {
+ decrement: function () {
changeBy(-1);
},
- value: function() {
+ value: function () {
return privateCounter;
- }
+ },
};
})();
@@ -185,7 +187,7 @@ alert(Counter.value()); /* Alerts 1 */
Заметьте, мы описываем анонимную функцию, создающую счётчик, и тут же запускаем её, присваивая результат исполнения переменной `Counter`. Но мы также можем не запускать эту функцию сразу, а сохранить её в отдельной переменной, чтобы использовать для дальнейшего создания нескольких счётчиков вот так:
```js
-var makeCounter = function() {
+var makeCounter = function () {
var privateCounter = 0;
function changeBy(val) {
@@ -193,16 +195,16 @@ var makeCounter = function() {
}
return {
- increment: function() {
+ increment: function () {
changeBy(1);
},
- decrement: function() {
+ decrement: function () {
changeBy(-1);
},
- value: function() {
+ value: function () {
return privateCounter;
- }
- }
+ },
+ };
};
var Counter1 = makeCounter();
@@ -231,28 +233,28 @@ alert(Counter2.value()); /* Alerts 0 */
```html
Helpful notes will appear here
-E-mail:
-Name:
-Age:
+E-mail:
+Name:
+Age:
```
```js
function showHelp(help) {
- document.getElementById('help').innerHTML = help;
+ document.getElementById("help").innerHTML = help;
}
function setupHelp() {
var helpText = [
- {'id': 'email', 'help': 'Ваш адрес e-mail'},
- {'id': 'name', 'help': 'Ваше полное имя'},
- {'id': 'age', 'help': 'Ваш возраст (Вам должно быть больше 16)'}
- ];
+ { id: "email", help: "Ваш адрес e-mail" },
+ { id: "name", help: "Ваше полное имя" },
+ { id: "age", help: "Ваш возраст (Вам должно быть больше 16)" },
+ ];
for (var i = 0; i < helpText.length; i++) {
var item = helpText[i];
- document.getElementById(item.id).onfocus = function() {
+ document.getElementById(item.id).onfocus = function () {
showHelp(item.help);
- }
+ };
}
}
@@ -271,21 +273,21 @@ setupHelp();
```js
function showHelp(help) {
- document.getElementById('help').innerHTML = help;
+ document.getElementById("help").innerHTML = help;
}
function makeHelpCallback(help) {
- return function() {
+ return function () {
showHelp(help);
};
}
function setupHelp() {
var helpText = [
- {'id': 'email', 'help': 'Ваш адрес e-mail'},
- {'id': 'name', 'help': 'Ваше полное имя'},
- {'id': 'age', 'help': 'Ваш возраст (Вам должно быть больше 16)'}
- ];
+ { id: "email", help: "Ваш адрес e-mail" },
+ { id: "name", help: "Ваше полное имя" },
+ { id: "age", help: "Ваш возраст (Вам должно быть больше 16)" },
+ ];
for (var i = 0; i < helpText.length; i++) {
var item = helpText[i];
@@ -313,11 +315,11 @@ function MyObject(name, message) {
this.name = name.toString();
this.message = message.toString();
- this.getName = function() {
+ this.getName = function () {
return this.name;
};
- this.getMessage = function() {
+ this.getMessage = function () {
return this.message;
};
}
@@ -332,12 +334,12 @@ function MyObject(name, message) {
}
MyObject.prototype = {
- getName: function() {
+ getName: function () {
return this.name;
},
- getMessage: function() {
+ getMessage: function () {
return this.message;
- }
+ },
};
```
@@ -349,11 +351,11 @@ function MyObject(name, message) {
this.message = message.toString();
}
-MyObject.prototype.getName = function() {
+MyObject.prototype.getName = function () {
return this.name;
};
-MyObject.prototype.getMessage = function() {
+MyObject.prototype.getMessage = function () {
return this.message;
};
```
@@ -366,12 +368,12 @@ function MyObject(name, message) {
this.message = message.toString();
}
-(function() {
- this.getName = function() {
+(function () {
+ this.getName = function () {
return this.name;
};
- this.getMessage = function() {
+ this.getMessage = function () {
return this.message;
};
}).call(MyObject.prototype);
diff --git a/files/ru/web/javascript/data_structures/index.md b/files/ru/web/javascript/data_structures/index.md
index 3d1acddbd2e47a..a422663227b586 100644
--- a/files/ru/web/javascript/data_structures/index.md
+++ b/files/ru/web/javascript/data_structures/index.md
@@ -7,6 +7,7 @@ tags:
- Учебник
translation_of: Web/JavaScript/Data_structures
---
+
{{jsSidebar("More")}}
Все языки программирования содержат встроенные типы данных, но они часто отличаются друг от друга в разных языках. Эта статья — попытка описать встроенные структуры (типы) данных, доступные в JavaScript, и их свойства. На их основе строятся другие структуры данных. Когда это возможно, то мы будем сравнивать типы данных в разных языках.
@@ -18,7 +19,7 @@ JavaScript является _слабо типизированным_ или _д
```js
var foo = 42; // сейчас foo типа Number
foo = "bar"; // а теперь foo типа String
-foo = true; // foo становится типа Boolean
+foo = true; // foo становится типа Boolean
```
## Типы данных
diff --git a/files/ru/web/javascript/enumerability_and_ownership_of_properties/index.md b/files/ru/web/javascript/enumerability_and_ownership_of_properties/index.md
index 3e375c9a0ecc69..cf0dc0f59fb2ea 100644
--- a/files/ru/web/javascript/enumerability_and_ownership_of_properties/index.md
+++ b/files/ru/web/javascript/enumerability_and_ownership_of_properties/index.md
@@ -223,66 +223,86 @@ translation_of: Web/JavaScript/Enumerability_and_ownership_of_properties
```js
var SimplePropertyRetriever = {
- getOwnEnumerables: function (obj) {
- return this._getPropertyNames(obj, true, false, this._enumerable);
- // Или можно использовать for..in, отфильтрованный по hasOwnProperty или проще: return Object.keys(obj);
- },
- getOwnNonenumerables: function (obj) {
- return this._getPropertyNames(obj, true, false, this._notEnumerable);
- },
- getOwnEnumerablesAndNonenumerables: function (obj) {
- return this._getPropertyNames(obj, true, false, this._enumerableAndNotEnumerable);
- // Или можно использовать: return Object.getOwnPropertyNames(obj);
- },
- getPrototypeEnumerables: function (obj) {
- return this._getPropertyNames(obj, false, true, this._enumerable);
- },
- getPrototypeNonenumerables: function (obj) {
- return this._getPropertyNames(obj, false, true, this._notEnumerable);
- },
- getPrototypeEnumerablesAndNonenumerables: function (obj) {
- return this._getPropertyNames(obj, false, true, this._enumerableAndNotEnumerable);
- },
- getOwnAndPrototypeEnumerables: function (obj) {
- return this._getPropertyNames(obj, true, true, this._enumerable);
- // Или можно использовать for..in
- },
- getOwnAndPrototypeNonenumerables: function (obj) {
- return this._getPropertyNames(obj, true, true, this._notEnumerable);
- },
- getOwnAndPrototypeEnumerablesAndNonenumerables: function (obj) {
- return this._getPropertyNames(obj, true, true, this._enumerableAndNotEnumerable);
- },
- // Private static property checker callbacks
- _enumerable : function (obj, prop) {
- return obj.propertyIsEnumerable(prop);
- },
- _notEnumerable : function (obj, prop) {
- return !obj.propertyIsEnumerable(prop);
- },
- _enumerableAndNotEnumerable : function (obj, prop) {
- return true;
- },
- // По мотивам http://stackoverflow.com/a/8024294/271577
- _getPropertyNames : function getAllPropertyNames(obj, iterateSelfBool, iteratePrototypeBool, includePropCb) {
- var props = [];
+ getOwnEnumerables: function (obj) {
+ return this._getPropertyNames(obj, true, false, this._enumerable);
+ // Или можно использовать for..in, отфильтрованный по hasOwnProperty или проще: return Object.keys(obj);
+ },
+ getOwnNonenumerables: function (obj) {
+ return this._getPropertyNames(obj, true, false, this._notEnumerable);
+ },
+ getOwnEnumerablesAndNonenumerables: function (obj) {
+ return this._getPropertyNames(
+ obj,
+ true,
+ false,
+ this._enumerableAndNotEnumerable,
+ );
+ // Или можно использовать: return Object.getOwnPropertyNames(obj);
+ },
+ getPrototypeEnumerables: function (obj) {
+ return this._getPropertyNames(obj, false, true, this._enumerable);
+ },
+ getPrototypeNonenumerables: function (obj) {
+ return this._getPropertyNames(obj, false, true, this._notEnumerable);
+ },
+ getPrototypeEnumerablesAndNonenumerables: function (obj) {
+ return this._getPropertyNames(
+ obj,
+ false,
+ true,
+ this._enumerableAndNotEnumerable,
+ );
+ },
+ getOwnAndPrototypeEnumerables: function (obj) {
+ return this._getPropertyNames(obj, true, true, this._enumerable);
+ // Или можно использовать for..in
+ },
+ getOwnAndPrototypeNonenumerables: function (obj) {
+ return this._getPropertyNames(obj, true, true, this._notEnumerable);
+ },
+ getOwnAndPrototypeEnumerablesAndNonenumerables: function (obj) {
+ return this._getPropertyNames(
+ obj,
+ true,
+ true,
+ this._enumerableAndNotEnumerable,
+ );
+ },
+ // Private static property checker callbacks
+ _enumerable: function (obj, prop) {
+ return obj.propertyIsEnumerable(prop);
+ },
+ _notEnumerable: function (obj, prop) {
+ return !obj.propertyIsEnumerable(prop);
+ },
+ _enumerableAndNotEnumerable: function (obj, prop) {
+ return true;
+ },
+ // По мотивам http://stackoverflow.com/a/8024294/271577
+ _getPropertyNames: function getAllPropertyNames(
+ obj,
+ iterateSelfBool,
+ iteratePrototypeBool,
+ includePropCb,
+ ) {
+ var props = [];
- do {
- if (iterateSelfBool) {
- Object.getOwnPropertyNames(obj).forEach(function (prop) {
- if (props.indexOf(prop) === -1 && includePropCb(obj, prop)) {
- props.push(prop);
- }
- });
- }
- if (!iteratePrototypeBool) {
- break;
- }
- iterateSelfBool = true;
- } while (obj = Object.getPrototypeOf(obj));
+ do {
+ if (iterateSelfBool) {
+ Object.getOwnPropertyNames(obj).forEach(function (prop) {
+ if (props.indexOf(prop) === -1 && includePropCb(obj, prop)) {
+ props.push(prop);
+ }
+ });
+ }
+ if (!iteratePrototypeBool) {
+ break;
+ }
+ iterateSelfBool = true;
+ } while ((obj = Object.getPrototypeOf(obj)));
- return props;
- }
+ return props;
+ },
};
```
diff --git a/files/ru/web/javascript/event_loop/index.md b/files/ru/web/javascript/event_loop/index.md
index 97f7d9dd94e307..a3335c69de3daf 100644
--- a/files/ru/web/javascript/event_loop/index.md
+++ b/files/ru/web/javascript/event_loop/index.md
@@ -58,7 +58,7 @@ g(21);
Модель событийного цикла (`event loop`) называется так потому, что отслеживает новые события в цикле:
```js
-while(queue.waitForMessage()){
+while (queue.waitForMessage()) {
queue.processNextMessage();
}
```
@@ -83,21 +83,19 @@ while(queue.waitForMessage()){
```js
(function () {
-
- console.log('this is the start');
+ console.log("this is the start");
setTimeout(function cb() {
- console.log('this is a msg from call back');
+ console.log("this is a msg from call back");
});
- console.log('this is just a message');
+ console.log("this is just a message");
setTimeout(function cb1() {
- console.log('this is a msg from call back1');
+ console.log("this is a msg from call back1");
}, 0);
- console.log('this is the end');
-
+ console.log("this is the end");
})();
// "this is the start"
diff --git a/files/ru/web/javascript/guide/control_flow_and_error_handling/index.md b/files/ru/web/javascript/guide/control_flow_and_error_handling/index.md
index 1de66ae7df4e18..b83faae516ca62 100644
--- a/files/ru/web/javascript/guide/control_flow_and_error_handling/index.md
+++ b/files/ru/web/javascript/guide/control_flow_and_error_handling/index.md
@@ -26,7 +26,9 @@ JavaScript поддерживает компактный набор инстру
Блок обычно используется с управляющими инструкциями (например, `if`, `for`, `while`).
```js
-while (x < 10) { x++; }
+while (x < 10) {
+ x++;
+}
```
В вышеприведённом примере `{ x++; }` является блоком.
@@ -55,9 +57,9 @@ console.log(x); // выведет 2
```js
if (condition) {
- statement_1;
+ statement_1;
} else {
- statement_2;
+ statement_2;
}
```
@@ -83,14 +85,18 @@ if (condition) {
Нежелательно использовать простые присваивания в условном выражении, т.к. присваивание может быть спутано с равенством при быстром просмотре кода. Например, не используйте следующий код:
-```js
-if (x = y) { /* ... */ }
+```js-nolint example-bad
+if (x = y) {
+ /* ... */
+}
```
Если вам нужно использовать присваивание в условном выражении, то распространённой практикой является заключение операции присваивания в дополнительные скобки. Например:
-```js
-if ( (x = y) ) { /* ... */ }
+```js example-good
+if ((x = y)) {
+ /* ... */
+}
```
#### Ложные значения
@@ -121,8 +127,11 @@ function checkData() {
if (document.form1.threeChar.value.length == 3) {
return true;
} else {
- alert("Enter exactly three characters. " +
- document.form1.threeChar.value + " is not valid.");
+ alert(
+ "Enter exactly three characters. " +
+ document.form1.threeChar.value +
+ " is not valid.",
+ );
return false;
}
}
@@ -174,7 +183,7 @@ switch (fruittype) {
console.log("Mangoes and papayas are $2.79 a pound.");
break;
default:
- console.log("Sorry, we are out of " + fruittype + ".");
+ console.log("Sorry, we are out of " + fruittype + ".");
}
console.log("Is there anything else you'd like?");
```
@@ -201,10 +210,14 @@ throw expression;
Вы можете выбросить любое выражение, а не только выражения определённого типа. В следующем примере выбрасываются исключения различных типов:
```js
-throw "Error2"; // string
-throw 42; // number
-throw true; // boolean
-throw { toString: function() { return "I'm an object!"; } }; // object
+throw "Error2"; // string
+throw 42; // number
+throw true; // boolean
+throw {
+ toString: function () {
+ return "I'm an object!";
+ },
+}; // object
```
> **Примечание:** Вы можете выбросить объект как исключение. Вы можете обращаться к свойствам данного объекта в блоке `catch`.
@@ -212,14 +225,14 @@ throw { toString: function() { return "I'm an object!"; } }; // object
> **Примечание:** В следующем примере объект `UserException` выбрасывается как исключение:
```js
-function UserException (message) {
+function UserException(message) {
this.message = message;
this.name = "UserException";
}
UserException.prototype.toString = function () {
return this.name + ': "' + this.message + '"';
-}
+};
throw new UserException("Value too high");
```
@@ -233,8 +246,20 @@ throw new UserException("Value too high");
```js
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"];
+ var months = [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "May",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Oct",
+ "Nov",
+ "Dec",
+ ];
if (months[mo]) {
return months[mo];
} else {
@@ -242,10 +267,10 @@ function getMonthName(mo) {
}
}
-try { // statements to try
+try {
+ // statements to try
monthName = getMonthName(myMonth); // function could throw exception
-}
-catch (e) {
+} catch (e) {
monthName = "unknown";
logMyErrors(e); // pass exception object to error handler -> your own
}
@@ -265,7 +290,7 @@ JavaScript создаёт идентификатор `catchID`, которому
```js
try {
- throw "myException"
+ throw "myException";
} catch (e) {
console.error(e);
}
@@ -281,7 +306,7 @@ try {
openMyFile();
try {
writeMyFile(theData);
-} catch(e) {
+} catch (e) {
handleError(e);
} finally {
closeMyFile();
@@ -295,19 +320,19 @@ function f() {
try {
console.log(0);
throw "bogus";
- } catch(e) {
+ } catch (e) {
console.log(1);
- return true; // приостанавливается до завершения блока `finally`
+ return true; // приостанавливается до завершения блока `finally`
console.log(2); // не выполняется
} finally {
console.log(3);
- return false; // заменяет предыдущий `return`
+ return false; // заменяет предыдущий `return`
console.log(4); // не выполняется
}
// `return false` выполняется сейчас
- console.log(5); // не выполняется
+ console.log(5); // не выполняется
}
-f(); // отображает 0, 1, 3 и возвращает `false`
+f(); // отображает 0, 1, 3 и возвращает `false`
```
Замена возвращаемых значений блоком `finally` распространяется в том числе и на исключения, которые выбрасываются или перевыбрасываются в блоке `catch`:
@@ -316,9 +341,9 @@ f(); // отображает 0, 1, 3 и возвращает `fals
function f() {
try {
throw "bogus";
- } catch(e) {
+ } catch (e) {
console.log('caught inner "bogus"');
- throw e; // приостанавливается до завершения блока `finally`
+ throw e; // приостанавливается до завершения блока `finally`
} finally {
return false; // заменяет предыдущий `throw`
}
@@ -327,7 +352,7 @@ function f() {
try {
f();
-} catch(e) {
+} catch (e) {
// Не выполняется, т.к. `throw` в `catch `заменяется на `return` в `finally`
console.log('caught outer "bogus"');
}
@@ -347,9 +372,9 @@ try {
Если вы выбрасываете собственные исключения, то чтобы получить преимущество, которое предоставляют эти свойства (например, если ваш блок `catch` не делает различий между вашими исключениями и системными), используйте конструктор `Error`. Например:
```js
-function doSomethingErrorProne () {
- if ( ourCodeMakesAMistake() ) {
- throw ( new Error('The message') );
+function doSomethingErrorProne() {
+ if (ourCodeMakesAMistake()) {
+ throw new Error("The message");
} else {
doSomethingToGetAJavascriptError();
}
@@ -358,7 +383,7 @@ function doSomethingErrorProne () {
try {
doSomethingErrorProne();
} catch (e) {
- console.log(e.name); // 'Error'
+ console.log(e.name); // 'Error'
console.log(e.message); // 'The message' или JavaScript error message
}
```
@@ -382,20 +407,23 @@ try {
```js
function imgLoad(url) {
- return new Promise(function(resolve, reject) {
+ return new Promise(function (resolve, reject) {
var request = new XMLHttpRequest();
- request.open('GET', url);
- request.responseType = 'blob';
- request.onload = function() {
+ request.open("GET", url);
+ request.responseType = "blob";
+ request.onload = function () {
if (request.status === 200) {
resolve(request.response);
} else {
- reject(Error('Image didn\'t load successfully; error code:'
- + request.statusText));
+ reject(
+ Error(
+ "Image didn't load successfully; error code:" + request.statusText,
+ ),
+ );
}
};
- request.onerror = function() {
- reject(Error('There was a network error.'));
+ request.onerror = function () {
+ reject(Error("There was a network error."));
};
request.send();
});
diff --git a/files/ru/web/javascript/guide/expressions_and_operators/index.md b/files/ru/web/javascript/guide/expressions_and_operators/index.md
index 031c3062aa5f75..08ac4b1987c1f1 100644
--- a/files/ru/web/javascript/guide/expressions_and_operators/index.md
+++ b/files/ru/web/javascript/guide/expressions_and_operators/index.md
@@ -23,10 +23,10 @@ translation_of: Web/JavaScript/Guide/Expressions_and_Operators
- [Операторы присваивания](#Операторы_присваивания)
- [Операторы сравнения](#Операторы_сравнения)
- [Арифметические операторы](#Арифметические_операторы)
-- [Битовые (поразрядные) операторы](#Битовые_(поразрядные)_операторы)
+- [Битовые (поразрядные) операторы](<#Битовые_(поразрядные)_операторы>)
- [Логические операторы](#Логические_операторы)
- [Строковые операторы](#Строковые_операторы)
-- [Условный (тернарный) оператор](#Условный_(тернарный)_оператор)
+- [Условный (тернарный) оператор](<#Условный_(тернарный)_оператор>)
- [Оператор запятая](#Оператор_запятая)
- [Унарные операторы](#Унарные_операторы)
- [Операторы отношения](#Операторы_отношения)
@@ -83,8 +83,8 @@ operand operator
var foo = ["one", "two", "three"];
// без деструктуризации
-var one = foo[0];
-var two = foo[1];
+var one = foo[0];
+var two = foo[1];
var three = foo[2];
// с деструктуризацией
@@ -96,19 +96,20 @@ var [one, two, three] = foo;
[Оператор сравнения](/ru/docs/Web/JavaScript/Reference/Operators/Comparison_Operators) сравнивает свои операнды и возвращает логическое значение, базируясь на истинности сравнения. Операнды могут быть числами, строками, логическими величинами или объектами. Строки сравниваются на основании стандартного лексикографического порядка, используя Unicode-значения. В большинстве случаев, если операнды имеют разный тип, то JavaScript пробует преобразовать их в тип, подходящий для сравнения. Такое поведение обычно происходит при сравнении числовых операндов. Единственным исключением из данного правила является сравнение с использованием операторов `===` и `!==`, которые производят строгое сравнение на равенство или неравенство. Эти операторы не пытаются преобразовать операнды перед их сравнением. Следующая таблица описывает операторы сравнения в контексте следующего примера кода:
```js
-var var1 = 3, var2 = 4;
+var var1 = 3,
+ var2 = 4;
```
-| Оператор | Описание | Примеры, возвращающие true |
-| ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------ |
-| [Равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Equality) (`==`) | Возвращает true, если операнды равны. | `3 == var1` `"3" == var1` `3 == '3'` |
-| [Не равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Inequality) (`!=`) | Возвращает true, если операнды не равны. | `var1 != 4 var2 != "3"` |
+| Оператор | Описание | Примеры, возвращающие true |
+| ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
+| [Равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Equality) (`==`) | Возвращает true, если операнды равны. | `3 == var1` `"3" == var1` `3 == '3'` |
+| [Не равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Inequality) (`!=`) | Возвращает true, если операнды не равны. | `var1 != 4 var2 != "3"` |
| [Строго равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Identity) (`===`) | Возвращает true, если операнды равны и имеют одинаковый тип. Смотрите также {{jsxref("Object.is")}} и [sameness in JS](/ru/docs/Web/JavaScript/Equality_comparisons_and_sameness). | `3 === var1` |
-| [Строго не равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Nonidentity)(`!==`) | Возвращает true, если операнды не равны и/или имеют разный тип. | `var1 !== "3" 3 !== '3'` |
-| [Больше](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Greater_than_operator) (`>`) | Возвращает true, если операнд слева больше операнда справа. | `var2 > var1 "12" > 2` |
-| [Больше или равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Greater_than_or_equal_operator) (`>=`) | Возвращает true, если операнд слева больше или равен операнду справа. | `var2 >= var1 var1 >= 3` |
-| [Меньше](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Less_than_operator) (`<`) | Возвращает true, если операнд слева меньше операнда справа. | `var1 < var2 "2" < 12` |
-| [Меньше или равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Less_than_or_equal_operator) (`<=`) | Возвращает true, если операнд слева меньше или равен операнду справа. | `var1 <= var2 var2 <= 5` |
+| [Строго не равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Nonidentity)(`!==`) | Возвращает true, если операнды не равны и/или имеют разный тип. | `var1 !== "3" 3 !== '3'` |
+| [Больше](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Greater_than_operator) (`>`) | Возвращает true, если операнд слева больше операнда справа. | `var2 > var1 "12" > 2` |
+| [Больше или равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Greater_than_or_equal_operator) (`>=`) | Возвращает true, если операнд слева больше или равен операнду справа. | `var2 >= var1 var1 >= 3` |
+| [Меньше](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Less_than_operator) (`<`) | Возвращает true, если операнд слева меньше операнда справа. | `var1 < var2 "2" < 12` |
+| [Меньше или равно](/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Less_than_or_equal_operator) (`<=`) | Возвращает true, если операнд слева меньше или равен операнду справа. | `var1 <= var2 var2 <= 5` |
> **Примечание:** (**=>**) не оператор, а нотация [Стрелочных функций](/ru/docs/Web/JavaScript/Reference/Functions/Arrow_functions).
@@ -123,13 +124,13 @@ console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */
Кроме того, JavaScript позволяет использовать следующие арифметические операторы, представленные в таблице:
-| Оператор | Описание | Пример |
-| ----------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-| [Остаток от деления](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder) (`%`) | Бинарный оператор. Возвращает целочисленный остаток от деления двух операндов. | 12 % 5 вернёт 2. |
-| [Инкремент](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment) (`++`) | Унарный оператор. Добавляет единицу к своему операнду. Если используется в качестве префикса (`++x`), то возвращает значение операнда с добавленной к нему единицей; а в случае применения в качестве окончания (`x++`) возвращает значение операнда перед добавлением к нему единицы. | `Если x` равно 3, тогда `++x` установит значение `x` равным 4 и вернёт 4, напротив `x++` вернёт 3 и потом установит значение `x` равным 4. |
-| [Декремент](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement) (`--`) | Унарный оператор. Вычитает единицу из значения своего операнда. Логика данного оператора аналогична оператору инкремента. | Если `x` равно 3, тогда `--x` установит значение `x` равным 2 и вернёт 2, напротив `x--` вернёт 3 и потом установит значение `x` равным 2. |
-| [Унарный минус](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_negation)`-` | Унарный оператор. Возвращает отрицательное значение своего операнда. | Если `x` равно 3, тогда `-x` вернёт -3. |
-| [Унарный плюс](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_plus) (`+`) | Унарный оператор. Пытается конвертировать операнд в число, если он ещё не оно. | `+"3"` вернёт `3`. `+true` вернёт `1.` |
+| Оператор | Описание | Пример |
+| -------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| [Остаток от деления](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder) (`%`) | Бинарный оператор. Возвращает целочисленный остаток от деления двух операндов. | 12 % 5 вернёт 2. |
+| [Инкремент](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment) (`++`) | Унарный оператор. Добавляет единицу к своему операнду. Если используется в качестве префикса (`++x`), то возвращает значение операнда с добавленной к нему единицей; а в случае применения в качестве окончания (`x++`) возвращает значение операнда перед добавлением к нему единицы. | `Если x` равно 3, тогда `++x` установит значение `x` равным 4 и вернёт 4, напротив `x++` вернёт 3 и потом установит значение `x` равным 4. |
+| [Декремент](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement) (`--`) | Унарный оператор. Вычитает единицу из значения своего операнда. Логика данного оператора аналогична оператору инкремента. | Если `x` равно 3, тогда `--x` установит значение `x` равным 2 и вернёт 2, напротив `x--` вернёт 3 и потом установит значение `x` равным 2. |
+| [Унарный минус](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_negation)`-` | Унарный оператор. Возвращает отрицательное значение своего операнда. | Если `x` равно 3, тогда `-x` вернёт -3. |
+| [Унарный плюс](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_plus) (`+`) | Унарный оператор. Пытается конвертировать операнд в число, если он ещё не оно. | `+"3"` вернёт `3`. `+true` вернёт `1.` |
| [Возведение в степень](/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation) (`**`) {{experimental_inline}} | Возводит `основание` в показатель `степени`, как, `основаниестепень` | `2 ** 3` вернёт `8`. `10 ** -1` вернёт `0.1`. |
### Битовые (поразрядные) операторы
@@ -154,7 +155,7 @@ console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */
- Операнды преобразуются в 32-битные целые числа и представляются в виде последовательности бит (нулей и единиц). Числа, имеющие более 32 битов будут сокращены. Например, следующее число имеет больше 32 битов и сконвертируется в 32-х битное:
- ```html
+ ```plain
До : 11100110111110100000000000000110000000000001
После : 10100000000000000110000000000001
```
@@ -164,13 +165,13 @@ console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */
Например, двоичным представлением числа 9 является 1001, а двоичным представлением пятнадцати - 1111. Результаты применения к этим числам битовых логических операторов выглядят следующим образом:
-| Выражение | Результат | Двоичное описание |
-| --------- | --------- | ---------------------------------------------------------------- |
-| `15 & 9` | `9` | `1111 & 1001 = 1001` |
-| `15 \| 9` | `15` | `1111 \| 1001 = 1111` |
-| `15 ^ 9` | `6` | `1111 ^ 1001 = 0110` |
-| `~15` | `-16` | ` ~``00000000...``00001111 = ``1111``1111``...``11110000 ` |
-| `~9` | `-10` | ` ~``00000000``...``0000``1001 = ``1111``1111``...``1111``0110 ` |
+| Выражение | Результат | Двоичное описание |
+| --------- | --------- | -------------------------------------------------------------- |
+| `15 & 9` | `9` | `1111 & 1001 = 1001` |
+| `15 \| 9` | `15` | `1111 \| 1001 = 1111` |
+| `15 ^ 9` | `6` | `1111 ^ 1001 = 0110` |
+| `~15` | `-16` | `~``00000000...``00001111 = ``1111``1111``...``11110000` |
+| `~9` | `-10` | `~``00000000``...``0000``1001 = ``1111``1111``...``1111``0110` |
Обратите внимание, что все 32 бита преобразуются с использованием битового оператора НЕ, и что величины с наиболее значимым (самым левым) битом равным 1 представляют собой отрицательные числа (в представлении дополнения до двух).
@@ -184,50 +185,50 @@ console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */
| Оператор | Описание | Пример |
| ------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| [Сдвиг влево]() (`<<`) | Данный оператор сдвигает первый операнд на указанное количество бит влево. Излишние биты, сдвинутые влево, отбрасываются. Справа число дополняется нулевыми битами. | `9<<2` равно 36, так как 1001 после сдвига на 2 бита влево превращается в 100100, что соответствует числу 36. |
-| [Сдвиг вправо с переносом знака](>_(Sign-propagating_right_shift)>) (`>>`) | Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется копиями крайнего слева бита. | `9>>2` равно 2, так как 1001 после сдвига на 2 бита вправо превращается в 10, что соответствует числу 2. Подобным же образом `-9>>2` равно -3, так как знак сохраняется. |
-| [Сдвиг вправо с заполнением нулями](>>_(Zero-fill_right_shift)>) (`>>>`) | Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется нулевыми битами. | `19>>>2` равно 4, так как 10011 после сдвига на 2 бита вправо превращается в 100, что соответствует числу 4. Для неотрицательных чисел сдвиг вправо с заполнением нулями и сдвиг вправо с переносом знака дают одинаковый результат. |
+| [Сдвиг влево]() (`<<`) | Данный оператор сдвигает первый операнд на указанное количество бит влево. Излишние биты, сдвинутые влево, отбрасываются. Справа число дополняется нулевыми битами. | `9<<2` равно 36, так как 1001 после сдвига на 2 бита влево превращается в 100100, что соответствует числу 36. |
+| [Сдвиг вправо с переносом знака](\>_(Sign-propagating_right_shift)>) (`>>`) | Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется копиями крайнего слева бита. | `9>>2` равно 2, так как 1001 после сдвига на 2 бита вправо превращается в 10, что соответствует числу 2. Подобным же образом `-9>>2` равно -3, так как знак сохраняется. |
+| [Сдвиг вправо с заполнением нулями](\>\>_(Zero-fill_right_shift)>) (`>>>`) | Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется нулевыми битами. | `19>>>2` равно 4, так как 10011 после сдвига на 2 бита вправо превращается в 100, что соответствует числу 4. Для неотрицательных чисел сдвиг вправо с заполнением нулями и сдвиг вправо с переносом знака дают одинаковый результат. |
### Логические операторы
[Логические операторы](/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators) обычно используются с булевыми (логическими) значениями; при этом возвращаемое ими значение также является булевым. Однако операторы && и || фактически возвращают значение одного из операндов, поэтому, если эти операторы используются с небулевыми величинами, то возвращаемая ими величина также может быть не булевой. Логические операторы описаны в следующей таблице.
-| Оператор | Использование | Описание |
-| --------------------------------------------------------------------------------------------------- | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [Логическое И](/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_AND)``(`&&`) | `expr1 && expr2` | (Логическое И) Возвращает операнд `expr1`, если он может быть преобразован в `false`; в противном случае возвращает операнд `expr2`. Таким образом, при использовании булевых величин в качестве операндов, оператор `&&` возвращает `true`, если оба операнда `true`; в противном случае возвращает `false`. |
+| Оператор | Использование | Описание |
+| -------------------------------------------------------------------------------------------------- | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Логическое И](/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_AND)(`&&`) | `expr1 && expr2` | (Логическое И) Возвращает операнд `expr1`, если он может быть преобразован в `false`; в противном случае возвращает операнд `expr2`. Таким образом, при использовании булевых величин в качестве операндов, оператор `&&` возвращает `true`, если оба операнда `true`; в противном случае возвращает `false`. |
| [Логическое ИЛИ](/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR)(`\|\|`) | `expr1 \|\| expr2` | (Логическое ИЛИ) Возвращает операнд `expr1`, если он может быть преобразован в `true`; в противном случае возвращает операнд `expr2`. Таким образом, при использовании булевых величин в качестве операндов, оператор `\|\|` возвращает `true`, если один из операндов `true`; если же оба `false`, то возвращает `false`. |
-| [Логическое НЕ](/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT) (`!`) | `!expr` | (Логическое НЕ) Возвращает `false`, если операнд может быть преобразован в `true`; в противном случае возвращает `true`. |
+| [Логическое НЕ](/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT) (`!`) | `!expr` | (Логическое НЕ) Возвращает `false`, если операнд может быть преобразован в `true`; в противном случае возвращает `true`. |
Примерами выражений, которые могут быть преобразованы в false являются: null, 0, NaN, пустая строка ("") или undefined.
Следующий код демонстрирует примеры использования оператора && (логическое И).
```js
-var a1 = true && true; // t && t возвращает true
-var a2 = true && false; // t && f возвращает false
-var a3 = false && true; // f && t возвращает false
-var a4 = false && (3 == 4); // f && f возвращает false
-var a5 = "Cat" && "Dog"; // t && t возвращает Dog
-var a6 = false && "Cat"; // f && t возвращает false
-var a7 = "Cat" && false; // t && f возвращает false
+var a1 = true && true; // t && t возвращает true
+var a2 = true && false; // t && f возвращает false
+var a3 = false && true; // f && t возвращает false
+var a4 = false && 3 == 4; // f && f возвращает false
+var a5 = "Cat" && "Dog"; // t && t возвращает Dog
+var a6 = false && "Cat"; // f && t возвращает false
+var a7 = "Cat" && false; // t && f возвращает false
```
Следующий код демонстрирует примеры использования оператора || (логическое ИЛИ).
```js
-var o1 = true || true; // t || t возвращает true
-var o2 = false || true; // f || t возвращает true
-var o3 = true || false; // t || f возвращает true
-var o4 = false || (3 == 4); // f || f возвращает false
-var o5 = "Cat" || "Dog"; // t || t возвращает Cat
-var o6 = false || "Cat"; // f || t возвращает Cat
-var o7 = "Cat" || false; // t || f возвращает Cat
+var o1 = true || true; // t || t возвращает true
+var o2 = false || true; // f || t возвращает true
+var o3 = true || false; // t || f возвращает true
+var o4 = false || 3 == 4; // f || f возвращает false
+var o5 = "Cat" || "Dog"; // t || t возвращает Cat
+var o6 = false || "Cat"; // f || t возвращает Cat
+var o7 = "Cat" || false; // t || f возвращает Cat
```
Следующий код демонстрирует примеры использования оператора ! (логическое НЕ).
```js
-var n1 = !true; // !t возвращает false
+var n1 = !true; // !t возвращает false
var n2 = !false; // !f возвращает true
var n3 = !"Cat"; // !t возвращает false
```
@@ -246,13 +247,14 @@ var n3 = !"Cat"; // !t возвращает false
В дополнение к операторам сравнения, которые могут использоваться со строковыми значениями, оператор (+) позволяет объединить две строки, возвращая при этом третью строку, которая представляет собой объединение двух строк-операндов:
```js
-console.log("my " + "string"); // в консоли выведется строка "my string".
+console.log("my " + "string"); // в консоли выведется строка "my string".
```
Сокращённый оператор присваивания += также может быть использован для объединения (конкатенации) строк:
```js
-var mystring = "alpha"; mystring += "bet"; // получается значение "alphabet" и присваивается mystring.
+var mystring = "alpha";
+mystring += "bet"; // получается значение "alphabet" и присваивается mystring.
```
### Условный (тернарный) оператор
@@ -268,7 +270,7 @@ condition ? val1 : val2
Если `condition (условие)` - истина, то оператор принимает значение `val1`. В противном случае оператор принимает значение `val2`. Вы можете использовать условный оператор во всех случаях, где может быть использован стандартный оператор.
```js
-var status = (age >= 18) ? "adult" : "minor";
+var status = age >= 18 ? "adult" : "minor";
```
Данное выражение присваивает значение "adult" переменной `status`, если `age` имеет значение 18 или более. В противном случае переменной `status` присваивается значение "minor".
@@ -311,12 +313,12 @@ delete property; // допустимо только внутри with
x = 42;
var y = 43;
myobj = new Number();
-myobj.h = 4; // создаём свойство h
-delete x; // возвращает true (можно удалить переменную объявленную неявно)
-delete y; // возвращает false (нельзя удалить переменную объявленную с помощью var)
+myobj.h = 4; // создаём свойство h
+delete x; // возвращает true (можно удалить переменную объявленную неявно)
+delete y; // возвращает false (нельзя удалить переменную объявленную с помощью var)
delete Math.PI; // возвращает false (нельзя удалить встроенные свойства)
delete myobj.h; // возвращает true (можно удалить пользовательские свойства)
-delete myobj; // возвращает true (можно удалить объект объявленный неявно)
+delete myobj; // возвращает true (можно удалить объект объявленный неявно)
```
##### Удаление элементов массива
@@ -366,10 +368,10 @@ var today = new Date();
Оператор `typeof` возвращает следующие результаты для этих переменных:
```js
-typeof myFun; // возвращает "function"
-typeof shape; // возвращает "string"
-typeof size; // возвращает "number"
-typeof today; // возвращает "object"
+typeof myFun; // возвращает "function"
+typeof shape; // возвращает "string"
+typeof size; // возвращает "number"
+typeof today; // возвращает "object"
typeof dontExist; // возвращает "undefined"
```
@@ -383,35 +385,35 @@ typeof null; // возвращает "object"
Для чисел и строк оператор `typeof` возвращает следующие результаты:
```js
-typeof 62; // возвращает "number"
-typeof 'Hello world'; // возвращает "string"
+typeof 62; // возвращает "number"
+typeof "Hello world"; // возвращает "string"
```
Для свойств оператор `typeof` возвращает тип значения данного свойства:
```js
typeof document.lastModified; // возвращает "string"
-typeof window.length; // возвращает "number"
-typeof Math.LN2; // возвращает "number"
+typeof window.length; // возвращает "number"
+typeof Math.LN2; // возвращает "number"
```
Для методов и функций оператор `typeof` возвращает следующие результаты:
```js
-typeof blur; // возвращает "function"
-typeof eval; // возвращает "function"
-typeof parseInt; // возвращает "function"
+typeof blur; // возвращает "function"
+typeof eval; // возвращает "function"
+typeof parseInt; // возвращает "function"
typeof shape.split; // возвращает "function"
```
Для встроенных объектов оператор `typeof` возвращает следующие результаты:
```js
-typeof Date; // возвращает "function"
+typeof Date; // возвращает "function"
typeof Function; // возвращает "function"
-typeof Math; // возвращает "object"
-typeof Option; // возвращает "function"
-typeof String; // возвращает "function"
+typeof Math; // возвращает "object"
+typeof Option; // возвращает "function"
+typeof String; // возвращает "function"
```
#### `Оператор void`
@@ -430,14 +432,15 @@ void expression
Следующий код служит примером создания гипертекстовой ссылки, которая бездействует при нажатии на неё пользователем. Когда пользователь нажимает на ссылку, `void(0)` вычисляется равным `undefined`, что не приводит ни к каким действиям в JavaScript.
```html
-Нажмите здесь, чтобы ничего не произошло
+Нажмите здесь, чтобы ничего не произошло
```
Приведённый ниже код создаёт гипертекстовую ссылку, которая подтверждает отправку формы при клике на ней пользователем:
```html
-
-Нажмите здесь, чтобы подтвердить отправку формы
+
+ Нажмите здесь, чтобы подтвердить отправку формы
```
### Операторы отношения
@@ -459,21 +462,21 @@ propNameOrNumber in objectName
```js
// Массивы
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
-0 in trees; // возвращает true
-3 in trees; // возвращает true
-6 in trees; // возвращает false
-"bay" in trees; // возвращает false (следует указать индекс элемента массива,
- // а не значение элемента)
+0 in trees; // возвращает true
+3 in trees; // возвращает true
+6 in trees; // возвращает false
+"bay" in trees; // возвращает false (следует указать индекс элемента массива,
+// а не значение элемента)
"length" in trees; // возвращает true (length является свойством объекта Array)
// Встроенные объекты
-"PI" in Math; // возвращает true
+"PI" in Math; // возвращает true
var myString = new String("coral");
-"length" in myString; // возвращает true
+"length" in myString; // возвращает true
// Пользовательские объекты
-var mycar = {make: "Honda", model: "Accord", year: 1998};
-"make" in mycar; // возвращает true
+var mycar = { make: "Honda", model: "Accord", year: 1998 };
+"make" in mycar; // возвращает true
"model" in mycar; // возвращает true
```
@@ -559,18 +562,16 @@ this.propertyName
Предположим, функция `validate` выполняет проверку свойства `value` некоторого объекта; задан объект, а также верхняя и нижняя граница величины данного свойства:
```js
-function validate(obj, lowval, hival){
- if ((obj.value < lowval) || (obj.value > hival))
- alert("Неверное значение!");
+function validate(obj, lowval, hival) {
+ if (obj.value < lowval || obj.value > hival) alert("Неверное значение!");
}
```
Вы можете вызвать функцию `validate` для обработчика события `onChange` для каждого элемента формы, используя `this` для указания на элемент формы, как это показано в следующем примере:
```html
-Введите число от 18 до 99:
-Введите число от 18 до 99:
+Enter your phone number (with area code) and then click "Check".
-
+
+ Enter your phone number (with area code) and then click "Check".
diff --git a/files/ru/web/javascript/guide/text_formatting/index.md b/files/ru/web/javascript/guide/text_formatting/index.md
index 3aad3d82f03072..c2f86c3bd3e1b5 100644
--- a/files/ru/web/javascript/guide/text_formatting/index.md
+++ b/files/ru/web/javascript/guide/text_formatting/index.md
@@ -19,17 +19,16 @@ translation_of: Web/JavaScript/Guide/Text_formatting
Вы можете создавать простые строки, используя либо одинарные, либо двойные кавычки:
-```js
-'foo'
-"bar"
+```js-nolint
+'foo';
+"bar";
```
Начиная со стандарта ES6 (ES-2015) для простых и сложных строк можно использовать обратные косые кавычки, а также, вставлять значения:
```js
const name = "Alex";
-const str =
- `Привет, ${name},
+const str = `Привет, ${name},
как дела?`;
console.log(str);
@@ -46,7 +45,7 @@ console.log(str);
Число после \x трактуется как [шестнадцатеричное.](https://en.wikipedia.org/wiki/Hexadecimal)
```js
-'\xA9' // "©"
+"\xA9"; // "©"
```
#### Unicode экранированные последовательности
@@ -54,7 +53,7 @@ console.log(str);
Экранированные последовательности Unicode требуют по меньшей мере 4 символа после `\u`.
```js
-'\u00A9' // "©"
+"\u00A9"; // "©"
```
#### Экранирование элементов кода Unicode
@@ -64,10 +63,10 @@ console.log(str);
Смотрите также {{jsxref("String.fromCodePoint()")}} или {{jsxref("String.prototype.codePointAt()")}}.
```js
-'\u{2F804}'
+"\u{2F804}";
// То же самое с простым Unicode
-'\uD87E\uDC04'
+"\uD87E\uDC04";
```
### Объекты String
@@ -96,7 +95,7 @@ eval(s2); // Вернёт строку "2 + 2"
```js
var mystring = "Hello, World!";
var x = mystring.length;
-mystring[0] = 'L'; // Ничего не произойдёт, т.к. строки неизменяемые
+mystring[0] = "L"; // Ничего не произойдёт, т.к. строки неизменяемые
mystring[0]; // Вернёт: "H"
```
@@ -104,21 +103,21 @@ mystring[0]; // Вернёт: "H"
В таблице ниже представлены методы String объекта.
-| Метод | Описание |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Метод | Описание |
+| ------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| {{jsxref("String.charAt", "charAt")}}, {{jsxref("String.charCodeAt", "charCodeAt")}}, {{jsxref("String.codePointAt", "codePointAt")}} | Возвращает символ или символьный код в указанной позиции в строке. |
-| {{jsxref("String.indexOf", "indexOf")}}, {{jsxref("String.lastIndexOf", "lastIndexOf")}} | Возвращает первую (indexOf) или последнюю (lastIndexOf) позицию указанной подстроки в строке. Если данная подстрока не найдена, то возвращает -1. |
-| {{jsxref("String.startsWith", "startsWith")}}, {{jsxref("String.endsWith", "endsWith")}}, {{jsxref("String.includes", "includes")}} | Проверяет, начинается/кончается/содержит ли строка указанную подстроку. |
-| {{jsxref("String.concat", "concat")}} | Объединяет две строки и возвращает результат в качестве новой строки. |
-| {{jsxref("String.fromCharCode", "fromCharCode")}}, {{jsxref("String.fromCodePoint", "fromCodePoint")}} | Создаёт строку из указанной последовательности Unicode значений. Это метод класса String, а не отдельного экземпляра этого класса. |
-| {{jsxref("String.split", "split")}} | Разбивает строку на подстроки, результат возвращает в виде массива строк. |
-| {{jsxref("String.slice", "slice")}} | Извлекает часть строки и возвращает её в качестве новой строки. |
-| {{jsxref("String.substring", "substring")}}, {{jsxref("String.substr", "substr")}} | Возвращает указанную часть строки по начальному и конечному индексам, либо по начальному индексу и длине. |
-| {{jsxref("String.match", "match")}}, {{jsxref("String.replace", "replace")}}, {{jsxref("String.search", "search")}} | Работа с регулярными выражениями. |
-| {{jsxref("String.toLowerCase", "toLowerCase")}}, {{jsxref("String.toUpperCase", "toUpperCase")}} | Возвращает строку полностью в нижнем (toLowerCase) или верхнем (toUpperCase) регистре. |
-| {{jsxref("String.normalize", "normalize")}} | Возвращает нормализованную Unicode форму строки - значения объекта String, на котором вызывается. |
-| {{jsxref("String.repeat", "repeat")}} | Возвращает строку, которая представляет собой повторение исходной строки указанное количество раз. |
-| {{jsxref("String.trim", "trim")}} | Убирает пробелы в начале и в конце строки, результат возвращается в качестве новой строки. |
+| {{jsxref("String.indexOf", "indexOf")}}, {{jsxref("String.lastIndexOf", "lastIndexOf")}} | Возвращает первую (indexOf) или последнюю (lastIndexOf) позицию указанной подстроки в строке. Если данная подстрока не найдена, то возвращает -1. |
+| {{jsxref("String.startsWith", "startsWith")}}, {{jsxref("String.endsWith", "endsWith")}}, {{jsxref("String.includes", "includes")}} | Проверяет, начинается/кончается/содержит ли строка указанную подстроку. |
+| {{jsxref("String.concat", "concat")}} | Объединяет две строки и возвращает результат в качестве новой строки. |
+| {{jsxref("String.fromCharCode", "fromCharCode")}}, {{jsxref("String.fromCodePoint", "fromCodePoint")}} | Создаёт строку из указанной последовательности Unicode значений. Это метод класса String, а не отдельного экземпляра этого класса. |
+| {{jsxref("String.split", "split")}} | Разбивает строку на подстроки, результат возвращает в виде массива строк. |
+| {{jsxref("String.slice", "slice")}} | Извлекает часть строки и возвращает её в качестве новой строки. |
+| {{jsxref("String.substring", "substring")}}, {{jsxref("String.substr", "substr")}} | Возвращает указанную часть строки по начальному и конечному индексам, либо по начальному индексу и длине. |
+| {{jsxref("String.match", "match")}}, {{jsxref("String.replace", "replace")}}, {{jsxref("String.search", "search")}} | Работа с регулярными выражениями. |
+| {{jsxref("String.toLowerCase", "toLowerCase")}}, {{jsxref("String.toUpperCase", "toUpperCase")}} | Возвращает строку полностью в нижнем (toLowerCase) или верхнем (toUpperCase) регистре. |
+| {{jsxref("String.normalize", "normalize")}} | Возвращает нормализованную Unicode форму строки - значения объекта String, на котором вызывается. |
+| {{jsxref("String.repeat", "repeat")}} | Возвращает строку, которая представляет собой повторение исходной строки указанное количество раз. |
+| {{jsxref("String.trim", "trim")}} | Убирает пробелы в начале и в конце строки, результат возвращается в качестве новой строки. |
### Многострочные шаблонные строки
@@ -131,8 +130,10 @@ mystring[0]; // Вернёт: "H"
Каждая новая горизонтальная линия символов, вставленная в исходный код, является частью шаблонной строки. Используя обычные строки, вам бы потребовалось использовать следующий синтаксис для многострочной записи:
```js
-console.log("string text line 1\n\
-string text line 2");
+console.log(
+ "string text line 1\n\
+string text line 2",
+);
// "string text line 1
// string text line 2"
```
@@ -184,8 +185,14 @@ var msPerDay = 24 * 60 * 60 * 1000;
// July 17, 2014 00:00:00 UTC.
var july172014 = new Date(msPerDay * (44 * 365 + 11 + 197));
-var options = { year: "2-digit", month: "2-digit", day: "2-digit",
- hour: "2-digit", minute: "2-digit", timeZoneName: "short" };
+var options = {
+ year: "2-digit",
+ month: "2-digit",
+ day: "2-digit",
+ hour: "2-digit",
+ minute: "2-digit",
+ timeZoneName: "short",
+};
var americanDateTime = new Intl.DateTimeFormat("en-US", options).format;
console.log(americanDateTime(july172014)); // 07/16/14, 5:00 PM PDT
@@ -196,14 +203,18 @@ console.log(americanDateTime(july172014)); // 07/16/14, 5:00 PM PDT
Объект {{jsxref("NumberFormat")}} полезен при форматировании чисел, например, валют.
```js
-var gasPrice = new Intl.NumberFormat("en-US",
- { style: "currency", currency: "USD",
- minimumFractionDigits: 3 });
+var gasPrice = new Intl.NumberFormat("en-US", {
+ style: "currency",
+ currency: "USD",
+ minimumFractionDigits: 3,
+});
console.log(gasPrice.format(5.259)); // $5.259
-var hanDecimalRMBInChina = new Intl.NumberFormat("zh-CN-u-nu-hanidec",
- { style: "currency", currency: "CNY" });
+var hanDecimalRMBInChina = new Intl.NumberFormat("zh-CN-u-nu-hanidec", {
+ style: "currency",
+ currency: "CNY",
+});
console.log(hanDecimalRMBInChina.format(1314.25)); // ￥ 一,三一四.二五
```
diff --git a/files/ru/web/javascript/guide/typed_arrays/index.md b/files/ru/web/javascript/guide/typed_arrays/index.md
index 0a11e76eaa8557..117eb77c2d7750 100644
--- a/files/ru/web/javascript/guide/typed_arrays/index.md
+++ b/files/ru/web/javascript/guide/typed_arrays/index.md
@@ -84,7 +84,7 @@ for (var i = 0; i < int32View.length; i++) {
var int16View = new Int16Array(buffer);
for (var i = 0; i < int16View.length; i++) {
- console.log('Entry ' + i + ': ' + int16View[i]);
+ console.log("Entry " + i + ": " + int16View[i]);
}
```
@@ -94,7 +94,7 @@ for (var i = 0; i < int16View.length; i++) {
```js
int16View[0] = 32;
-console.log('Элемент 0 в 32-битном представлении теперь равен ' + int32View[0]);
+console.log("Элемент 0 в 32-битном представлении теперь равен " + int32View[0]);
```
Результатом выполнения станет текст: "Элемент 0 в 32-битном представлении теперь равен 32". Другими словами, два массива на самом деле являются лишь разными представлениями одного и того же буфера данных в разных форматах. Вы можете повторить это с [представлениями](/ru/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#TypedArray_objects) любого типа.
@@ -135,7 +135,7 @@ var amountDueView = new Float32Array(buffer, 20, 1);
```js
var typedArray = new Uint8Array([1, 2, 3, 4]),
- normalArray = Array.prototype.slice.call(typedArray);
+ normalArray = Array.prototype.slice.call(typedArray);
normalArray.length === 4;
normalArray.constructor === Array;
```
diff --git a/files/ru/web/javascript/guide/using_promises/index.md b/files/ru/web/javascript/guide/using_promises/index.md
index 6e4782c211a899..85a83ba7d389fa 100644
--- a/files/ru/web/javascript/guide/using_promises/index.md
+++ b/files/ru/web/javascript/guide/using_promises/index.md
@@ -22,10 +22,10 @@ original_slug: Web/JavaScript/Guide/Ispolzovanie_promisov
function doSomethingOldStyle(successCallback, failureCallback) {
console.log("Готово.");
// Успех в половине случаев.
- if (Math.random() > .5) {
- successCallback("Успех")
+ if (Math.random() > 0.5) {
+ successCallback("Успех");
} else {
- failureCallback("Ошибка")
+ failureCallback("Ошибка");
}
}
@@ -47,12 +47,12 @@ function doSomething() {
return new Promise((resolve, reject) => {
console.log("Готово.");
// Успех в половине случаев.
- if (Math.random() > .5) {
- resolve("Успех")
+ if (Math.random() > 0.5) {
+ resolve("Успех");
} else {
- reject("Ошибка")
+ reject("Ошибка");
}
- })
+ });
}
const promise = doSomething();
@@ -101,40 +101,49 @@ let promise2 = doSomething().then(successCallback, failureCallback);
Раньше выполнение нескольких асинхронных операций друг за другом приводило к классической "Вавилонской башне" колбэков:
```js
-doSomething(function(result) {
- doSomethingElse(result, function(newResult) {
- doThirdThing(newResult, function(finalResult) {
- console.log('Итоговый результат: ' + finalResult);
- }, failureCallback);
- }, failureCallback);
+doSomething(function (result) {
+ doSomethingElse(
+ result,
+ function (newResult) {
+ doThirdThing(
+ newResult,
+ function (finalResult) {
+ console.log("Итоговый результат: " + finalResult);
+ },
+ failureCallback,
+ );
+ },
+ failureCallback,
+ );
}, failureCallback);
```
В современных функциях мы записываем колбэки в возвращаемые промисы - формируем цепочку промисов:
```js
-doSomething().then(function(result) {
- return doSomethingElse(result);
-})
-.then(function(newResult) {
- return doThirdThing(newResult);
-})
-.then(function(finalResult) {
- console.log('Итоговый результат: ' + finalResult);
-})
-.catch(failureCallback);
+doSomething()
+ .then(function (result) {
+ return doSomethingElse(result);
+ })
+ .then(function (newResult) {
+ return doThirdThing(newResult);
+ })
+ .then(function (finalResult) {
+ console.log("Итоговый результат: " + finalResult);
+ })
+ .catch(failureCallback);
```
Аргументы `then` необязательны, а `catch(failureCallback)` - это сокращение для `then(null, failureCallback)`. Вот как это выражено с помощью [стрелочных функций](/ru/docs/Web/JavaScript/Reference/Functions/Arrow_functions):
```js
doSomething()
-.then(result => doSomethingElse(result))
-.then(newResult => doThirdThing(newResult))
-.then(finalResult => {
- console.log(`Итоговый результат: ${finalResult}`);
-})
-.catch(failureCallback);
+ .then((result) => doSomethingElse(result))
+ .then((newResult) => doThirdThing(newResult))
+ .then((finalResult) => {
+ console.log(`Итоговый результат: ${finalResult}`);
+ })
+ .catch(failureCallback);
```
**Важно:** Всегда возвращайте промисы в return, иначе колбэки не будут сцеплены и ошибки могут быть не пойманы (стрелочные функции неявно возвращают результат, если скобки {} вокруг тела функции опущены).
diff --git a/files/ru/web/javascript/guide/working_with_objects/index.md b/files/ru/web/javascript/guide/working_with_objects/index.md
index b33ee241a6e7b9..8cce0db09856ae 100644
--- a/files/ru/web/javascript/guide/working_with_objects/index.md
+++ b/files/ru/web/javascript/guide/working_with_objects/index.md
@@ -19,7 +19,7 @@ JavaScript спроектирован на основе простой пара
В JavaScript объект имеет свойства, ассоциированные с ним. Свойство объекта можно понимать как переменную, закреплённую за объектом. Свойства объекта в сущности являются теми же самыми переменными JavaScript, за тем исключением, что они закреплены за объектом. Свойства объекта определяют его характеристики. Получить доступ к свойству объекта можно с помощью точечной записи:
```js
-objectName.propertyName
+objectName.propertyName;
```
Как и все переменные JavaScript, имя объекта (которое тоже может быть переменной) и имя свойства являются чувствительными к регистру. Вы можете определить свойство указав его значение. Например, давайте создадим объект `myCar` и определим его свойства `make`, `model`, и `year` следующим образом:
@@ -49,16 +49,16 @@ myCar["year"] = 1969;
```js
var myObj = new Object(),
- str = "myString",
- rand = Math.random(),
- obj = new Object();
+ str = "myString",
+ rand = Math.random(),
+ obj = new Object();
-myObj.type = "Dot syntax";
-myObj["date created"] = "String with space";
-myObj[str] = "String value";
-myObj[rand] = "Random Number";
-myObj[obj] = "Object";
-myObj[""] = "Even an empty string";
+myObj.type = "Dot syntax";
+myObj["date created"] = "String with space";
+myObj[str] = "String value";
+myObj[rand] = "Random Number";
+myObj[obj] = "Object";
+myObj[""] = "Even an empty string";
console.log(myObj);
```
@@ -82,7 +82,7 @@ function showProps(obj, objName) {
var result = "";
for (var i in obj) {
if (obj.hasOwnProperty(i)) {
- result += objName + "." + i + " = " + obj[i] + "\n";
+ result += objName + "." + i + " = " + obj[i] + "\n";
}
}
return result;
@@ -92,9 +92,9 @@ function showProps(obj, objName) {
Так что если вызвать эту функцию вот так `showProps(myCar, "myCar"),` то получим результат:
```js
-myCar.make = Ford
-myCar.model = Mustang
-myCar.year = 1969
+myCar.make = Ford;
+myCar.model = Mustang;
+myCar.year = 1969;
```
## Перечисление всех свойств объекта
@@ -111,11 +111,15 @@ myCar.year = 1969
До ECMAScript 5 не было встроенного способа перечислить все свойства объекта. Однако это можно сделать с помощью следующей функции:
```js
-function listAllProperties(o){
+function listAllProperties(o) {
var objectToInspect;
var result = [];
- for(objectToInspect = o; objectToInspect !== null; objectToInspect = Object.getPrototypeOf(objectToInspect)){
+ for (
+ objectToInspect = o;
+ objectToInspect !== null;
+ objectToInspect = Object.getPrototypeOf(objectToInspect)
+ ) {
result = result.concat(Object.getOwnPropertyNames(objectToInspect));
}
@@ -134,10 +138,12 @@ JavaScript содержит набор встроенных объектов. Т
Помимо создания объектов с помощью функции-конструктора вы можете создавать объекты и другим, особым способом. Фактически, вы можете записать объект синтаксически, и он будет создан интерпретатором автоматически во время выполнения. Эта синтаксическая схема приведена ниже:
```js
-var obj = { property_1: value_1, // property_# may be an identifier...
- 2: value_2, // or a number...
- // ...,
- "property n": value_n }; // or a string
+var obj = {
+ property_1: value_1, // property_# may be an identifier...
+ 2: value_2, // or a number...
+ // ...,
+ "property n": value_n,
+}; // or a string
```
здесь `obj` — это имя нового объекта, каждое `property_i` — это идентификатор (имя, число или строковый литерал), и каждый `value_i` — это значения, назначенные _`property_i`_. Имя `obj` и ссылка объекта на него необязательна; если далее вам не надо будет ссылаться на данный объект, то вам не обязательно назначать объект переменной. (Обратите внимание, что вам потребуется обернуть литерал объекта в скобки, если объект находится в месте, где ожидается инструкция, чтобы интерпретатор не перепутал его с блоком.)
@@ -147,7 +153,7 @@ var obj = { property_1: value_1, // property_# may be an identifier...
Следующая инструкция создаёт объект и назначает его переменной `x`, когда выражение `cond` истинно.
```js
-if (cond) var x = {hi: "there"};
+if (cond) var x = { hi: "there" };
```
Следующий пример создаёт объект `myHonda` с тремя свойствами. Заметьте, что свойство `engine` — это также объект со своими собственными свойствами.
@@ -158,8 +164,8 @@ var myHonda = {
wheels: 4,
engine: {
cylinders: 4,
- size: 2.2
- }
+ size: 2.2,
+ },
};
```
@@ -239,7 +245,7 @@ var car2 = new Car("Nissan", "300ZX", 1992, ken);
Заметьте, что вместо того, чтобы передавать строку, литерал или целое число при создании новых объектов, в выражениях выше передаются объекты `rand` и `ken` как аргумент функции. Теперь, если вам нужно узнать имя владельца car2, это можно сделать следующим образом:
```js
-car2.owner.name
+car2.owner.name;
```
Заметьте, что в любое время вы можете добавить новое свойство ранее созданному объекту. Например, выражение
@@ -257,10 +263,11 @@ car1.color = "black";
```js
// список свойств и методов для Animal
var Animal = {
- type: 'Invertebrates', // Значение type по умолчанию
- displayType: function() { // Метод отображающий тип объекта Animal
+ type: "Invertebrates", // Значение type по умолчанию
+ displayType: function () {
+ // Метод отображающий тип объекта Animal
console.log(this.type);
- }
+ },
};
// Создаём объект Animal
@@ -269,7 +276,7 @@ animal1.displayType(); // Выведет:Invertebrates
// Создаём объект Animal и присваиваем ему type = Fishes
var fish = Object.create(Animal);
-fish.type = 'Fishes';
+fish.type = "Fishes";
fish.displayType(); // Выведет:Fishes
```
@@ -304,9 +311,9 @@ _Метод_ — это функция, ассоциированная с объ
objectName.methodname = function_name;
var myObj = {
- myMethod: function(params) {
+ myMethod: function (params) {
// ...do something
- }
+ },
};
```
@@ -322,8 +329,7 @@ object.methodname(params);
```js
function displayCar() {
- var result = "A Beautiful " + this.year + " " + this.make
- + " " + this.model;
+ var result = "A Beautiful " + this.year + " " + this.make + " " + this.model;
pretty_print(result);
}
```
@@ -361,16 +367,14 @@ car2.displayCar();
```js
function validate(obj, lowval, hival) {
- if ((obj.value < lowval) || (obj.value > hival))
- alert("Invalid Value!");
+ if (obj.value < lowval || obj.value > hival) alert("Invalid Value!");
}
```
Вы можете вызвать эту функцию `validate` в каждом элементе формы, в обработчике события `onchange`. Используйте `this` для доступа к этому элементу, как это сделано ниже:
```html
-';
-}
+Person.prototype.toString = function () {
+ return "";
+};
s.toString(); // ""
```
@@ -845,9 +847,9 @@ s.toString(); // ""
```js
function trivialNew(constructor, ...args) {
- var o = {}; // Создаём новый объект
- constructor.apply(o, args);
- return o;
+ var o = {}; // Создаём новый объект
+ constructor.apply(o, args);
+ return o;
}
```
@@ -856,20 +858,20 @@ function trivialNew(constructor, ...args) {
Вызов
```js
-var bill = trivialNew(Person, 'William', 'Orange');
+var bill = trivialNew(Person, "William", "Orange");
```
практически полностью эквивалентен этому:
```js
-var bill = new Person('William', 'Orange');
+var bill = new Person("William", "Orange");
```
В JavaScript метод [`apply()`](/ru/docs/Web/JavaScript/Reference/Global_Objects/Function/apply) имеет похожий метод [`call()`](/ru/docs/Web/JavaScript/Reference/Global_Objects/Function/call), который тоже позволяет устанавливать `this`, но принимает список, а не массив аргументов.
```js
function lastNameCaps() {
- return this.last.toUpperCase();
+ return this.last.toUpperCase();
}
var s = new Person("Simon", "Willison");
lastNameCaps.call(s);
@@ -904,9 +906,9 @@ function parentFunc() {
```js
function makeAdder(a) {
- return function(b) {
- return a + b;
- };
+ return function (b) {
+ return a + b;
+ };
}
var x = makeAdder(5);
diff --git a/files/ru/web/javascript/memory_management/index.md b/files/ru/web/javascript/memory_management/index.md
index 7ca34a6d0f08b6..420f2578197871 100644
--- a/files/ru/web/javascript/memory_management/index.md
+++ b/files/ru/web/javascript/memory_management/index.md
@@ -32,19 +32,23 @@ var s = "azerty"; // выделяет память для типа string
var o = {
a: 1,
- b: null
+ b: null,
}; // выделяет память для типа object и всех его внутренних переменных
var a = [1, null, "abra"]; // (like object) выделяет память для array и его внутренних значений
-function f(a){
+function f(a) {
return a + 2;
} // выделяет память для function (которая представляет собой вызываемый объект)
// функциональные выражения также выделяют память под object
-someElement.addEventListener('click', function(){
- someElement.style.backgroundColor = 'blue';
-}, false);
+someElement.addEventListener(
+ "click",
+ function () {
+ someElement.style.backgroundColor = "blue";
+ },
+ false,
+);
```
#### Выделение памяти при вызовах функций
@@ -53,7 +57,7 @@ someElement.addEventListener('click', function(){
```js
var d = new Date();
-var e = document.createElement('div'); // выделяет память под DOM-элемент
+var e = document.createElement("div"); // выделяет память под DOM-элемент
```
Некоторые методы выделяют память для новых значений или объектов:
@@ -97,13 +101,12 @@ var a3 = a.concat(a2); // новый массив с 4 элементами в
```js
var o = {
a: {
- b:2
- }
+ b: 2,
+ },
}; // создано 2 объекта. Один ссылается на другой как на одно из своих полей.
// Второй имеет виртуальную ссылку, поскольку присвоен в качестве значения переменной 'o'.
// Очевидно, что ни один из них не подлежит сборке мусора.
-
var o2 = o; // переменная 'o2' - вторая ссылка на объект
o = 1; // теперь объект, имевший изначально ссылку на себя из 'o' имеет уникальную ссылку через переменную 'o2'
@@ -123,7 +126,7 @@ oa = null; // оригинальное значение поля объекта
Основное ограничение данного наивного алгоритма заключается в том, что если два объекта ссылаются друг на друга (создавая таким образом циклическую ссылку), они не могут быть уничтожены сборщиком мусора, даже если "более не нужны".
```js
-function f(){
+function f() {
var o = {};
var o2 = {};
o.a = o2; // o ссылается на o2
@@ -143,7 +146,7 @@ f();
```js
var div;
-window.onload = function(){
+window.onload = function () {
div = document.getElementById("myDivElement");
div.circularReference = div; // DOM-элемент "myDivElement" получает ссылку на себя
div.lotsOfData = new Array(10000).join("*");
diff --git a/files/ru/web/javascript/reference/classes/constructor/index.md b/files/ru/web/javascript/reference/classes/constructor/index.md
index 17f56ab8cb505b..b53acae4f6c50f 100644
--- a/files/ru/web/javascript/reference/classes/constructor/index.md
+++ b/files/ru/web/javascript/reference/classes/constructor/index.md
@@ -128,7 +128,7 @@ class Square extends Polygon {
super(length, length);
// Примечание: В производном классе, super() должен вызываться перед тем, как
// вы сможете использовать 'this'. Иначе будет сгенерировано исключение reference error.
- this.name = 'Square';
+ this.name = "Square";
}
get area() {
diff --git a/files/ru/web/javascript/reference/classes/extends/index.md b/files/ru/web/javascript/reference/classes/extends/index.md
index a6b9988ae9e91c..973bfaba6865a6 100644
--- a/files/ru/web/javascript/reference/classes/extends/index.md
+++ b/files/ru/web/javascript/reference/classes/extends/index.md
@@ -42,7 +42,7 @@ class Square extends Polygon {
// В конструкторе класса, метод super() должен быть вызван
// перед использованием this. В противном случае, будет
// выброшена ошибка.
- this.name = 'Square';
+ this.name = "Square";
}
get area() {
@@ -63,12 +63,22 @@ class myDate extends Date {
getFormattedDate() {
var months = [
- 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
- 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "May",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Oct",
+ "Nov",
+ "Dec",
];
- return this.getDate() + '-' +
- months[this.getMonth()] + '-' +
- this.getFullYear();
+ return (
+ this.getDate() + "-" + months[this.getMonth()] + "-" + this.getFullYear()
+ );
}
}
```
@@ -83,7 +93,7 @@ class nullExtends extends null {
}
Object.getPrototypeOf(nullExtends); // Function.prototype
-Object.getPrototypeOf(nullExtends.prototype) // null
+Object.getPrototypeOf(nullExtends.prototype); // null
new nullExtends(); //ReferenceError: this is not defined
```
diff --git a/files/ru/web/javascript/reference/classes/index.md b/files/ru/web/javascript/reference/classes/index.md
index 21f8e2ffb5bcca..e3fb8f7b7aba44 100644
--- a/files/ru/web/javascript/reference/classes/index.md
+++ b/files/ru/web/javascript/reference/classes/index.md
@@ -132,11 +132,11 @@ class Point {
const p1 = new Point(5, 5);
const p2 = new Point(10, 10);
p1.displayName; //undefined
-p1.distance; //undefined
+p1.distance; //undefined
p2.displayName; //undefined
-p2.distance; //undefined
+p2.distance; //undefined
-console.log(Point.displayName); // "Точка"
+console.log(Point.displayName); // "Точка"
console.log(Point.distance(p1, p2)); // 7.0710678118654755
```
@@ -159,7 +159,7 @@ obj.speak(); // объект Animal
let speak = obj.speak;
speak(); // undefined
-Animal.eat() // класс Animal
+Animal.eat(); // класс Animal
let eat = Animal.eat;
eat(); // undefined
```
@@ -167,13 +167,13 @@ eat(); // undefined
Если мы напишем этот же код используя классы основанные на функциях, тогда произойдёт автоупаковка основанная на значении this, в течение которого функция была вызвана. В строгом режиме автоупаковка не произойдёт - значение this останется прежним.
```js
-function Animal() { }
+function Animal() {}
-Animal.prototype.speak = function(){
+Animal.prototype.speak = function () {
return this;
};
-Animal.eat = function() {
+Animal.eat = function () {
return this;
};
@@ -276,7 +276,7 @@ class Dog extends Animal {
}
}
-let d = new Dog('Митци');
+let d = new Dog("Митци");
d.speak(); // Митци лает
```
@@ -285,12 +285,12 @@ d.speak(); // Митци лает
Аналогичным образом можно расширять традиционные, основанные на функциях "классы":
```js
-function Animal (name) {
+function Animal(name) {
this.name = name;
}
Animal.prototype.speak = function () {
console.log(`${this.name} издаёт звук.`);
-}
+};
class Dog extends Animal {
speak() {
@@ -298,7 +298,7 @@ class Dog extends Animal {
}
}
-let d = new Dog('Митци');
+let d = new Dog("Митци");
d.speak(); // Митци лает
// Для аналогичных методов дочерний метод имеет приоритет над родительским.
@@ -310,7 +310,7 @@ d.speak(); // Митци лает
var Animal = {
speak() {
console.log(`${this.name} издаёт звук.`);
- }
+ },
};
class Dog {
@@ -322,7 +322,7 @@ class Dog {
// Если вы этого не сделаете, вы получите ошибку TypeError при вызове speak.
Object.setPrototypeOf(Dog.prototype, Animal);
-let d = new Dog('Митци');
+let d = new Dog("Митци");
d.speak(); // Митци издаёт звук.
```
@@ -335,13 +335,15 @@ d.speak(); // Митци издаёт звук.
```js
class MyArray extends Array {
// Изменить species на родительский конструктор Array
- static get [Symbol.species]() { return Array; }
+ static get [Symbol.species]() {
+ return Array;
+ }
}
-var a = new MyArray(1,2,3);
-var mapped = a.map(x => x * x);
+var a = new MyArray(1, 2, 3);
+var mapped = a.map((x) => x * x);
console.log(mapped instanceof MyArray); // false
-console.log(mapped instanceof Array); // true
+console.log(mapped instanceof Array); // true
```
## Обращение к родительскому классу с помощью `super`
@@ -366,7 +368,7 @@ class Lion extends Cat {
}
}
-let l = new Lion('Фаззи');
+let l = new Lion("Фаззи");
l.speak();
// Фаззи издаёт звук.
// Фаззи рычит.
@@ -379,20 +381,22 @@ l.speak();
Для реализации mix-ins в ECMAScript можно использовать функцию, которая в качестве аргумента принимает родительский класс, а возвращает подкласс, его расширяющий:
```js
-var calculatorMixin = Base => class extends Base {
- calc() { }
-};
-
-var randomizerMixin = Base => class extends Base {
- randomize() { }
-};
+var calculatorMixin = (Base) =>
+ class extends Base {
+ calc() {}
+ };
+
+var randomizerMixin = (Base) =>
+ class extends Base {
+ randomize() {}
+ };
```
Класс, использующий такие mix-ins, можно описать следующим образом:
```js
-class Foo { }
-class Bar extends calculatorMixin(randomizerMixin(Foo)) { }
+class Foo {}
+class Bar extends calculatorMixin(randomizerMixin(Foo)) {}
```
## Спецификации
diff --git a/files/ru/web/javascript/reference/classes/private_class_fields/index.md b/files/ru/web/javascript/reference/classes/private_class_fields/index.md
index 236a82f2aab09d..642b3dd2b59e55 100644
--- a/files/ru/web/javascript/reference/classes/private_class_fields/index.md
+++ b/files/ru/web/javascript/reference/classes/private_class_fields/index.md
@@ -37,15 +37,15 @@ class ClassWithPrivateStaticField {
```js
class ClassWithPrivateStaticField {
- static #PRIVATE_STATIC_FIELD
+ static #PRIVATE_STATIC_FIELD;
static publicStaticMethod() {
- ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD = 42
- return ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD
+ ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD = 42;
+ return ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD;
}
}
-console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42)
+console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42);
```
Приватные статические поля добавляются в конструктор класса во время обработки класса.
@@ -56,23 +56,25 @@ console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42)
```js
class BaseClassWithPrivateStaticField {
- static #PRIVATE_STATIC_FIELD
+ static #PRIVATE_STATIC_FIELD;
static basePublicStaticMethod() {
- this.#PRIVATE_STATIC_FIELD = 42
- return this.#PRIVATE_STATIC_FIELD
+ this.#PRIVATE_STATIC_FIELD = 42;
+ return this.#PRIVATE_STATIC_FIELD;
}
}
-class SubClass extends BaseClassWithPrivateStaticField { }
+class SubClass extends BaseClassWithPrivateStaticField {}
-let error = null
+let error = null;
try {
- SubClass.basePublicStaticMethod()
-} catch(e) { error = e}
+ SubClass.basePublicStaticMethod();
+} catch (e) {
+ error = e;
+}
-console.assert(error instanceof TypeError)
+console.assert(error instanceof TypeError);
```
### Приватные поля экземпляров
@@ -83,16 +85,16 @@ console.assert(error instanceof TypeError)
```js
class ClassWithPrivateField {
- #privateField
+ #privateField;
constructor() {
- this.#privateField = 42
- this.#randomField = 666 // Syntax error
+ this.#privateField = 42;
+ this.#randomField = 666; // Syntax error
}
}
-const instance = new ClassWithPrivateField()
-instance.#privateField === 42 // Syntax error
+const instance = new ClassWithPrivateField();
+instance.#privateField === 42; // Syntax error
```
### Приватные методы
@@ -107,17 +109,17 @@ instance.#privateField === 42 // Syntax error
```js
class ClassWithPrivateStaticMethod {
- static #privateStaticMethod() {
- return 42
- }
+ static #privateStaticMethod() {
+ return 42;
+ }
- static publicStaticMethod1() {
- return ClassWithPrivateStaticMethod.#privateStaticMethod();
- }
+ static publicStaticMethod1() {
+ return ClassWithPrivateStaticMethod.#privateStaticMethod();
+ }
- static publicStaticMethod2() {
- return this.#privateStaticMethod();
- }
+ static publicStaticMethod2() {
+ return this.#privateStaticMethod();
+ }
}
console.assert(ClassWithPrivateStaticMethod.publicStaticMethod1() === 42);
@@ -128,15 +130,15 @@ console.assert(ClassWithPrivateStaticMethod.publicStaticMethod2() === 42);
```js
class Base {
- static #privateStaticMethod() {
- return 42;
- }
- static publicStaticMethod1() {
- return Base.#privateStaticMethod();
- }
- static publicStaticMethod2() {
- return this.#privateStaticMethod();
- }
+ static #privateStaticMethod() {
+ return 42;
+ }
+ static publicStaticMethod1() {
+ return Base.#privateStaticMethod();
+ }
+ static publicStaticMethod2() {
+ return this.#privateStaticMethod();
+ }
}
class Derived extends Base {}
@@ -152,16 +154,16 @@ console.log(Derived.publicStaticMethod2()); // TypeError
```js
class ClassWithPrivateMethod {
#privateMethod() {
- return 'hello world'
+ return "hello world";
}
getPrivateMessage() {
- return this.#privateMethod()
+ return this.#privateMethod();
}
}
-const instance = new ClassWithPrivateMethod()
-console.log(instance.getPrivateMessage())
+const instance = new ClassWithPrivateMethod();
+console.log(instance.getPrivateMessage());
// expected output: "hello world"
```
@@ -169,18 +171,18 @@ console.log(instance.getPrivateMessage())
```js
class ClassWithPrivateAccessor {
- #message
+ #message;
get #decoratedMessage() {
- return `✨${this.#message}✨`
+ return `✨${this.#message}✨`;
}
set #decoratedMessage(msg) {
- this.#message = msg
+ this.#message = msg;
}
constructor() {
- this.#decoratedMessage = 'hello world'
- console.log(this.#decoratedMessage)
+ this.#decoratedMessage = "hello world";
+ console.log(this.#decoratedMessage);
}
}
diff --git a/files/ru/web/javascript/reference/classes/public_class_fields/index.md b/files/ru/web/javascript/reference/classes/public_class_fields/index.md
index cfdde8b4a6e2bd..3a631f08dc146a 100644
--- a/files/ru/web/javascript/reference/classes/public_class_fields/index.md
+++ b/files/ru/web/javascript/reference/classes/public_class_fields/index.md
@@ -8,6 +8,7 @@ tags:
translation_of: Web/JavaScript/Reference/Classes/Public_class_fields
original_slug: Web/JavaScript/Reference/Classes/Class_fields
---
+
{{JsSidebar("Classes")}}
> **Примечание:** Эта страница описывает экспериментальные возможности.
@@ -23,16 +24,16 @@ original_slug: Web/JavaScript/Reference/Classes/Class_fields
```js
class ClassWithInstanceField {
- instanceField = 'instance field'
+ instanceField = "instance field";
}
class ClassWithStaticField {
- static staticField = 'static field'
+ static staticField = "static field";
}
class ClassWithPublicInstanceMethod {
publicMethod() {
- return 'hello world'
+ return "hello world";
}
}
```
@@ -47,7 +48,7 @@ class ClassWithPublicInstanceMethod {
```js
class ClassWithStaticField {
- static staticField = 'static field';
+ static staticField = "static field";
}
console.log(ClassWithStaticField.staticField);
@@ -61,7 +62,7 @@ class ClassWithStaticField {
static staticField;
}
-console.assert(ClassWithStaticField.hasOwnProperty('staticField'));
+console.assert(ClassWithStaticField.hasOwnProperty("staticField"));
console.log(ClassWithStaticField.staticField);
// Ожидаемый вывод: "undefined"
```
@@ -70,11 +71,11 @@ console.log(ClassWithStaticField.staticField);
```js
class ClassWithStaticField {
- static baseStaticField = 'base field';
+ static baseStaticField = "base field";
}
class SubClassWithStaticField extends ClassWithStaticField {
- static subStaticField = 'sub class field';
+ static subStaticField = "sub class field";
}
console.log(SubClassWithStaticField.subStaticField);
@@ -88,10 +89,12 @@ console.log(SubClassWithStaticField.baseStaticField);
```js
class ClassWithStaticField {
- static baseStaticField = 'base static field';
+ static baseStaticField = "base static field";
static anotherBaseStaticField = this.baseStaticField;
- static baseStaticMethod() { return 'base static method output'; }
+ static baseStaticMethod() {
+ return "base static method output";
+ }
}
class SubClassWithStaticField extends ClassWithStaticField {
@@ -114,7 +117,7 @@ console.log(SubClassWithStaticField.subStaticField);
```js
class ClassWithInstanceField {
- instanceField = 'instance field';
+ instanceField = "instance field";
}
const instance = new ClassWithInstanceField();
@@ -130,7 +133,7 @@ class ClassWithInstanceField {
}
const instance = new ClassWithInstanceField();
-console.assert(instance.hasOwnProperty('instanceField'));
+console.assert(instance.hasOwnProperty("instanceField"));
console.log(instance.instanceField);
// Ожидаемый вывод: "undefined"
```
@@ -138,10 +141,10 @@ console.log(instance.instanceField);
Как и свойства, названия полей могут вычисляться.
```js
-const PREFIX = 'prefix';
+const PREFIX = "prefix";
class ClassWithComputedFieldName {
- [`${PREFIX}Field`] = 'prefixed field';
+ [`${PREFIX}Field`] = "prefixed field";
}
const instance = new ClassWithComputedFieldName();
@@ -153,9 +156,11 @@ console.log(instance.prefixField);
```js
class ClassWithInstanceField {
- baseInstanceField = 'base field';
+ baseInstanceField = "base field";
anotherBaseInstanceField = this.baseInstanceField;
- baseInstanceMethod() { return 'base method output'; }
+ baseInstanceMethod() {
+ return "base method output";
+ }
}
class SubClassWithInstanceField extends ClassWithInstanceField {
@@ -181,7 +186,7 @@ console.log(sub.subInstanceField);
```js
class ClassWithStaticMethod {
static staticMethod() {
- return 'static method has been called.';
+ return "static method has been called.";
}
}
@@ -198,7 +203,7 @@ console.log(ClassWithStaticMethod.staticMethod());
```js
class ClassWithPublicInstanceMethod {
publicMethod() {
- return 'hello world';
+ return "hello world";
}
}
@@ -213,9 +218,9 @@ console.log(instance.publicMethod());
```js
class ClassWithFancyMethods {
- *generatorMethod() { }
- async asyncMethod() { }
- async *asyncGeneratorMethod() { }
+ *generatorMethod() {}
+ async asyncMethod() {}
+ async *asyncGeneratorMethod() {}
}
```
@@ -224,7 +229,7 @@ class ClassWithFancyMethods {
```js
class BaseClass {
- msg = 'hello world';
+ msg = "hello world";
basePublicMethod() {
return this.msg;
}
@@ -245,7 +250,7 @@ console.log(instance.subPublicMethod());
```js
class ClassWithGetSet {
- #msg = 'hello world';
+ #msg = "hello world";
get msg() {
return this.#msg;
}
@@ -258,7 +263,7 @@ const instance = new ClassWithGetSet();
console.log(instance.msg);
// Ожидаемый вывод: "hello world"
-instance.msg = 'cake';
+instance.msg = "cake";
console.log(instance.msg);
// Ожидаемый вывод: "hello cake"
```
diff --git a/files/ru/web/javascript/reference/classes/static/index.md b/files/ru/web/javascript/reference/classes/static/index.md
index 8128ac4fe8c7bf..a64c425671b653 100644
--- a/files/ru/web/javascript/reference/classes/static/index.md
+++ b/files/ru/web/javascript/reference/classes/static/index.md
@@ -3,6 +3,7 @@ title: static
slug: Web/JavaScript/Reference/Classes/static
translation_of: Web/JavaScript/Reference/Classes/static
---
+
{{jsSidebar("Classes")}}
Для того, чтобы объявить статический метод класса, необходимо использовать ключевое слово **static**.
@@ -26,10 +27,10 @@ static methodName() { ... }
```js
class StaticMethodCall {
static staticMethod() {
- return 'Вызван статический метод';
+ return "Вызван статический метод";
}
static anotherStaticMethod() {
- return this.staticMethod() + ' из другого статического метода';
+ return this.staticMethod() + " из другого статического метода";
}
}
StaticMethodCall.staticMethod();
@@ -54,7 +55,7 @@ class StaticMethodCall {
}
static staticMethod() {
- return 'вызван статический метод.';
+ return "вызван статический метод.";
}
}
```
@@ -83,8 +84,8 @@ class BiggerTriple extends Triple {
}
}
-console.log(Triple.triple()); // 3
-console.log(Triple.triple(6)); // 18
+console.log(Triple.triple()); // 3
+console.log(Triple.triple(6)); // 18
var tp = new Triple();
diff --git a/files/ru/web/javascript/reference/deprecated_and_obsolete_features/index.md b/files/ru/web/javascript/reference/deprecated_and_obsolete_features/index.md
index e22a836961fdc9..f8406cd572d32c 100644
--- a/files/ru/web/javascript/reference/deprecated_and_obsolete_features/index.md
+++ b/files/ru/web/javascript/reference/deprecated_and_obsolete_features/index.md
@@ -19,30 +19,30 @@ These deprecated features can still be used, but should be used with caution bec
The following properties are deprecated. This does not affect their use in {{jsxref("String.replace", "replacement strings", "", 1)}}:
-| Свойство | Описание |
-| ---------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| {{jsxref("RegExp.n", "$1-$9")}} | Parenthesized substring matches, if any. **Warning:** Using these properties can result in problems, since browser extensions can modify them. Avoid them! |
-| {{jsxref("RegExp.input", "$_")}} | Смотрите `input`. |
-| {{jsxref("RegExp.multiline", "$*")}} | Смотрите `multiline`. |
-| {{jsxref("RegExp.lastMatch", "$&")}} | Смотрите `lastMatch`. |
-| {{jsxref("RegExp.lastParen", "$+")}} | Смотрите `lastParen`. |
-| {{jsxref("RegExp.leftContext", "$`")}} | Смотрите `leftContext`. |
-| {{jsxref("RegExp.rightContext", "$'")}} | Смотрите `rightContext`. |
-| {{jsxref("RegExp.input", "input")}} | The string against which a regular expression is matched. |
-| {{jsxref("RegExp.lastMatch", "lastMatch")}} | The last matched characters. |
-| {{jsxref("RegExp.lastParen", "lastParen")}} | The last parenthesized substring match, if any. |
-| {{jsxref("RegExp.leftContext", "leftContext")}} | The substring preceding the most recent match. |
+| Свойство | Описание |
+| ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{jsxref("RegExp.n", "$1-$9")}} | Parenthesized substring matches, if any. **Warning:** Using these properties can result in problems, since browser extensions can modify them. Avoid them! |
+| {{jsxref("RegExp.input", "$_")}} | Смотрите `input`. |
+| {{jsxref("RegExp.multiline", "$*")}} | Смотрите `multiline`. |
+| {{jsxref("RegExp.lastMatch", "$&")}} | Смотрите `lastMatch`. |
+| {{jsxref("RegExp.lastParen", "$+")}} | Смотрите `lastParen`. |
+| {{jsxref("RegExp.leftContext", "$`")}} | Смотрите `leftContext`. |
+| {{jsxref("RegExp.rightContext", "$'")}} | Смотрите `rightContext`. |
+| {{jsxref("RegExp.input", "input")}} | The string against which a regular expression is matched. |
+| {{jsxref("RegExp.lastMatch", "lastMatch")}} | The last matched characters. |
+| {{jsxref("RegExp.lastParen", "lastParen")}} | The last parenthesized substring match, if any. |
+| {{jsxref("RegExp.leftContext", "leftContext")}} | The substring preceding the most recent match. |
| {{jsxref("RegExp.rightContext", "rightContext")}} | The substring following the most recent match. |
The following are now properties of `RegExp` instances, no longer of the `RegExp` object:
-| Свойство | Описание |
-| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------ |
-| {{jsxref("RegExp.global", "global")}} | Whether or not to test the regular expression against all possible matches in a string, or only against the first. |
+| Свойство | Описание |
+| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| {{jsxref("RegExp.global", "global")}} | Whether or not to test the regular expression against all possible matches in a string, or only against the first. |
| {{jsxref("RegExp.ignoreCase", "ignoreCase")}} | Whether or not to ignore case while attempting a match in a string. |
-| {{jsxref("RegExp.lastIndex", "lastIndex")}} | The index at which to start the next match. |
-| {{jsxref("RegExp.multiline", "multiline")}} | Whether or not to search in strings across multiple lines. |
-| {{jsxref("RegExp.source", "source")}} | The text of the pattern. |
+| {{jsxref("RegExp.lastIndex", "lastIndex")}} | The index at which to start the next match. |
+| {{jsxref("RegExp.multiline", "multiline")}} | Whether or not to search in strings across multiple lines. |
+| {{jsxref("RegExp.source", "source")}} | The text of the pattern. |
### RegExp methods
@@ -107,26 +107,26 @@ These obsolete features have been entirely removed from JavaScript and can no lo
### Объект
-| Свойство | Описание |
-| ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
-| {{jsxref("Global_Objects/Object/count", "**count**")}} | Returns the number of enumerable properties directly on a user-defined object. |
-| {{jsxref("Global_Objects/Object/Parent", "**parent**")}} | Points to an object's context. |
+| Свойство | Описание |
+| ------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
+| {{jsxref("Global_Objects/Object/count", "**count**")}} | Returns the number of enumerable properties directly on a user-defined object. |
+| {{jsxref("Global_Objects/Object/Parent", "**parent**")}} | Points to an object's context. |
| {{jsxref("Global_Objects/Object/eval", "Object.prototype.eval()")}} | Evaluates a string of JavaScript code in the context of the specified object. |
-| {{jsxref("Object.observe()")}} | Asynchronously observing the changes to an object. |
-| {{jsxref("Object.unobserve()")}} | Remove observers. |
-| {{jsxref("Object.getNotifier()")}} | Creates an object that allows to synthetically trigger a change. |
+| {{jsxref("Object.observe()")}} | Asynchronously observing the changes to an object. |
+| {{jsxref("Object.unobserve()")}} | Remove observers. |
+| {{jsxref("Object.getNotifier()")}} | Creates an object that allows to synthetically trigger a change. |
### Function
-| Свойство | Описание |
-| -------------------------------------------------------------------- | --------------------------- |
+| Свойство | Описание |
+| ---------------------------------------------------- | --------------------------- |
| {{jsxref("Global_Objects/Function/arity", "arity")}} | Number of formal arguments. |
### Массив
-| Свойство | Описание |
-| ---------------------------------------- | ------------------------------------------ |
-| {{jsxref("Array.observe()")}} | Асинхронный просмотр изменений в массивах. |
+| Свойство | Описание |
+| ------------------------------- | ------------------------------------------ |
+| {{jsxref("Array.observe()")}} | Асинхронный просмотр изменений в массивах. |
| {{jsxref("Array.unobserve()")}} | Remove observers. |
### Число
diff --git a/files/ru/web/javascript/reference/errors/array_sort_argument/index.md b/files/ru/web/javascript/reference/errors/array_sort_argument/index.md
index 89258a9c36796d..113327bdaeadcd 100644
--- a/files/ru/web/javascript/reference/errors/array_sort_argument/index.md
+++ b/files/ru/web/javascript/reference/errors/array_sort_argument/index.md
@@ -5,6 +5,7 @@ title: >-
slug: Web/JavaScript/Reference/Errors/Array_sort_argument
translation_of: Web/JavaScript/Reference/Errors/Array_sort_argument
---
+
{{jsSidebar("Errors")}}
## Сообщение
@@ -27,20 +28,19 @@ TypeError: недопустимый Array.prototype.sort аргумент для
### Неправильные примеры
```js example-bad
-[1, 3, 2].sort(5); // TypeError
+[1, 3, 2].sort(5); // TypeError
var cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };
-[1, 3, 2].sort(cmp[this.key] || 'asc'); // TypeError
+[1, 3, 2].sort(cmp[this.key] || "asc"); // TypeError
```
### правильные
```js example-good
-[1, 3, 2].sort(); // [1, 2, 3]
-
+[1, 3, 2].sort(); // [1, 2, 3]
var cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };
-[1, 3, 2].sort(cmp[this.key || 'asc']); // [1, 2, 3]
+[1, 3, 2].sort(cmp[this.key || "asc"]); // [1, 2, 3]
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/bad_radix/index.md b/files/ru/web/javascript/reference/errors/bad_radix/index.md
index 23dfce98b6a5e6..78d9327fa0d3a5 100644
--- a/files/ru/web/javascript/reference/errors/bad_radix/index.md
+++ b/files/ru/web/javascript/reference/errors/bad_radix/index.md
@@ -1,5 +1,5 @@
---
-title: 'RangeError: radix must be an integer'
+title: "RangeError: radix must be an integer"
slug: Web/JavaScript/Reference/Errors/Bad_radix
tags:
- JavaScript
@@ -44,16 +44,16 @@ RangeError: toString() radix argument must be between 2 and 36 (Chrome)
(42).toString(37);
(42).toString(150);
// Нельзя использовать для форматирования строку данного вида:
-(12071989).toString('MM-dd-yyyy');
+(12071989).toString("MM-dd-yyyy");
```
### Корректное применение
```js example-good
-(42).toString(2); // "101010" (двоичная система)
-(13).toString(8); // "15" (восьмеричная)
-(0x42).toString(10); // "66" (десятичная)
-(100000).toString(16) // "186a0" (шестнадцатеричная)
+(42).toString(2); // "101010" (двоичная система)
+(13).toString(8); // "15" (восьмеричная)
+(0x42).toString(10); // "66" (десятичная)
+(100000).toString(16); // "186a0" (шестнадцатеричная)
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/bad_regexp_flag/index.md b/files/ru/web/javascript/reference/errors/bad_regexp_flag/index.md
index d4174905ac998d..5b47af2a354600 100644
--- a/files/ru/web/javascript/reference/errors/bad_regexp_flag/index.md
+++ b/files/ru/web/javascript/reference/errors/bad_regexp_flag/index.md
@@ -30,17 +30,17 @@ var re = /pattern/flags;
или
```js
-var re = new RegExp('pattern', 'flags');
+var re = new RegExp("pattern", "flags");
```
Флаги регулярного выражения
-| Флаг | Описание |
-| ---- | ------------------------------------------------------------------------------------------------------------------------------------------- |
-| `g` | Глобальный поиск. |
-| i | Нечувствительный к регистру поиск. |
-| m | Поиск по всем строкам. |
-| u | Unicode; обрабатывать шаблон как последовательность кода Unicode |
+| Флаг | Описание |
+| ---- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `g` | Глобальный поиск. |
+| i | Нечувствительный к регистру поиск. |
+| m | Поиск по всем строкам. |
+| u | Unicode; обрабатывать шаблон как последовательность кода Unicode |
| y | Выполняет «липкий» поиск, который будет начинаться с текущей позиции в целевой строке. См. {{jsxref("RegExp.sticky", "sticky")}} |
## Примеры
@@ -67,7 +67,7 @@ let obj = {
```js example-good
let obj = {
- url: '/docs/Web'
+ url: "/docs/Web",
};
```
diff --git a/files/ru/web/javascript/reference/errors/bad_return/index.md b/files/ru/web/javascript/reference/errors/bad_return/index.md
index bf245d6a4011ad..49a4e3fc330265 100644
--- a/files/ru/web/javascript/reference/errors/bad_return/index.md
+++ b/files/ru/web/javascript/reference/errors/bad_return/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: return not in function'
+title: "SyntaxError: return not in function"
slug: Web/JavaScript/Reference/Errors/Bad_return
tags:
- JavaScript
@@ -45,12 +45,12 @@ var cheer = function(score) {
На первый взгляд кажется, что фигурные скобки расставлены правильно, но в данном примере пропущена `{` после первого оператора `if`. Правильный вариант:
```js example-good
-var cheer = function(score) {
+var cheer = function (score) {
if (score === 147) {
- return 'Максимум!';
+ return "Максимум!";
}
if (score > 100) {
- return 'Столетие!';
+ return "Столетие!";
}
};
```
diff --git a/files/ru/web/javascript/reference/errors/called_on_incompatible_type/index.md b/files/ru/web/javascript/reference/errors/called_on_incompatible_type/index.md
index 6b1091f6ab1b57..41e5ae3670ac46 100644
--- a/files/ru/web/javascript/reference/errors/called_on_incompatible_type/index.md
+++ b/files/ru/web/javascript/reference/errors/called_on_incompatible_type/index.md
@@ -33,28 +33,28 @@ TypeError: Bind должен вызываться для функции(Chrome)
### Неправильные
```js example-bad
-var mySet = new Set;
-['bar', 'baz'].forEach(mySet.add);
+var mySet = new Set();
+["bar", "baz"].forEach(mySet.add);
// mySet.add is a function, but "mySet" is not captured as this.
var myFun = function () {
console.log(this);
};
-['bar', 'baz'].forEach(myFun.bind);
+["bar", "baz"].forEach(myFun.bind);
// myFun.bind is a function, but "myFun" is not captured as this.
```
### Правильные
```js example-good
-var mySet = new Set;
-['bar', 'baz'].forEach(mySet.add.bind(mySet));
+var mySet = new Set();
+["bar", "baz"].forEach(mySet.add.bind(mySet));
// This works due to binding "mySet" as this.
var myFun = function () {
console.log(this);
};
-['bar', 'baz'].forEach(x => myFun.bind(x));
+["bar", "baz"].forEach((x) => myFun.bind(x));
// This works using the "bind" function. It creates a lambda forwarding the argument.
```
diff --git a/files/ru/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md b/files/ru/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md
index dcc2ca2025c49d..65fd488cd990d2 100644
--- a/files/ru/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md
+++ b/files/ru/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md
@@ -35,7 +35,7 @@ ReferenceError: 'x' is not defined (Chrome)
function test() {
let foo = 33;
if (true) {
- let foo = (foo + 55);
+ let foo = foo + 55;
// ReferenceError: can't access lexical
// declaration `foo' before initialization
}
@@ -48,11 +48,11 @@ test();
Чтобы изменить "foo" в теле выражения if, надо убрать ключевое слово `let` и таким образом избавиться от повторного объявления.
```js example-good
-function test(){
- let foo = 33;
- if (true) {
- foo = (foo + 55);
- }
+function test() {
+ let foo = 33;
+ if (true) {
+ foo = foo + 55;
+ }
}
test();
```
diff --git a/files/ru/web/javascript/reference/errors/cant_assign_to_property/index.md b/files/ru/web/javascript/reference/errors/cant_assign_to_property/index.md
index 562bf251e9ac9a..08b0f42d889958 100644
--- a/files/ru/web/javascript/reference/errors/cant_assign_to_property/index.md
+++ b/files/ru/web/javascript/reference/errors/cant_assign_to_property/index.md
@@ -3,6 +3,7 @@ title: 'TypeError: can''t assign to property "x" on "y": not an object'
slug: Web/JavaScript/Reference/Errors/Cant_assign_to_property
translation_of: Web/JavaScript/Reference/Errors/Cant_assign_to_property
---
+
{{jsSidebar("Errors")}}Ошибка строгого режима JavaScript "can't assign to property" ("невозможно присвоить свойство") происходит в тот момент, когда вы пытаетесь создать свойство примитивного типа данных (такого как символ, строка, число или булевое значение). Примитивные типы данных не могут содержать никаких свойств.
## Message
@@ -27,7 +28,7 @@ The problem might be that an unexpected value is flowing at an unexpected place,
### Invalid cases
```js example-bad
-'use strict';
+"use strict";
var foo = "my string";
// The following line does nothing if not in strict mode.
@@ -39,7 +40,7 @@ foo.bar = {}; // TypeError: can't assign to property "bar" on "my string": not a
Either fix the code to prevent the [primitive](/ru/docs/Glossary/primitive) from being used in such places, or fix the issue is to create the object equivalent {{jsxref("Object")}}.
```js example-good
-'use strict';
+"use strict";
var foo = new String("my string");
foo.bar = {};
diff --git a/files/ru/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md b/files/ru/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md
index c619995c0eea40..390fbba22b7a2f 100644
--- a/files/ru/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md
+++ b/files/ru/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md
@@ -33,34 +33,32 @@ TypeError: Cannot define property: "x", object is not extensible. (Chrome)
В строгом режиме при попытке добавить новые свойства в нерасширяемый объект возникает ошибка TypeError. В нестрогом режиме добавление свойства "x" игнорируется.
```js example-bad
-'use strict';
+"use strict";
var obj = {};
Object.preventExtensions(obj);
-obj.x = 'foo';
+obj.x = "foo";
// TypeError: can't define property "x": "obj" is not extensible
```
В обеих, строгом и нестрогом режимах, вызов {{jsxref("Object.defineProperty()")}} вызывает исключение при добавлении нового свойства в нерасширяемый объект.
```js example-bad
-var obj = { };
+var obj = {};
Object.preventExtensions(obj);
-Object.defineProperty(obj,
- 'x', { value: "foo" }
-);
+Object.defineProperty(obj, "x", { value: "foo" });
// TypeError: can't define property "x": "obj" is not extensible
```
Чтобы исправить эту ошибку, необходимо удалить вызов {{jsxref("Object.preventExtensions()")}} полностью или переместить его в положение, чтобы сначала свойство добавлялось, а потом объект помечался как нерасширяемый. Конечно вы также можете удалить свойство, которое пытались добавить, если оно вам не нужно.
```js example-good
-'use strict';
+"use strict";
var obj = {};
-obj.x = 'foo'; // add property first and only then prevent extensions
+obj.x = "foo"; // add property first and only then prevent extensions
Object.preventExtensions(obj);
```
diff --git a/files/ru/web/javascript/reference/errors/cant_delete/index.md b/files/ru/web/javascript/reference/errors/cant_delete/index.md
index f149d564e741f6..ac44be6c98dffc 100644
--- a/files/ru/web/javascript/reference/errors/cant_delete/index.md
+++ b/files/ru/web/javascript/reference/errors/cant_delete/index.md
@@ -5,6 +5,7 @@ title: >-
slug: Web/JavaScript/Reference/Errors/Cant_delete
translation_of: Web/JavaScript/Reference/Errors/Cant_delete
---
+
{{jsSidebar("Errors")}}
## Сообщение
@@ -30,25 +31,25 @@ TypeError: не удаётся удалить свойство "x" из #-
slug: Web/JavaScript/Reference/Errors/Cant_redefine_property
translation_of: Web/JavaScript/Reference/Errors/Cant_redefine_property
---
+
{{jsSidebar("Errors")}}
## Сообщения
@@ -31,9 +32,9 @@ The {{jsxref("Object.defineProperty()")}} создаёт не настраива
```js example-bad
var obj = Object.create({});
-Object.defineProperty(obj, "foo", {value: "bar"});
+Object.defineProperty(obj, "foo", { value: "bar" });
-Object.defineProperty(obj, "foo", {value: "baz"});
+Object.defineProperty(obj, "foo", { value: "baz" });
// TypeError: не удаётся переопределить не настраиваемое свойство "foo"
```
@@ -41,8 +42,8 @@ Object.defineProperty(obj, "foo", {value: "baz"});
```js example-good
var obj = Object.create({});
-Object.defineProperty(obj, "foo", {value: "bar", configurable: true});
-Object.defineProperty(obj, "foo", {value: "baz", configurable: true});
+Object.defineProperty(obj, "foo", { value: "bar", configurable: true });
+Object.defineProperty(obj, "foo", { value: "baz", configurable: true });
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/cyclic_object_value/index.md b/files/ru/web/javascript/reference/errors/cyclic_object_value/index.md
index 06c24037a537e4..7653c077c0fccd 100644
--- a/files/ru/web/javascript/reference/errors/cyclic_object_value/index.md
+++ b/files/ru/web/javascript/reference/errors/cyclic_object_value/index.md
@@ -1,5 +1,5 @@
---
-title: 'TypeError: cyclic object value'
+title: "TypeError: cyclic object value"
slug: Web/JavaScript/Reference/Errors/Cyclic_object_value
tags:
- Ошибка
@@ -30,7 +30,7 @@ TypeError: циклическая ссылка в аргументе значе
В круговой структуре как эта
```js
-var circularReference = {otherData: 123};
+var circularReference = { otherData: 123 };
circularReference.myself = circularReference;
```
diff --git a/files/ru/web/javascript/reference/errors/delete_in_strict_mode/index.md b/files/ru/web/javascript/reference/errors/delete_in_strict_mode/index.md
index e98fab734909af..bd900cbc05c7e3 100644
--- a/files/ru/web/javascript/reference/errors/delete_in_strict_mode/index.md
+++ b/files/ru/web/javascript/reference/errors/delete_in_strict_mode/index.md
@@ -6,6 +6,7 @@ title: >-
slug: Web/JavaScript/Reference/Errors/Delete_in_strict_mode
translation_of: Web/JavaScript/Reference/Errors/Delete_in_strict_mode
---
+
{{jsSidebar("Errors")}}
## Сообщение
@@ -35,7 +36,7 @@ SyntaxError: удаление неполного идентификатора в
Попытка удалить простую переменную не работает в JavaScript и выдаёт ошибку в строгом режиме:
```js example-bad
-'use strict';
+"use strict";
var x;
@@ -49,7 +50,7 @@ delete x;
Чтобы освободить содержимое переменной, задайте для неё значение {{jsxref("null")}}:
```js example-good
-'use strict';
+"use strict";
var x;
diff --git a/files/ru/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md b/files/ru/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md
index 3ad54ec2628f86..83895f4443fbb4 100644
--- a/files/ru/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md
+++ b/files/ru/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md
@@ -1,5 +1,5 @@
---
-title: 'Ошибка Ссылки: устаревший вызывающий объект или использование аргументов'
+title: "Ошибка Ссылки: устаревший вызывающий объект или использование аргументов"
slug: Web/JavaScript/Reference/Errors/Deprecated_caller_or_arguments_usage
tags:
- JavaScript
@@ -35,13 +35,13 @@ TypeError(Ошибка Типа): 'callee' и 'caller' (не может быть
{{jsxref("Function.caller")}} и [`arguments.callee.caller`](/ru/docs/Web/JavaScript/Reference/Functions/arguments/callee) являются устаревшими (Дополнительные сведения см. в справочных статьях).
```js example-bad
-'use strict';
+"use strict";
function myFunc() {
if (myFunc.caller == null) {
- return 'The function was called from the top!';
+ return "The function was called from the top!";
} else {
- return 'This function\'s caller was ' + myFunc.caller;
+ return "This function's caller was " + myFunc.caller;
}
}
@@ -55,19 +55,23 @@ myFunc();
{{jsxref("Function.arguments")}} является устаревшим (Дополнительные сведения см. в справочной статье).
```js example-bad
-'use strict';
+"use strict";
-function f(n) { g(n - 1); }
+function f(n) {
+ g(n - 1);
+}
function g(n) {
- console.log('before: ' + g.arguments[0]);
- if (n > 0) { f(n); }
- console.log('after: ' + g.arguments[0]);
+ console.log("before: " + g.arguments[0]);
+ if (n > 0) {
+ f(n);
+ }
+ console.log("after: " + g.arguments[0]);
}
f(2);
-console.log('returned: ' + g.arguments);
+console.log("returned: " + g.arguments);
// Warning: ReferenceError: использование устаревших аргументов
```
diff --git a/files/ru/web/javascript/reference/errors/deprecated_octal/index.md b/files/ru/web/javascript/reference/errors/deprecated_octal/index.md
index 305bd3a7bb5154..1f91511a27d2ac 100644
--- a/files/ru/web/javascript/reference/errors/deprecated_octal/index.md
+++ b/files/ru/web/javascript/reference/errors/deprecated_octal/index.md
@@ -63,7 +63,7 @@ for octal literals use the "0o" prefix instead
Вместо escape-последовательностей можно использовать шестнадцатеричные escape-последовательности:
```js
-'\xA9';
+"\xA9";
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/equal_as_assign/index.md b/files/ru/web/javascript/reference/errors/equal_as_assign/index.md
index 8aa90c437b2132..a0d5b5f1c076ec 100644
--- a/files/ru/web/javascript/reference/errors/equal_as_assign/index.md
+++ b/files/ru/web/javascript/reference/errors/equal_as_assign/index.md
@@ -28,7 +28,7 @@ Warning: SyntaxError: тест на равенство (==) опечатка к
Рекомендуется не использовать простые назначения в условном выражении (например, if...else), поскольку при просмотре кода назначение можно спутать с равенством. Например, не используйте следующий код:
-```js example-bad
+```js-nolint example-bad
if (x = y) {
// делать правильные вещи
}
diff --git a/files/ru/web/javascript/reference/errors/getter_only/index.md b/files/ru/web/javascript/reference/errors/getter_only/index.md
index 23869cad38b51c..aea8c6870aa491 100644
--- a/files/ru/web/javascript/reference/errors/getter_only/index.md
+++ b/files/ru/web/javascript/reference/errors/getter_only/index.md
@@ -5,6 +5,7 @@ title: >-
slug: Web/JavaScript/Reference/Errors/Getter_only
translation_of: Web/JavaScript/Reference/Errors/Getter_only
---
+
{{jsSidebar("Errors")}}
## Сообщения
@@ -32,11 +33,11 @@ TypeError: не удаётся установить свойство "prop" из
function Archiver() {
var temperature = null;
- Object.defineProperty(this, 'temperature', {
- get: function() {
- console.log('get!');
+ Object.defineProperty(this, "temperature", {
+ get: function () {
+ console.log("get!");
return temperature;
- }
+ },
});
}
@@ -56,18 +57,20 @@ function Archiver() {
var temperature = null;
var archive = [];
- Object.defineProperty(this, 'temperature', {
- get: function() {
- console.log('get!');
+ Object.defineProperty(this, "temperature", {
+ get: function () {
+ console.log("get!");
return temperature;
},
- set: function(value) {
+ set: function (value) {
temperature = value;
archive.push({ val: temperature });
- }
+ },
});
- this.getArchive = function() { return archive; };
+ this.getArchive = function () {
+ return archive;
+ };
}
var arc = new Archiver();
diff --git a/files/ru/web/javascript/reference/errors/identifier_after_number/index.md b/files/ru/web/javascript/reference/errors/identifier_after_number/index.md
index 220635dcf93bea..0027a251efa097 100644
--- a/files/ru/web/javascript/reference/errors/identifier_after_number/index.md
+++ b/files/ru/web/javascript/reference/errors/identifier_after_number/index.md
@@ -5,6 +5,7 @@ title: >-
slug: Web/JavaScript/Reference/Errors/Identifier_after_number
translation_of: Web/JavaScript/Reference/Errors/Identifier_after_number
---
+
{{JSSidebar("Errors")}}
## Сообщение
@@ -45,7 +46,7 @@ alert(1.foo);
Вы можете переназвать вашу переменную чтобы избежать ведущего числа.
```js example-good
-var life1 = 'foo';
+var life1 = "foo";
var foo = life1;
```
diff --git a/files/ru/web/javascript/reference/errors/illegal_character/index.md b/files/ru/web/javascript/reference/errors/illegal_character/index.md
index 64e47f38181fb2..7f51bc4f127275 100644
--- a/files/ru/web/javascript/reference/errors/illegal_character/index.md
+++ b/files/ru/web/javascript/reference/errors/illegal_character/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: illegal character'
+title: "SyntaxError: illegal character"
slug: Web/JavaScript/Reference/Errors/Illegal_character
translation_of: Web/JavaScript/Reference/Errors/Illegal_character
---
@@ -19,7 +19,7 @@ SyntaxError: Invalid or unexpected token (Chrome)
## Что пошло не так?
-Присутствует недопустимый или неожиданный знак, который не принадлежит данной позиции в коде. Используйте редактор, поддерживающий подсветку синтаксиса, и внимательно проверьте ваш код на предмет таких несовпадений, как знак минус (` - `) вместо тире (` – `) или простые кавычки (` " `) вместо нестандартных знаков цитирования (` “ `).
+Присутствует недопустимый или неожиданный знак, который не принадлежит данной позиции в коде. Используйте редактор, поддерживающий подсветку синтаксиса, и внимательно проверьте ваш код на предмет таких несовпадений, как знак минус (`-`) вместо тире (`–`) или простые кавычки (`"`) вместо нестандартных знаков цитирования (`“`).
## Примеры
@@ -55,7 +55,7 @@ var colors = ['#000', #333', '#666'];
Добавляем пропущенную кавычку для `'#333'` .
```js example-good
-var colors = ['#000', '#333', '#666'];
+var colors = ["#000", "#333", "#666"];
```
### Скрытые символы
diff --git a/files/ru/web/javascript/reference/errors/in_operator_no_object/index.md b/files/ru/web/javascript/reference/errors/in_operator_no_object/index.md
index 2d651dc6ae28ed..03ce21422d91e1 100644
--- a/files/ru/web/javascript/reference/errors/in_operator_no_object/index.md
+++ b/files/ru/web/javascript/reference/errors/in_operator_no_object/index.md
@@ -68,7 +68,7 @@ var foo = { baz: "bar" };
Будьте осторожны при использовании оператора для поиска {{jsxref("Array")}} объекты. the `in` оператор проверяет номер индекса, а не его значение.
```js
-var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
+var trees = ["redwood", "bay", "cedar", "oak", "maple"];
3 in trees; // true
"oak" in trees; // false
```
diff --git a/files/ru/web/javascript/reference/errors/invalid_array_length/index.md b/files/ru/web/javascript/reference/errors/invalid_array_length/index.md
index 963e14fd2bd811..5ef005f6a3eb90 100644
--- a/files/ru/web/javascript/reference/errors/invalid_array_length/index.md
+++ b/files/ru/web/javascript/reference/errors/invalid_array_length/index.md
@@ -1,5 +1,5 @@
---
-title: 'RangeError: invalid array length'
+title: "RangeError: invalid array length"
slug: Web/JavaScript/Reference/Errors/Invalid_array_length
tags:
- JavaScript
@@ -38,23 +38,23 @@ RangeError: Invalid array buffer length (Chrome)
## Примеры
```js example-bad
-new Array(Math.pow(2, 40))
-new Array(-1)
-new ArrayBuffer(Math.pow(2, 32))
-new ArrayBuffer(-1)
+new Array(Math.pow(2, 40));
+new Array(-1);
+new ArrayBuffer(Math.pow(2, 32));
+new ArrayBuffer(-1);
let a = [];
-a.length = a.length - 1; // установка длинны -1
+a.length = a.length - 1; // установка длинны -1
let b = new Array(Math.pow(2, 32) - 1);
-b.length = b.length + 1; // установка длинны 2^32
+b.length = b.length + 1; // установка длинны 2^32
```
```js example-good
-[ Math.pow(2, 40) ] // [ 1099511627776 ]
-[ -1 ] // [ -1 ]
-new ArrayBuffer(Math.pow(2, 32) - 1)
-new ArrayBuffer(0)
+[Math.pow(2, 40)]; // [ 1099511627776 ]
+[-1]; // [ -1 ]
+new ArrayBuffer(Math.pow(2, 32) - 1);
+new ArrayBuffer(0);
let a = [];
a.length = Math.max(0, a.length - 1);
diff --git a/files/ru/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md b/files/ru/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md
index 614b4e4b45a9f2..76a86ac159b0bf 100644
--- a/files/ru/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md
+++ b/files/ru/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md
@@ -1,5 +1,5 @@
---
-title: 'ReferenceError: invalid assignment left-hand side'
+title: "ReferenceError: invalid assignment left-hand side"
slug: Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side
tags:
- JavaScript
@@ -7,6 +7,7 @@ tags:
- Ошибки
translation_of: Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side
---
+
{{jsSidebar("Errors")}}
## Сообщение
@@ -41,12 +42,10 @@ var str = 'Привет, '
```js example-good
if (Math.PI == 3 || Math.PI == 4) {
- console.log('исключено!');
+ console.log("исключено!");
}
-var str = 'Привет '
-+ 'с другой '
-+ 'стороны!';
+var str = "Привет " + "с другой " + "стороны!";
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/invalid_const_assignment/index.md b/files/ru/web/javascript/reference/errors/invalid_const_assignment/index.md
index 09bd0623aa2dc4..e1bd3ca2192c9b 100644
--- a/files/ru/web/javascript/reference/errors/invalid_const_assignment/index.md
+++ b/files/ru/web/javascript/reference/errors/invalid_const_assignment/index.md
@@ -79,14 +79,14 @@ function setupBigScreenEnvironment() {
Объявление const создаёт ссылку только для чтения на значение. Это не означает, что значение, которое он содержит, является неизменяемым, просто идентификатор переменной не может быть переназначен. Например, если содержимое является объектом, это означает, что сам объект все ещё может быть изменён. Это означает, что нельзя изменить значение, хранящееся в переменной:
```js example-bad
-const obj = {foo: 'bar'};
-obj = {foo: 'baz'}; // TypeError: invalid assignment to const `obj'
+const obj = { foo: "bar" };
+obj = { foo: "baz" }; // TypeError: invalid assignment to const `obj'
```
Но можно изменить свойства в переменной:
```js example-good
-obj.foo = 'baz';
+obj.foo = "baz";
obj; // Object { foo: "baz" }
```
diff --git a/files/ru/web/javascript/reference/errors/invalid_date/index.md b/files/ru/web/javascript/reference/errors/invalid_date/index.md
index a7f62343cfd610..b22df2885a2190 100644
--- a/files/ru/web/javascript/reference/errors/invalid_date/index.md
+++ b/files/ru/web/javascript/reference/errors/invalid_date/index.md
@@ -1,5 +1,5 @@
---
-title: 'RangeError: invalid date'
+title: "RangeError: invalid date"
slug: Web/JavaScript/Reference/Errors/Invalid_date
tags:
- Errors
@@ -33,15 +33,15 @@ RangeError: Provided date is not in valid range (Chrome)
Неопознанные строки или даты, содержащие недопустимые значения элементов в строках, отформатированных ISO, обычно возвращают [`NaN`](/ru/docs/Web/JavaScript/Reference/Global_Objects/NaN). Тем не менее, в зависимости от реализации, при несоответствии строкам формата ISO, может также возникнуть ошибка `RangeError: invalid date`, например в следующих случаях, в Firefox.
```js example-bad
-new Date('foo-bar 2014');
-new Date('2014-25-23').toISOString();
-new Date('foo-bar 2014').toString();
+new Date("foo-bar 2014");
+new Date("2014-25-23").toISOString();
+new Date("foo-bar 2014").toString();
```
Это, без сомнения, вернёт {{jsxref("NaN")}} в Firefox:
```js example-bad
-Date.parse('foo-bar 2014'); // NaN
+Date.parse("foo-bar 2014"); // NaN
```
Для получения более подробной информации, смотрите документацию по {{jsxref("Date.parse()")}}
@@ -49,7 +49,7 @@ Date.parse('foo-bar 2014'); // NaN
### Верная запись
```js example-good
-new Date('05 October 2011 14:48 UTC');
+new Date("05 October 2011 14:48 UTC");
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/invalid_for-in_initializer/index.md b/files/ru/web/javascript/reference/errors/invalid_for-in_initializer/index.md
index 5ae4c9c631a9ac..e775a9ac47405a 100644
--- a/files/ru/web/javascript/reference/errors/invalid_for-in_initializer/index.md
+++ b/files/ru/web/javascript/reference/errors/invalid_for-in_initializer/index.md
@@ -6,6 +6,7 @@ title: >-
slug: Web/JavaScript/Reference/Errors/Invalid_for-in_initializer
translation_of: Web/JavaScript/Reference/Errors/Invalid_for-in_initializer
---
+
{{jsSidebar("Errors")}}
## Message
@@ -47,7 +48,7 @@ for (var i = 0 in obj) {
```js example-good
"use strict";
-var obj = {a: 1, b: 2, c: 3 };
+var obj = { a: 1, b: 2, c: 3 };
for (var i in obj) {
console.log(obj[i]);
@@ -59,7 +60,7 @@ for (var i in obj) {
Цикл for...in не должен использоваться для итерации массива. Вы намеревались использовать цикл for вместо цикла for-in для итерации {{jsxref("Array")}}? Цикл for позволяет также установить инициализатор:
```js example-good
-var arr = [ "a", "b", "c" ]
+var arr = ["a", "b", "c"];
for (var i = 2; i < arr.length; i++) {
console.log(arr[i]);
diff --git a/files/ru/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md b/files/ru/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md
index 46b1c22f21b740..4a22e9c1b9e8f2 100644
--- a/files/ru/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md
+++ b/files/ru/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md
@@ -29,28 +29,28 @@ The [`instanceof` operator](/ru/docs/Web/JavaScript/Reference/Operators/instance
```js example-bad
"test" instanceof ""; // TypeError: invalid 'instanceof' operand ""
-42 instanceof 0; // TypeError: invalid 'instanceof' operand 0
+42 instanceof 0; // TypeError: invalid 'instanceof' operand 0
function Foo() {}
-var f = Foo(); // Foo() is called and returns undefined
+var f = Foo(); // Foo() is called and returns undefined
var x = new Foo();
-x instanceof f; // TypeError: invalid 'instanceof' operand f
-x instanceof x; // TypeError: x is not a function
+x instanceof f; // TypeError: invalid 'instanceof' operand f
+x instanceof x; // TypeError: x is not a function
```
Чтобы исправить эти ошибки, необходимо либо заменить оператор `instanceof` оператором `typeof`, либо убедиться, что вместо результата его вычисления используется имя функции.
```js example-good
typeof "test" == "string"; // true
-typeof 42 == "number" // true
+typeof 42 == "number"; // true
function Foo() {}
-var f = Foo; // Do not call Foo.
+var f = Foo; // Do not call Foo.
var x = new Foo();
-x instanceof f; // true
-x instanceof Foo; // true
+x instanceof f; // true
+x instanceof Foo; // true
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/is_not_iterable/index.md b/files/ru/web/javascript/reference/errors/is_not_iterable/index.md
index 07bb3ae24393eb..921b8a32e629a4 100644
--- a/files/ru/web/javascript/reference/errors/is_not_iterable/index.md
+++ b/files/ru/web/javascript/reference/errors/is_not_iterable/index.md
@@ -1,5 +1,5 @@
---
-title: 'TypeError: ''x'' is not iterable (Тип ошибки ''x'' не является итерационным)'
+title: "TypeError: 'x' is not iterable (Тип ошибки 'x' не является итерационным)"
slug: Web/JavaScript/Reference/Errors/is_not_iterable
translation_of: Web/JavaScript/Reference/Errors/is_not_iterable
---
@@ -28,43 +28,42 @@ TypeError: 'x' не является функцией или её возвращ
В JavaScript, {{jsxref("object")}} не повторяется, если они реализуют итерационный протокол . Поэтому нельзя использовать for...of для перебора свойств объекта.
```js example-bad
-var obj = { 'France': 'Paris', 'England': 'London' };
-for (let p of obj) { // TypeError: obj не является итерационным
- // …
+var obj = { France: "Paris", England: "London" };
+for (let p of obj) {
+ // TypeError: obj не является итерационным
+ // …
}
```
Вместо этого вы должны использовать {{jsxref("Object.keys")}} или {{jsxref("Object.entries")}}, для итерации по свойствам или записям объекта.
```js example-good
-var obj = { 'France': 'Paris', 'England': 'London' };
+var obj = { France: "Paris", England: "London" };
// Iterate over the property names:
for (let country of Object.keys(obj)) {
- var capital = obj[country];
- console.log(country, capital);
+ var capital = obj[country];
+ console.log(country, capital);
}
for (const [country, capital] of Object.entries(obj))
- console.log(country, capital);
+ console.log(country, capital);
```
Другим вариантом для этого варианта использования может быть использование {{jsxref("Map")}}:
```js example-good
-var map = new Map;
-map.set('France', 'Paris');
-map.set('England', 'London');
+var map = new Map();
+map.set("France", "Paris");
+map.set("England", "London");
// Iterate over the property names:
for (let country of map.keys()) {
- let capital = map[country];
- console.log(country, capital);
+ let capital = map[country];
+ console.log(country, capital);
}
-for (let capital of map.values())
- console.log(capital);
+for (let capital of map.values()) console.log(capital);
-for (const [country, capital] of map.entries())
- console.log(country, capital);
+for (const [country, capital] of map.entries()) console.log(country, capital);
```
### Итерация по генератору
@@ -78,19 +77,18 @@ function* generate(a, b) {
}
for (let x of generate) // TypeError: генерация не является итерационной
- console.log(x);
+ console.log(x);
```
Если они не вызываются, то объект {{jsxref("Function")}}, соответствующий генератору, можно вызвать, но нельзя выполнить итерацию. Вызов генератора создаёт итерационный объект, который будет выполнять итерацию по значениям, полученным во время выполнения генератора.
```js example-good
function* generate(a, b) {
- yield a;
- yield b;
+ yield a;
+ yield b;
}
-for (let x of generate(1,2))
- console.log(x);
+for (let x of generate(1, 2)) console.log(x);
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/json_bad_parse/index.md b/files/ru/web/javascript/reference/errors/json_bad_parse/index.md
index 9ff8ccb899ac6b..a134baa6703162 100644
--- a/files/ru/web/javascript/reference/errors/json_bad_parse/index.md
+++ b/files/ru/web/javascript/reference/errors/json_bad_parse/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: JSON.parse: bad parsing'
+title: "SyntaxError: JSON.parse: bad parsing"
slug: Web/JavaScript/Reference/Errors/JSON_bad_parse
tags:
- Errors
@@ -63,7 +63,7 @@ SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data
Обе строки выдадут ошибку типа SyntaxError:
```js example-bad
-JSON.parse('[1, 2, 3, 4,]');
+JSON.parse("[1, 2, 3, 4,]");
JSON.parse('{"foo": 1,}');
// SyntaxError JSON.parse: unexpected character
// at line 1 column 14 of the JSON data
@@ -72,7 +72,7 @@ JSON.parse('{"foo": 1,}');
Необходимо убрать последние запятые в строках и тогда ошибки не будет:
```js example-good
-JSON.parse('[1, 2, 3, 4]');
+JSON.parse("[1, 2, 3, 4]");
JSON.parse('{"foo": 1}');
```
diff --git a/files/ru/web/javascript/reference/errors/malformed_uri/index.md b/files/ru/web/javascript/reference/errors/malformed_uri/index.md
index b04b9910f40d92..f646a190b60e81 100644
--- a/files/ru/web/javascript/reference/errors/malformed_uri/index.md
+++ b/files/ru/web/javascript/reference/errors/malformed_uri/index.md
@@ -1,5 +1,5 @@
---
-title: 'URIError: malformed URI sequence'
+title: "URIError: malformed URI sequence"
slug: Web/JavaScript/Reference/Errors/Malformed_URI
translation_of: Web/JavaScript/Reference/Errors/Malformed_URI
---
@@ -28,17 +28,17 @@ URIError: URI malformed (Chrome)
Кодирование заменяет каждое вхождение конкретного символа одним, двумя, тремя или четырьмя управляющими последовательностями, представленными стандартом UTF-8. {{jsxref("URIError")}} возникнет, при попытке кодирования суррогата, не являющегося частью high-low пары, например:
```js example-bad
-encodeURI('\uD800');
+encodeURI("\uD800");
// "URIError: malformed URI sequence"
-encodeURI('\uDFFF');
+encodeURI("\uDFFF");
// "URIError: malformed URI sequence"
```
Нормальная high-low пара. Например:
```js example-good
-encodeURI('\uD800\uDFFF');
+encodeURI("\uD800\uDFFF");
// "%F0%90%8F%BF"
```
@@ -47,14 +47,14 @@ encodeURI('\uD800\uDFFF');
Декодирование заменяет каждую управляющую последовательность в закодированном URI компоненте символом, который она представляет. Если такого символа нет, возникнет ошибка:
```js example-bad
-decodeURIComponent('%E0%A4%A');
+decodeURIComponent("%E0%A4%A");
// "URIError: malformed URI sequence"
```
Правильный вариант обычно выглядит так:
```js example-good
-decodeURIComponent('JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B');
+decodeURIComponent("JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
// "JavaScript_шеллы"
```
diff --git a/files/ru/web/javascript/reference/errors/missing_bracket_after_list/index.md b/files/ru/web/javascript/reference/errors/missing_bracket_after_list/index.md
index 14e245f839ba9b..4c6b82d6bf22a2 100644
--- a/files/ru/web/javascript/reference/errors/missing_bracket_after_list/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_bracket_after_list/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing ] after element list'
+title: "SyntaxError: missing ] after element list"
slug: Web/JavaScript/Reference/Errors/Missing_bracket_after_list
tags:
- JavaScript
@@ -45,13 +45,9 @@ var data = [{foo: 'bar'} {bar: 'foo'}];
```js example-good
var list = [1, 2];
-var instruments = [
- 'Укулеле',
- 'Гитара',
- 'Пианино'
-];
+var instruments = ["Укулеле", "Гитара", "Пианино"];
-var data = [{foo: 'bar'}, {bar: 'foo'}];
+var data = [{ foo: "bar" }, { bar: "foo" }];
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/missing_colon_after_property_id/index.md b/files/ru/web/javascript/reference/errors/missing_colon_after_property_id/index.md
index 54ac9a05a851ec..1951eb044c53c4 100644
--- a/files/ru/web/javascript/reference/errors/missing_colon_after_property_id/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_colon_after_property_id/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing : after property id'
+title: "SyntaxError: missing : after property id"
slug: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id
translation_of: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id
---
@@ -21,7 +21,7 @@ SyntaxError: missing : after property id
При создании объекта с помощью [инициализатора объекта](/ru/docs/Web/JavaScript/Reference/Operators/Object_initializer), двоеточие (`:`) разделяет ключи и значения свойств объекта.
```js
-var obj = { propertyKey: 'value' };
+var obj = { propertyKey: "value" };
```
## Примеры
@@ -38,12 +38,12 @@ var obj = { propertyKey = 'value' };
Корректно будет использовать двоеточие или квадратные скобки для назначения нового свойства после того, как объект уже был создан.
```js example-good
-var obj = { propertyKey: 'value' };
+var obj = { propertyKey: "value" };
// or alternatively
-var obj = { };
-obj['propertyKey'] = 'value';
+var obj = {};
+obj["propertyKey"] = "value";
```
### Пустые свойства
@@ -73,7 +73,7 @@ var obj = { 'b'+'ar': 'foo' };
Поместите выражение в скобки `[]`:
```js example-good
-var obj = { ['b'+'ar']: 'foo' };
+var obj = { ["b" + "ar"]: "foo" };
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/missing_curly_after_function_body/index.md b/files/ru/web/javascript/reference/errors/missing_curly_after_function_body/index.md
index dd2b04ea34a60a..4e3736fec0b050 100644
--- a/files/ru/web/javascript/reference/errors/missing_curly_after_function_body/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_curly_after_function_body/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing } after function body'
+title: "SyntaxError: missing } after function body"
slug: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body
tags:
- JavaScript
@@ -42,7 +42,7 @@ var charge = function() {
Правильный код:
```js example-good
-var charge = function() {
+var charge = function () {
if (sunny) {
useSolarCells();
} else {
@@ -60,7 +60,7 @@ var charge = function() {
Зачастую облегчить поиск ошибок можно, проверив отступы ещё раз или расставив их по-другому.
```js example-good
-(function() {
+(function () {
if (true) {
return false;
}
diff --git a/files/ru/web/javascript/reference/errors/missing_curly_after_property_list/index.md b/files/ru/web/javascript/reference/errors/missing_curly_after_property_list/index.md
index 966167c35d9289..4c9030fcbbdb73 100644
--- a/files/ru/web/javascript/reference/errors/missing_curly_after_property_list/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_curly_after_property_list/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing } after property list'
+title: "SyntaxError: missing } after property list"
slug: Web/JavaScript/Reference/Errors/Missing_curly_after_property_list
tags:
- JavaScript
@@ -44,7 +44,7 @@ var obj = {
var obj = {
a: 1,
b: { myProp: 2 },
- c: 3
+ c: 3,
};
```
diff --git a/files/ru/web/javascript/reference/errors/missing_formal_parameter/index.md b/files/ru/web/javascript/reference/errors/missing_formal_parameter/index.md
index 67b0f50c251030..2f30cbd601a6c6 100644
--- a/files/ru/web/javascript/reference/errors/missing_formal_parameter/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_formal_parameter/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing formal parameter( отсутствует формальный параметр)'
+title: "SyntaxError: missing formal parameter( отсутствует формальный параметр)"
slug: Web/JavaScript/Reference/Errors/Missing_formal_parameter
translation_of: Web/JavaScript/Reference/Errors/Missing_formal_parameter
---
@@ -48,15 +48,15 @@ function log({ obj: "value"}) {
```js example-good
function square(number) {
return number * number;
-};
+}
function greet(greeting) {
return greeting;
-};
+}
function log(arg) {
- console.log(arg)
-};
+ console.log(arg);
+}
```
Затем можно вызвать эти функции с аргументами, которые вам нравятся:
@@ -66,7 +66,7 @@ square(2); // 4
greet("Howdy"); // "Howdy"
-log({obj: "value"}); // Object { obj: "value" }
+log({ obj: "value" }); // Object { obj: "value" }
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/missing_initializer_in_const/index.md b/files/ru/web/javascript/reference/errors/missing_initializer_in_const/index.md
index 127e6c46a9c565..7f776a4e9bc8d5 100644
--- a/files/ru/web/javascript/reference/errors/missing_initializer_in_const/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_initializer_in_const/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing = in const declaration'
+title: "SyntaxError: missing = in const declaration"
slug: Web/JavaScript/Reference/Errors/Missing_initializer_in_const
translation_of: Web/JavaScript/Reference/Errors/Missing_initializer_in_const
---
diff --git a/files/ru/web/javascript/reference/errors/missing_name_after_dot_operator/index.md b/files/ru/web/javascript/reference/errors/missing_name_after_dot_operator/index.md
index 12ee85fa2f6f02..bce3df646b9350 100644
--- a/files/ru/web/javascript/reference/errors/missing_name_after_dot_operator/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_name_after_dot_operator/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing name after . operator(отсутствует имя после. оператора)'
+title: "SyntaxError: missing name after . operator(отсутствует имя после. оператора)"
slug: Web/JavaScript/Reference/Errors/Missing_name_after_dot_operator
translation_of: Web/JavaScript/Reference/Errors/Missing_name_after_dot_operator
---
diff --git a/files/ru/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md b/files/ru/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md
index b36f88cc00e413..5b784d1702d590 100644
--- a/files/ru/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md
@@ -32,7 +32,7 @@ console.log('PI: ' Math.PI);
Можно скорректировать вызов функции `log` добавлением оператора "`+`":
```js example-good
-console.log('PI: ' + Math.PI);
+console.log("PI: " + Math.PI);
// "PI: 3.141592653589793"
```
diff --git a/files/ru/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md b/files/ru/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md
index af97b420b777a6..55175b88999cef 100644
--- a/files/ru/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing ) after condition'
+title: "SyntaxError: missing ) after condition"
slug: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_condition
tags:
- Error
@@ -65,7 +65,7 @@ if (done is true) {
```js example-good
if (done === true) {
- console.log("мы сделали!");
+ console.log("мы сделали!");
}
```
diff --git a/files/ru/web/javascript/reference/errors/missing_semicolon_before_statement/index.md b/files/ru/web/javascript/reference/errors/missing_semicolon_before_statement/index.md
index 638d581d7ac128..4a1c1278f5a6df 100644
--- a/files/ru/web/javascript/reference/errors/missing_semicolon_before_statement/index.md
+++ b/files/ru/web/javascript/reference/errors/missing_semicolon_before_statement/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing ; before statement'
+title: "SyntaxError: missing ; before statement"
slug: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement
tags:
- JavaScript
@@ -34,14 +34,14 @@ SyntaxError: missing ; before statement (Firefox)
Эта ошибка может легко возникнуть, если не экранировать строку правильным образом, из-за чего JavaScript будет рассматривать это место как конец строки. Например:
-```js example-bad
+```js-nolint example-bad
var foo = 'Tom's bar';
// SyntaxError: missing ; before statement
```
Можно использовать двойные кавычки или экранировать апостроф:
-```js example-good
+```js-nolint example-good
var foo = "Tom's bar";
var foo = 'Tom\'s bar';
```
@@ -62,10 +62,10 @@ var array[0] = 'всем'; // SyntaxError missing ; before statement
```js example-good
var obj = {};
-obj.foo = 'привет';
+obj.foo = "привет";
var array = [];
-array[0] = 'всем';
+array[0] = "всем";
```
### Неправильные ключевые слова
@@ -81,9 +81,9 @@ def print(info){
Вместо `def` используйте `function`:
```js example-good
-function print(info){
+function print(info) {
console.log(info);
-};
+}
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/more_arguments_needed/index.md b/files/ru/web/javascript/reference/errors/more_arguments_needed/index.md
index 1954afa5c78c29..44820e62ab4af1 100644
--- a/files/ru/web/javascript/reference/errors/more_arguments_needed/index.md
+++ b/files/ru/web/javascript/reference/errors/more_arguments_needed/index.md
@@ -1,5 +1,5 @@
---
-title: 'TypeError: More arguments needed'
+title: "TypeError: More arguments needed"
slug: Web/JavaScript/Reference/Errors/More_arguments_needed
tags:
- Errors
diff --git a/files/ru/web/javascript/reference/errors/negative_repetition_count/index.md b/files/ru/web/javascript/reference/errors/negative_repetition_count/index.md
index 492feec76cf929..5fa5fe9afb3712 100644
--- a/files/ru/web/javascript/reference/errors/negative_repetition_count/index.md
+++ b/files/ru/web/javascript/reference/errors/negative_repetition_count/index.md
@@ -1,5 +1,5 @@
---
-title: 'RangeError: repeat count must be non-negative'
+title: "RangeError: repeat count must be non-negative"
slug: Web/JavaScript/Reference/Errors/Negative_repetition_count
translation_of: Web/JavaScript/Reference/Errors/Negative_repetition_count
---
@@ -26,16 +26,16 @@ RangeError: Invalid count value (Chrome)
### Неверно
```js example-bad
-'abc'.repeat(-1); // RangeError
+"abc".repeat(-1); // RangeError
```
### Верно
```js example-good
-'abc'.repeat(0); // ''
-'abc'.repeat(1); // 'abc'
-'abc'.repeat(2); // 'abcabc'
-'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer)
+"abc".repeat(0); // ''
+"abc".repeat(1); // 'abc'
+"abc".repeat(2); // 'abcabc'
+"abc".repeat(3.5); // 'abcabcabc' (count will be converted to integer)
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/no_non-null_object/index.md b/files/ru/web/javascript/reference/errors/no_non-null_object/index.md
index 7a994fb37d7304..2ce684041959f5 100644
--- a/files/ru/web/javascript/reference/errors/no_non-null_object/index.md
+++ b/files/ru/web/javascript/reference/errors/no_non-null_object/index.md
@@ -32,17 +32,17 @@ TypeError: недопустимое значение, используемое
Когда такие методы, как {{jsxref("Object.create()")}} или {{jsxref("object.defineProperty()")}} и {{jsxref("object.defineProperties()")}} используются, дополнительный параметр дескриптора ожидает объект дескриптора свойства. Если не указать объект (например, просто число), возникнет ошибка:
```js example-bad
-Object.defineProperty({}, 'key', 1);
+Object.defineProperty({}, "key", 1);
// TypeError: 1 is not a non-null object
-Object.defineProperty({}, 'key', null);
+Object.defineProperty({}, "key", null);
// TypeError: null is not a non-null object
```
Допустимый объект дескриптора свойства может выглядеть следующим образом:
```js example-good
-Object.defineProperty({}, 'key', { value: 'foo', writable: false });
+Object.defineProperty({}, "key", { value: "foo", writable: false });
```
### `СлабаяКарта` и `СлабыйСет` объектов требуют ключей объектов
@@ -51,14 +51,14 @@ Object.defineProperty({}, 'key', { value: 'foo', writable: false });
```js example-bad
var ws = new WeakSet();
-ws.add('foo');
+ws.add("foo");
// TypeError: "foo" is not a non-null object
```
Создание объекта вместо:
```js example-good
-ws.add({foo: 'bar'});
+ws.add({ foo: "bar" });
ws.add(window);
```
diff --git a/files/ru/web/javascript/reference/errors/no_variable_name/index.md b/files/ru/web/javascript/reference/errors/no_variable_name/index.md
index 7e516ec3802dda..cb6ad5b4609c86 100644
--- a/files/ru/web/javascript/reference/errors/no_variable_name/index.md
+++ b/files/ru/web/javascript/reference/errors/no_variable_name/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: missing variable name'
+title: "SyntaxError: missing variable name"
slug: Web/JavaScript/Reference/Errors/No_variable_name
tags:
- JavaScript
@@ -65,11 +65,12 @@ var second = document.getElementById('два'),
Исправленный вариант:
```js example-good
-var x, y = "foo";
+var x,
+ y = "foo";
var x = "foo";
-var first = document.getElementById('раз');
-var second = document.getElementById('два');
+var first = document.getElementById("раз");
+var second = document.getElementById("два");
```
### Массивы
@@ -84,7 +85,7 @@ var arr = 1,2,3,4,5;
А вот так будет правильно:
```js example-good
-var arr = [1,2,3,4,5];
+var arr = [1, 2, 3, 4, 5];
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/non_configurable_array_element/index.md b/files/ru/web/javascript/reference/errors/non_configurable_array_element/index.md
index c4aeb27562a57d..889601ef3893e2 100644
--- a/files/ru/web/javascript/reference/errors/non_configurable_array_element/index.md
+++ b/files/ru/web/javascript/reference/errors/non_configurable_array_element/index.md
@@ -5,6 +5,7 @@ title: >-
slug: Web/JavaScript/Reference/Errors/Non_configurable_array_element
translation_of: Web/JavaScript/Reference/Errors/Non_configurable_array_element
---
+
{{jsSidebar("Errors")}}
## Сообщения
@@ -34,8 +35,8 @@ The {{jsxref("Object.defineProperty()")}} создаёт не настраива
```js example-bad
var arr = [];
-Object.defineProperty(arr, 0, {value: 0});
-Object.defineProperty(arr, 1, {value: "1"});
+Object.defineProperty(arr, 0, { value: 0 });
+Object.defineProperty(arr, 1, { value: "1" });
arr.length = 1;
// TypeError: не удаётся удалить не настраиваемый элемент массива
@@ -45,8 +46,8 @@ arr.length = 1;
```js example-good
var arr = [];
-Object.defineProperty(arr, 0, {value: 0, configurable: true});
-Object.defineProperty(arr, 1, {value: "1", configurable: true});
+Object.defineProperty(arr, 0, { value: 0, configurable: true });
+Object.defineProperty(arr, 1, { value: "1", configurable: true });
arr.length = 1;
```
@@ -56,7 +57,7 @@ arr.length = 1;
The {{jsxref("Object.seal()")}} функция помечает все существующие элементы как не настраиваемые.
```js example-bad
-var arr = [1,2,3];
+var arr = [1, 2, 3];
Object.seal(arr);
arr.length = 1;
@@ -66,7 +67,7 @@ arr.length = 1;
Вам или нужно извлечь {{jsxref("Object.seal()")}} позвоните или сделайте копию. В случае копирования сокращение копии массива не изменяет длину исходного массива.
```js example-good
-var arr = [1,2,3];
+var arr = [1, 2, 3];
Object.seal(arr);
// Скопируйте исходный массив, чтобы сократить копию
diff --git a/files/ru/web/javascript/reference/errors/not_a_constructor/index.md b/files/ru/web/javascript/reference/errors/not_a_constructor/index.md
index c0ba83d7a44777..80bde10bd2fd9c 100644
--- a/files/ru/web/javascript/reference/errors/not_a_constructor/index.md
+++ b/files/ru/web/javascript/reference/errors/not_a_constructor/index.md
@@ -52,8 +52,8 @@ new Math();
new Symbol();
// TypeError: Symbol is not a constructor
-function* f() {};
-var obj = new f;
+function* f() {}
+var obj = new f();
// TypeError: f is not a constructor
```
@@ -72,7 +72,7 @@ function Car(make, model, year) {
Теперь вы можете создать объект, который называется `mycar` (мой автомобиль) следующим образом:
```js
-var mycar = new Car('Лада', 'Самара', 1993);
+var mycar = new Car("Лада", "Самара", 1993);
```
### В Промисах
@@ -89,7 +89,9 @@ return new Promise.resolve(true);
```js
// Это допустимо, но слишком длинно, в этом нет необходимости:
-return new Promise((resolve, reject) => { resolve(true); })
+return new Promise((resolve, reject) => {
+ resolve(true);
+});
// Вместо этого, возвращайте статический метод:
return Promise.resolve(true);
diff --git a/files/ru/web/javascript/reference/errors/not_a_function/index.md b/files/ru/web/javascript/reference/errors/not_a_function/index.md
index 15a1f21f3b0dbb..b6f1213f08e56a 100644
--- a/files/ru/web/javascript/reference/errors/not_a_function/index.md
+++ b/files/ru/web/javascript/reference/errors/not_a_function/index.md
@@ -60,7 +60,7 @@ var x = document.getElementById("foo");
```js example-bad
var obj = { a: 13, b: 37, c: 42 };
-obj.map(function(num) {
+obj.map(function (num) {
return num * 2;
});
@@ -72,7 +72,7 @@ obj.map(function(num) {
```js example-good
var numbers = [1, 4, 9];
-numbers.map(function(num) {
+numbers.map(function (num) {
return num * 2;
});
diff --git a/files/ru/web/javascript/reference/errors/not_a_valid_code_point/index.md b/files/ru/web/javascript/reference/errors/not_a_valid_code_point/index.md
index 4d0b408912d0e9..56735a6c983b25 100644
--- a/files/ru/web/javascript/reference/errors/not_a_valid_code_point/index.md
+++ b/files/ru/web/javascript/reference/errors/not_a_valid_code_point/index.md
@@ -1,5 +1,5 @@
---
-title: 'RangeError: argument is not a valid code point'
+title: "RangeError: argument is not a valid code point"
slug: Web/JavaScript/Reference/Errors/Not_a_valid_code_point
translation_of: Web/JavaScript/Reference/Errors/Not_a_codepoint
original_slug: Web/JavaScript/Reference/Errors/Not_a_codepoint
@@ -30,23 +30,23 @@ RangeError: Invalid code point {0} (Chrome)
### Нерабочие случаи
```js example-bad
-String.fromCodePoint('_'); // RangeError
+String.fromCodePoint("_"); // RangeError
String.fromCodePoint(Infinity); // RangeError
-String.fromCodePoint(-1); // RangeError
-String.fromCodePoint(3.14); // RangeError
-String.fromCodePoint(3e-2); // RangeError
-String.fromCodePoint(NaN); // RangeError
+String.fromCodePoint(-1); // RangeError
+String.fromCodePoint(3.14); // RangeError
+String.fromCodePoint(3e-2); // RangeError
+String.fromCodePoint(NaN); // RangeError
```
### Рабочие случаи
```js example-good
-String.fromCodePoint(42); // "*"
-String.fromCodePoint(65, 90); // "AZ"
-String.fromCodePoint(0x404); // "\u0404"
-String.fromCodePoint(0x2F804); // "\uD87E\uDC04"
-String.fromCodePoint(194564); // "\uD87E\uDC04"
-String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07"
+String.fromCodePoint(42); // "*"
+String.fromCodePoint(65, 90); // "AZ"
+String.fromCodePoint(0x404); // "\u0404"
+String.fromCodePoint(0x2f804); // "\uD87E\uDC04"
+String.fromCodePoint(194564); // "\uD87E\uDC04"
+String.fromCodePoint(0x1d306, 0x61, 0x1d307); // "\uD834\uDF06a\uD834\uDF07"
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/not_defined/index.md b/files/ru/web/javascript/reference/errors/not_defined/index.md
index 7c65d0105d3190..24c76a1c9f3f16 100644
--- a/files/ru/web/javascript/reference/errors/not_defined/index.md
+++ b/files/ru/web/javascript/reference/errors/not_defined/index.md
@@ -42,9 +42,9 @@ foo.substring(1); // "ar"
Переменная должна быть доступна в текущем контексте исполнения. Переменные, определённые внутри [функции](/ru/docs/Web/JavaScript/Reference/Functions) не могут быть доступны из любой точки за пределами функции, так как переменная определена только в области видимости самой функции.
```js example-bad
-function numbers () {
+function numbers() {
var num1 = 2,
- num2 = 3;
+ num2 = 3;
return num1 + num2;
}
@@ -55,9 +55,9 @@ console.log(num1); // ReferenceError num1 is not defined.
```js example-good
var num1 = 2,
- num2 = 3;
+ num2 = 3;
-function numbers () {
+function numbers() {
return num1 + num2;
}
diff --git a/files/ru/web/javascript/reference/errors/precision_range/index.md b/files/ru/web/javascript/reference/errors/precision_range/index.md
index 0a253ecafdcd08..f5d5c59e9edd8b 100644
--- a/files/ru/web/javascript/reference/errors/precision_range/index.md
+++ b/files/ru/web/javascript/reference/errors/precision_range/index.md
@@ -1,5 +1,5 @@
---
-title: 'RangeError: precision is out of range'
+title: "RangeError: precision is out of range"
slug: Web/JavaScript/Reference/Errors/Precision_range
tags:
- JavaScript
@@ -33,39 +33,39 @@ RangeError: toPrecision() argument must be between 1 and 21 (Chrome)
Допустимые значения для аргументов данных методов обычно лежат в диапазоне от 0 до 20 (или 21), однако спецификация ECMAScript допускает его расширение.
-| Метод | Firefox (SpiderMonkey) | Chrome, Opera (V8) |
-| ------------------------------------------------------------ | ---------------------- | ------------------ |
+| Метод | Firefox (SpiderMonkey) | Chrome, Opera (V8) |
+| ---------------------------------------------- | ---------------------- | ------------------ |
| {{jsxref("Number.prototype.toExponential()")}} | от 0 до 100 | от 0 до 20 |
-| {{jsxref("Number.prototype.toFixed()")}} | от -20 до 100 | от 0 до 20 |
-| {{jsxref("Number.prototype.toPrecision()")}} | от 1 до 100 | от 1 до 21 |
+| {{jsxref("Number.prototype.toFixed()")}} | от -20 до 100 | от 0 до 20 |
+| {{jsxref("Number.prototype.toPrecision()")}} | от 1 до 100 | от 1 до 21 |
## Примеры
### Примеры некорректного кода
```js example-bad
-77.1234.toExponential(-1); // RangeError
-77.1234.toExponential(101); // RangeError
+(77.1234).toExponential(-1); // RangeError
+(77.1234).toExponential(101); // RangeError
-2.34.toFixed(-100); // RangeError
-2.34.toFixed(1001); // RangeError
+(2.34).toFixed(-100); // RangeError
+(2.34).toFixed(1001); // RangeError
-1234.5.toPrecision(-1); // RangeError
-1234.5.toPrecision(101); // RangeError
+(1234.5).toPrecision(-1); // RangeError
+(1234.5).toPrecision(101); // RangeError
```
### Примеры правильного кода
```js example-good
-77.1234.toExponential(4); // 7.7123e+1
-77.1234.toExponential(2); // 7.71e+1
+(77.1234).toExponential(4); // 7.7123e+1
+(77.1234).toExponential(2); // 7.71e+1
-2.34.toFixed(1); // 2.3
-2.35.toFixed(1); // 2.4 (обратите внимание: в данном случае производится округление в большую сторону)
+(2.34).toFixed(1); // 2.3
+(2.35).toFixed(1); // 2.4 (обратите внимание: в данном случае производится округление в большую сторону)
-5.123456.toPrecision(5); // 5.1235
-5.123456.toPrecision(2); // 5.1
-5.123456.toPrecision(1); // 5
+(5.123456).toPrecision(5); // 5.1235
+(5.123456).toPrecision(2); // 5.1
+(5.123456).toPrecision(1); // 5
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/property_access_denied/index.md b/files/ru/web/javascript/reference/errors/property_access_denied/index.md
index 0eaafda064fe6c..d4ac622db697e1 100644
--- a/files/ru/web/javascript/reference/errors/property_access_denied/index.md
+++ b/files/ru/web/javascript/reference/errors/property_access_denied/index.md
@@ -28,15 +28,17 @@ Error: Permission denied to access property "x"
## Примеры
```html
-
+
-
+
diff --git a/files/ru/web/javascript/reference/errors/read-only/index.md b/files/ru/web/javascript/reference/errors/read-only/index.md
index 9924654c98e054..7a000e415e2e2a 100644
--- a/files/ru/web/javascript/reference/errors/read-only/index.md
+++ b/files/ru/web/javascript/reference/errors/read-only/index.md
@@ -3,6 +3,7 @@ title: 'TypeError: "x" is read-only(Ошибка Типа: "x" только дл
slug: Web/JavaScript/Reference/Errors/Read-only
translation_of: Web/JavaScript/Reference/Errors/Read-only
---
+
{{jsSidebar("Errors")}}
## Сообщения
@@ -32,24 +33,24 @@ TypeError: не удаётся назначить только для чтени
Свойства только для чтения не очень распространены, но их можно создать с помощью {{jsxref("Object.defineProperty()")}} или {{jsxref("Object.freeze()")}}.
```js example-bad
-'use strict';
-var obj = Object.freeze({name: 'Elsa', score: 157});
-obj.score = 0; // TypeError
+"use strict";
+var obj = Object.freeze({ name: "Elsa", score: 157 });
+obj.score = 0; // TypeError
-'use strict';
-Object.defineProperty(this, 'LUNG_COUNT', {value: 2, writable: false});
-LUNG_COUNT = 3; // TypeError
+("use strict");
+Object.defineProperty(this, "LUNG_COUNT", { value: 2, writable: false });
+LUNG_COUNT = 3; // TypeError
-'use strict';
+("use strict");
var frozenArray = Object.freeze([0, 1, 2]);
-frozenArray[0]++; // TypeError
+frozenArray[0]++; // TypeError
```
В JavaScript также встроено несколько свойств, доступных только для чтения. Возможно, вы пытались переопределить математическую константу.
```js example-bad
-'use strict';
-Math.PI = 4; // TypeError
+"use strict";
+Math.PI = 4; // TypeError
```
Прости, ты не можешь этого сделать.
@@ -57,20 +58,20 @@ Math.PI = 4; // TypeError
Глобальная переменная undefined также доступна только для чтения, поэтому вы не можете заставить замолчать печально известную ошибку "undefined is not a function:
```js example-bad
-'use strict';
-undefined = function() {}; // TypeError: "undefined" доступен только для чтения
+"use strict";
+undefined = function () {}; // TypeError: "undefined" доступен только для чтения
```
### Правильные кейсы
```js example-good
-'use strict';
-var obj = Object.freeze({name: 'Score', points: 157});
-obj = {name: obj.name, points: 0}; // замена его на новый работающий объект
+"use strict";
+var obj = Object.freeze({ name: "Score", points: 157 });
+obj = { name: obj.name, points: 0 }; // замена его на новый работающий объект
-'use strict';
-var LUNG_COUNT = 2; // "var` работает, потому что он не только для чтения
-LUNG_COUNT = 3; // ok (анатомически маловероятно, хотя)
+("use strict");
+var LUNG_COUNT = 2; // "var` работает, потому что он не только для чтения
+LUNG_COUNT = 3; // ok (анатомически маловероятно, хотя)
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/redeclared_parameter/index.md b/files/ru/web/javascript/reference/errors/redeclared_parameter/index.md
index 1053a904bda908..4147bdd92a1e04 100644
--- a/files/ru/web/javascript/reference/errors/redeclared_parameter/index.md
+++ b/files/ru/web/javascript/reference/errors/redeclared_parameter/index.md
@@ -31,7 +31,7 @@ SyntaxError: Identifier "x" has already been declared (Chrome)
```js example-bad
function f(arg) {
- let arg = 'foo';
+ let arg = "foo";
}
// SyntaxError: redeclaration of formal parameter "arg"
@@ -41,11 +41,11 @@ function f(arg) {
```js example-good
function f(arg) {
- arg = 'foo';
+ arg = "foo";
}
function f(arg) {
- let bar = 'foo';
+ let bar = "foo";
}
```
diff --git a/files/ru/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md b/files/ru/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md
index b45364bb441602..a84fcd2f4e2845 100644
--- a/files/ru/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md
+++ b/files/ru/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md
@@ -5,6 +5,7 @@ title: >-
slug: Web/JavaScript/Reference/Errors/Reduce_of_empty_array_with_no_initial_value
translation_of: Web/JavaScript/Reference/Errors/Reduce_of_empty_array_with_no_initial_value
---
+
{{jsSidebar("Errors")}}
## Сообщение
@@ -34,15 +35,19 @@ TypeError: уменьшение пустого массива без начал
```js example-bad
var ints = [0, -1, -2, -3, -4, -5];
-ints.filter(x => x > 0) // удаление всех элементов
- .reduce((x, y) => x + y) // no more elements to use for the initial value.
+ints
+ .filter((x) => x > 0) // удаление всех элементов
+ .reduce((x, y) => x + y); // no more elements to use for the initial value.
```
Аналогично, та же проблема может возникнуть, если в селекторе есть опечатка или непредвиденное количество элементов в списке:
```js example-bad
var names = document.getElementsByClassName("names");
-var name_list = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name);
+var name_list = Array.prototype.reduce.call(
+ names,
+ (acc, name) => acc + ", " + name,
+);
```
### Правильные примеры
@@ -53,8 +58,9 @@ var name_list = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + n
```js example-good
var ints = [0, -1, -2, -3, -4, -5];
-ints.filter(x => x < 0) // removes all elements
- .reduce((x, y) => x + y, 0) // the initial value is the neutral element of the addition
+ints
+ .filter((x) => x < 0) // removes all elements
+ .reduce((x, y) => x + y, 0); // the initial value is the neutral element of the addition
```
Другим способом было бы два для обработки пустого случая, или перед вызовом reduce, или в обратном вызове после добавления неожиданного фиктивного начального значения.
@@ -64,14 +70,22 @@ var names = document.getElementsByClassName("names");
var name_list1 = "";
if (names1.length >= 1)
- name_list1 = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name);
+ name_list1 = Array.prototype.reduce.call(
+ names,
+ (acc, name) => acc + ", " + name,
+ );
// name_list1 == "" when names is empty.
-var name_list2 = Array.prototype.reduce.call(names, (acc, name) => {
- if (acc == "") // initial value
- return name;
- return acc + ", " + name;
-}, "");
+var name_list2 = Array.prototype.reduce.call(
+ names,
+ (acc, name) => {
+ if (acc == "")
+ // initial value
+ return name;
+ return acc + ", " + name;
+ },
+ "",
+);
// name_list2 == "" when names is empty.
```
diff --git a/files/ru/web/javascript/reference/errors/resulting_string_too_large/index.md b/files/ru/web/javascript/reference/errors/resulting_string_too_large/index.md
index 169c8292e448b0..314081898c3cfb 100644
--- a/files/ru/web/javascript/reference/errors/resulting_string_too_large/index.md
+++ b/files/ru/web/javascript/reference/errors/resulting_string_too_large/index.md
@@ -1,5 +1,5 @@
---
-title: 'RangeError: repeat count must be less than infinity'
+title: "RangeError: repeat count must be less than infinity"
slug: Web/JavaScript/Reference/Errors/Resulting_string_too_large
translation_of: Web/JavaScript/Reference/Errors/Resulting_string_too_large
---
@@ -29,17 +29,17 @@ RangeError: Invalid count value (Chrome)
### Неверно
```js example-bad
-'abc'.repeat(Infinity); // RangeError
-'a'.repeat(2**28); // RangeError
+"abc".repeat(Infinity); // RangeError
+"a".repeat(2 ** 28); // RangeError
```
### Верно
```js example-good
-'abc'.repeat(0); // ''
-'abc'.repeat(1); // 'abc'
-'abc'.repeat(2); // 'abcabc'
-'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer)
+"abc".repeat(0); // ''
+"abc".repeat(1); // 'abc'
+"abc".repeat(2); // 'abcabc'
+"abc".repeat(3.5); // 'abcabcabc' (count will be converted to integer)
```
## Смотрите также
diff --git a/files/ru/web/javascript/reference/errors/stmt_after_return/index.md b/files/ru/web/javascript/reference/errors/stmt_after_return/index.md
index 3a85c362171a1a..9f8c720364c306 100644
--- a/files/ru/web/javascript/reference/errors/stmt_after_return/index.md
+++ b/files/ru/web/javascript/reference/errors/stmt_after_return/index.md
@@ -1,5 +1,5 @@
---
-title: 'Warning: unreachable code after return statement'
+title: "Warning: unreachable code after return statement"
slug: Web/JavaScript/Reference/Errors/Stmt_after_return
tags:
- JavaScript
@@ -51,13 +51,13 @@ Warning: unreachable code after return statement (Firefox)
function f() {
var x = 3;
x += 4;
- return x; //return завершает функцию немедленно,
- x -= 3; //поэтому эта строка никогда не запустится; она недоступна
+ return x; //return завершает функцию немедленно,
+ x -= 3; //поэтому эта строка никогда не запустится; она недоступна
}
function f() {
- return //эта строка трактуется как завершение функции оператором `return;`,
- 3 + 4; //поэтому происходит выход из функции, и эта строка не выполнится
+ return; //эта строка трактуется как завершение функции оператором `return;`,
+ 3 + 4; //поэтому происходит выход из функции, и эта строка не выполнится
}
```
@@ -68,11 +68,11 @@ function f() {
var x = 3;
x += 4;
x -= 3;
- return x; //OK: return находится после всех остальных выражений
+ return x; //OK: return находится после всех остальных выражений
}
function f() {
- return 3 + 4 //OK: return без точки с запятой и вычисляемое выражение находятся на одной строке
+ return 3 + 4; //OK: return без точки с запятой и вычисляемое выражение находятся на одной строке
}
```
diff --git a/files/ru/web/javascript/reference/errors/strict_non_simple_params/index.md b/files/ru/web/javascript/reference/errors/strict_non_simple_params/index.md
index 7b5a13ec9a5bec..6f1d4ef328a348 100644
--- a/files/ru/web/javascript/reference/errors/strict_non_simple_params/index.md
+++ b/files/ru/web/javascript/reference/errors/strict_non_simple_params/index.md
@@ -67,7 +67,7 @@ function sum(a = 1, b = 2) {
Если функция должна находиться в строгом режиме, и весь скрипт или заключающая функция также в порядке, чтобы быть в строгом режиме, вы можете переместить директиву "use strict" за пределы функции:
```js example-good
-'use strict';
+"use strict";
function sum(a = 1, b = 2) {
return a + b;
}
@@ -88,8 +88,8 @@ var sum = function sum([a, b]) {
Это может быть преобразовано в следующее выражение:
```js example-good
-var sum = (function() {
- 'use strict';
+var sum = (function () {
+ "use strict";
return function sum([a, b]) {
return a + b;
};
@@ -112,7 +112,7 @@ var callback = (...args) => {
```js example-good
var callback = (() => {
- 'use strict';
+ "use strict";
return (...args) => {
return this.run(args);
};
diff --git a/files/ru/web/javascript/reference/errors/too_much_recursion/index.md b/files/ru/web/javascript/reference/errors/too_much_recursion/index.md
index a69007073ae08a..2b63fe8eac43ed 100644
--- a/files/ru/web/javascript/reference/errors/too_much_recursion/index.md
+++ b/files/ru/web/javascript/reference/errors/too_much_recursion/index.md
@@ -1,5 +1,5 @@
---
-title: 'InternalError: too much recursion'
+title: "InternalError: too much recursion"
slug: Web/JavaScript/Reference/Errors/Too_much_recursion
tags:
- Errors
@@ -30,8 +30,10 @@ InternalError: too much recursion
```js
function loop(x) {
- if (x >= 10) // "x >= 10" это условие выхода
+ if (x >= 10) {
+ // "x >= 10" это условие выхода
return;
+ }
// do stuff
loop(x + 1); // рекурсивный вызов
}
@@ -42,8 +44,7 @@ loop(0);
```js example-bad
function loop(x) {
- if (x >= 1000000000000)
- return;
+ if (x >= 1000000000000) return;
// do stuff
loop(x + 1);
}
diff --git a/files/ru/web/javascript/reference/errors/undeclared_var/index.md b/files/ru/web/javascript/reference/errors/undeclared_var/index.md
index e98305775811d2..d50835cf372d69 100644
--- a/files/ru/web/javascript/reference/errors/undeclared_var/index.md
+++ b/files/ru/web/javascript/reference/errors/undeclared_var/index.md
@@ -40,7 +40,7 @@ Errors about undeclared variable assignments occur in [strict mode code](/ru/doc
```js example-bad
function foo() {
- 'use strict';
+ "use strict";
bar = true;
}
foo(); // ReferenceError: assignment to undeclared variable bar
@@ -52,7 +52,7 @@ foo(); // ReferenceError: assignment to undeclared variable bar
```js example-good
function foo() {
- 'use strict';
+ "use strict";
var bar = true;
}
foo();
diff --git a/files/ru/web/javascript/reference/errors/undefined_prop/index.md b/files/ru/web/javascript/reference/errors/undefined_prop/index.md
index b4474b42d71bf1..dfaef13c1ac581 100644
--- a/files/ru/web/javascript/reference/errors/undefined_prop/index.md
+++ b/files/ru/web/javascript/reference/errors/undefined_prop/index.md
@@ -45,12 +45,12 @@ var foo = {};
// Задать свойство bar
-foo.bar = 'moon';
+foo.bar = "moon";
console.log(foo.bar); // "moon"
// Убедиться, что свойство bar существует, прежде чем обращаться к нему
-if (foo.hasOwnProperty('bar')) {
+if (foo.hasOwnProperty("bar")) {
console.log(foo.bar);
}
```
diff --git a/files/ru/web/javascript/reference/errors/unexpected_token/index.md b/files/ru/web/javascript/reference/errors/unexpected_token/index.md
index cacf227bdd66d8..fd3a76a0b4a900 100644
--- a/files/ru/web/javascript/reference/errors/unexpected_token/index.md
+++ b/files/ru/web/javascript/reference/errors/unexpected_token/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: Unexpected token'
+title: "SyntaxError: Unexpected token"
slug: Web/JavaScript/Reference/Errors/Unexpected_token
tags:
- JavaScript
@@ -69,12 +69,19 @@ function round(n, upperBound, lowerBound){
На первый взгляд кажется, что скобки расставлены правильно, но обратите внимание, что `||` находится не в скобках. Необходимо заключить `||` в скобки:
```js example-good
-function round(n, upperBound, lowerBound){
- if((n > upperBound) || (n < lowerBound)){
- throw 'Число ' + String(n) + ' больше, чем ' + String(upperBound) + ', или меньше, чем ' + String(lowerBound);
- }else if(n < ((upperBound + lowerBound)/2)){
+function round(n, upperBound, lowerBound) {
+ if (n > upperBound || n < lowerBound) {
+ throw (
+ "Число " +
+ String(n) +
+ " больше, чем " +
+ String(upperBound) +
+ ", или меньше, чем " +
+ String(lowerBound)
+ );
+ } else if (n < (upperBound + lowerBound) / 2) {
return lowerBound;
- }else{
+ } else {
return upperBound;
}
}
diff --git a/files/ru/web/javascript/reference/errors/unexpected_type/index.md b/files/ru/web/javascript/reference/errors/unexpected_type/index.md
index 973a04ace585cb..4e8a2b569d6e5b 100644
--- a/files/ru/web/javascript/reference/errors/unexpected_type/index.md
+++ b/files/ru/web/javascript/reference/errors/unexpected_type/index.md
@@ -41,12 +41,11 @@ foo.substring(1); // TypeError: foo is undefined
var foo = null;
foo.substring(1); // TypeError: foo is null
-
// Некоторые методы могут требовать определённый тип
-var foo = {}
+var foo = {};
Symbol.keyFor(foo); // TypeError: foo is not a symbol
-var foo = 'bar'
+var foo = "bar";
Object.create(foo); // TypeError: "foo" is not an object or null
```
@@ -55,7 +54,7 @@ Object.create(foo); // TypeError: "foo" is not an object or null
Что бы исправить ошибку пустого указателя вы можете использовать оператор [typeof.](/ru/docs/Web/JavaScript/Reference/Operators/typeof)
```js
-if (typeof foo !== 'undefined') {
+if (typeof foo !== "undefined") {
// Теперь мы знаем, что foo определено.
}
```
diff --git a/files/ru/web/javascript/reference/errors/unnamed_function_statement/index.md b/files/ru/web/javascript/reference/errors/unnamed_function_statement/index.md
index a2af998f96a4d0..1e3e1e79fd8c34 100644
--- a/files/ru/web/javascript/reference/errors/unnamed_function_statement/index.md
+++ b/files/ru/web/javascript/reference/errors/unnamed_function_statement/index.md
@@ -1,5 +1,5 @@
---
-title: 'SyntaxError: function statement requires a name(функция оператор требует имя)'
+title: "SyntaxError: function statement requires a name(функция оператор требует имя)"
slug: Web/JavaScript/Reference/Errors/Unnamed_function_statement
translation_of: Web/JavaScript/Reference/Errors/Unnamed_function_statement
---
@@ -38,17 +38,15 @@ function () {
Вы можете использовать выражение функции (назначат) вместо:
```js example-good
-var greet = function() {
- return 'Hello world';
+var greet = function () {
+ return "Hello world";
};
```
Или, ваша функция возможно, предназначена для IIFE (немедленно вызываемое выражение функции), которое является функцией, которая запускается, как только она определена. В этом случае вам понадобится ещё несколько брекетов:
```js example-good
-(function () {
-
-})();
+(function () {})();
```
### Помеченные функции
@@ -82,7 +80,7 @@ function Greeter() {
var greeter = {
german: function () {
return "Moin";
- }
+ },
};
```
diff --git a/files/ru/web/javascript/reference/errors/unterminated_string_literal/index.md b/files/ru/web/javascript/reference/errors/unterminated_string_literal/index.md
index db736d3904568f..b66e7ed4620f11 100644
--- a/files/ru/web/javascript/reference/errors/unterminated_string_literal/index.md
+++ b/files/ru/web/javascript/reference/errors/unterminated_string_literal/index.md
@@ -1,8 +1,9 @@
---
-title: 'SyntaxError: unterminated string literal(незавершённый строковый литерал)'
+title: "SyntaxError: unterminated string literal(незавершённый строковый литерал)"
slug: Web/JavaScript/Reference/Errors/Unterminated_string_literal
translation_of: Web/JavaScript/Reference/Errors/Unterminated_string_literal
---
+
{{jsSidebar("Errors")}}
## Сообщение
diff --git a/files/ru/web/javascript/reference/functions/arguments/callee/index.md b/files/ru/web/javascript/reference/functions/arguments/callee/index.md
index 9b01a2476ce430..4f3b967ba2e365 100644
--- a/files/ru/web/javascript/reference/functions/arguments/callee/index.md
+++ b/files/ru/web/javascript/reference/functions/arguments/callee/index.md
@@ -18,17 +18,17 @@ translation_of: Web/JavaScript/Reference/Functions/arguments/callee
```js
var f = function test() {
- alert(typeof test); //undefined
- alert(typeof arguments.callee); //function
-}
+ alert(typeof test); //undefined
+ alert(typeof arguments.callee); //function
+};
```
В нынешние времена, когда мы уже можем работать с _NFE_, надобность в использовании свойства **callee** сама собой отпадает**.**
```js
-var f = function test(){
- alert(typeof test); //function
-}
+var f = function test() {
+ alert(typeof test); //function
+};
```
Действительно незаменимым оно остаётся всего в одной ситуации. Когда мы создаём анонимную функцию напрямую через конструктор _Function._
@@ -42,8 +42,8 @@ var b = new Function("", "alert(typeof arguments.callee)");
### Использование `arguments.callee` для создания рекурсии
```js
-var factorial = function(n) {
- return n == 1 ? 1 : n * arguments.callee(n-1);
+var factorial = function (n) {
+ return n == 1 ? 1 : n * arguments.callee(n - 1);
};
factorial(7);
@@ -51,11 +51,11 @@ factorial(7);
## Specifications
-| Specification | Status | Comment |
-| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------- |
-| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Initial definition. Implemented in JavaScript 1.2 |
-| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}} | {{Spec2('ES5.1')}} | |
-| {{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ES6')}} | |
+| Specification | Status | Comment |
+| ------------------------------------------------------------------------------------ | -------------------- | ------------------------------------------------- |
+| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Initial definition. Implemented in JavaScript 1.2 |
+| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}} | {{Spec2('ES5.1')}} | |
+| {{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ES6')}} | |
| {{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ESDraft')}} | |
## Browser compatibility
diff --git a/files/ru/web/javascript/reference/functions/arguments/index.md b/files/ru/web/javascript/reference/functions/arguments/index.md
index b7a56644729b25..b31d6c82e69f6f 100644
--- a/files/ru/web/javascript/reference/functions/arguments/index.md
+++ b/files/ru/web/javascript/reference/functions/arguments/index.md
@@ -30,15 +30,15 @@ arguments
Объект `arguments` - это локальная переменная, доступная внутри любой (нестрелочной) функции. Объект `arguments` позволяет ссылаться на аргументы функции внутри неё. Он состоит из переданных в функцию аргументов, индексация начинается с 0. Например, если в функцию было передано 3 аргумента, обратиться к ним можно следующим образом:
```js
-arguments[0]
-arguments[1]
-arguments[2]
+arguments[0];
+arguments[1];
+arguments[2];
```
Аргументам может быть присвоено значение:
```js
-arguments[1] = 'new value';
+arguments[1] = "new value";
```
Объект `arguments` не является {{jsxref("Array")}}. Он похож на массив, но не обладает ни одним из его свойств, кроме [`length`](/ru/docs/Web/JavaScript/Reference/Functions/arguments/length). Например, у него нет метода [`pop`](/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/pop). Однако, он может быть преобразован в обычный массив:
@@ -55,7 +55,8 @@ const args = [...arguments];
> **Предупреждение:** Использование `slice` на объекте `arguments` не позволяет сделать оптимизации в некоторых JavaScript движках (например, V8 — [подробнее](https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments)). Если они важны, можно попробовать вместо этого создать новый массив с аналогичной длиной и заполнить его элементами объекта `arguments.` Альтернативный вариант — использовать конструктор `Array` как функцию:
>
> ```js
-> var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));
+> var args =
+> arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
> ```
Объект `arguments` можно использовать при вызове функции с бо́льшим количеством аргументов, чем было предусмотрено в её объявлении. Такой способ удобен для функций, в которые допустимо передавать переменное количество аргументов. Можно воспользоваться [`arguments.length`](/ru/docs/Web/JavaScript/Reference/Functions/arguments/length), чтобы определить количество переданных в функцию аргументов, а затем обработать каждый из них с помощью объекта `arguments`. Чтобы определить количество параметров функции, описанных в её [сигнатуре](/ru/docs/Glossary/Signature/Function), можно использовать свойство [`Function.length`](/ru/docs/Web/JavaScript/Reference/Global_Objects/Function/length).
@@ -162,7 +163,7 @@ foo(1, 2, 3); // { "0": 1, "1": 2, "2": 3 }
Тем не менее, в нестрогих функциях **соответствие между их аргументами и объектом `arguments`** существует только в том случае, если функция **не** содержит никаких [остаточных параметров](/ru/docs/Web/JavaScript/Reference/Functions/Rest_parameters), [параметров по умолчанию](/ru/docs/Web/JavaScript/Reference/Functions/Default_parameters) или [деструктурированных параметров](/ru/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment). Например, в функции, приведённой ниже, используется параметр по умолчанию, и в данном случае возвращаемый результат будет равен 10, а не 100:
```js
-function bar(a=1) {
+function bar(a = 1) {
arguments[0] = 100;
return a;
}
@@ -183,9 +184,9 @@ zoo(10); // 100
```js
function func(a, b) {
- arguments[0] = 90;
- arguments[1] = 99;
- console.log(a + " " + b);
+ arguments[0] = 90;
+ arguments[1] = 99;
+ console.log(a + " " + b);
}
func(1, 2); //90, 99
@@ -195,9 +196,9 @@ func(1, 2); //90, 99
```js
function func(a, b) {
- a = 9;
- b = 99;
- console.log(arguments[0] + " " + arguments[1]);
+ a = 9;
+ b = 99;
+ console.log(arguments[0] + " " + arguments[1]);
}
func(3, 4); //9, 99
@@ -206,10 +207,10 @@ func(3, 4); //9, 99
Но в случае, когда применяются [остаточные параметры](/ru/docs/Web/JavaScript/Reference/Functions/Rest_parameters), [параметры по умолчанию](/ru/docs/Web/JavaScript/Reference/Functions/Default_parameters) или [деструктурированные параметры](/ru/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment), будет обработано нормальное поведение, как в случае [параметров по умолчанию](/ru/docs/Web/JavaScript/Reference/Functions/Default_parameters):
```js
-function func(a, b, c=9) {
- arguments[0] = 99;
- arguments[1] = 98;
- console.log(a + " " + b);
+function func(a, b, c = 9) {
+ arguments[0] = 99;
+ arguments[1] = 98;
+ console.log(a + " " + b);
}
func(3, 4); //3, 4
diff --git a/files/ru/web/javascript/reference/functions/arguments/length/index.md b/files/ru/web/javascript/reference/functions/arguments/length/index.md
index a465a5504f0b20..4e41a9562a40a4 100644
--- a/files/ru/web/javascript/reference/functions/arguments/length/index.md
+++ b/files/ru/web/javascript/reference/functions/arguments/length/index.md
@@ -36,11 +36,11 @@ function adder(base /*, n2, ... */) {
## Спецификации
-| Specification | Status | Comment |
-| ------------------------------------------------------------------------------------------------------------ | ------------------------ | ------------------------------------------------- |
-| ECMAScript 1st Edition. | Standard | Initial definition. Implemented in JavaScript 1.1 |
-| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}} | {{Spec2('ES5.1')}} | |
-| {{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ES6')}} | |
+| Specification | Status | Comment |
+| -------------------------------------------------------------------------------- | ------------------ | ------------------------------------------------- |
+| ECMAScript 1st Edition. | Standard | Initial definition. Implemented in JavaScript 1.1 |
+| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}} | {{Spec2('ES5.1')}} | |
+| {{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ES6')}} | |
## Поддержка браузерами
diff --git a/files/ru/web/javascript/reference/functions/arrow_functions/index.md b/files/ru/web/javascript/reference/functions/arrow_functions/index.md
index 7537763a357cc0..0ac7464de6badd 100644
--- a/files/ru/web/javascript/reference/functions/arrow_functions/index.md
+++ b/files/ru/web/javascript/reference/functions/arrow_functions/index.md
@@ -59,14 +59,9 @@ f(); // 6
В некоторых функциональных шаблонах приветствуются более короткие функции. Сравните:
```js
-var elements = [
- 'Hydrogen',
- 'Helium',
- 'Lithium',
- 'Beryllium'
-];
-
-elements.map(function(element) {
+var elements = ["Hydrogen", "Helium", "Lithium", "Beryllium"];
+
+elements.map(function (element) {
return element.length;
}); // Это выражение вернёт массив [8, 6, 7, 9]
@@ -78,12 +73,12 @@ elements.map((element) => {
// Если единственным оператором в выражении стрелочной функции является return,
// можно удалить return и окружающие фигурные скобки
-elements.map(element => element.length); // [8, 6, 7, 9]
+elements.map((element) => element.length); // [8, 6, 7, 9]
// В данном случае, поскольку нам нужно только свойство length, мы можем использовать деструктуризированный параметр:
// Обратите внимание, что строка `"length"` соответствует свойству, которое мы хотим получить,
// в то время как `lengthFooBArX` это просто имя переменной, которую можно назвать как вы хотите
-elements.map(({ "length": lengthFooBArX }) => lengthFooBArX); // [8, 6, 7, 9]
+elements.map(({ length: lengthFooBArX }) => lengthFooBArX); // [8, 6, 7, 9]
// Это задание деструктуризированного параметра может быть записано, как показано ниже. Тем не менее, обратите внимание,
// что нет строки `"length"`, чтобы выбрать, какое свойство мы хотим получить. Вместо этого в качестве свойства,
@@ -131,7 +126,7 @@ function Person() {
Стрелочные функции не содержат собственный контекст [`this`](/ru/docs/Web/JavaScript/Reference/Operators/this), а используют значение [`this`](/ru/docs/Web/JavaScript/Reference/Operators/this) окружающего контекста. Поэтому нижеприведённый код работает как предполагалось:
```js
-function Person(){
+function Person() {
this.age = 0;
setInterval(() => {
@@ -147,7 +142,10 @@ var p = new Person();
Поскольку значение `this` определяется лексикой, правила строгого режима ([strict mode](/ru/docs/Web/JavaScript/Reference/Strict_mode)) относительно `this` игнорируются:
```js
-var f = () => { 'use strict'; return this; };
+var f = () => {
+ "use strict";
+ return this;
+};
f() === window; // или глобальный объект
```
@@ -159,24 +157,24 @@ f() === window; // или глобальный объект
```js
var adder = {
- base : 1,
+ base: 1,
- add : function(a) {
- var f = v => v + this.base;
+ add: function (a) {
+ var f = (v) => v + this.base;
return f(a);
},
- addThruCall: function(a) {
- var f = v => v + this.base;
+ addThruCall: function (a) {
+ var f = (v) => v + this.base;
var b = {
- base : 2
+ base: 2,
};
return f.call(b, a);
- }
+ },
};
-console.log(adder.add(1)); // Выводит 2
+console.log(adder.add(1)); // Выводит 2
console.log(adder.addThruCall(1)); // Всё равно выводит 2
```
@@ -192,8 +190,8 @@ arr(); // 42
function foo() {
var f = (i) => arguments[0] + i; // Неявное связывание ссылки arguments
- // стрелочной функции f
- // c объектом arguments функции foo
+ // стрелочной функции f
+ // c объектом arguments функции foo
return f(2);
}
@@ -216,14 +214,14 @@ foo(1); // 2
Как показано ранее, стрелочные функции лучше всего подходят для функций без методов. Посмотрим, что будет, когда мы попробуем их использовать как методы:
```js
-'use strict';
+"use strict";
var obj = {
i: 10,
b: () => console.log(this.i, this),
- c: function() {
+ c: function () {
console.log(this.i, this);
- }
-}
+ },
+};
obj.b(); // prints undefined, Window {...} (или глобальный объект)
obj.c(); // prints 10, Object {...}
```
@@ -231,17 +229,17 @@ obj.c(); // prints 10, Object {...}
Стрелочные функции не объявляют привязку ("bind") их контекста `this`. Другой пример включает {{jsxref("Object.defineProperty()")}}:
```js
-'use strict';
+"use strict";
var obj = {
- a: 10
+ a: 10,
};
-Object.defineProperty(obj, 'b', {
+Object.defineProperty(obj, "b", {
get: () => {
console.log(this.a, typeof this.a, this);
return this.a + 10;
// представляет глобальный объект 'Window', но 'this.a' возвращает 'undefined'
- }
+ },
});
```
@@ -250,10 +248,10 @@ Object.defineProperty(obj, 'b', {
Стрелочные функции не могут быть использованы как конструктор и вызовут ошибку при использовании с `new`:
```js
-var a = new (function() {})
+var a = new (function () {})();
// переменной "a" будет присвоено значение экземпляра анонимной функции
-var b = new (() => {})
+var b = new (() => {})();
// будет выброшено исключение
// Uncaught TypeError: (intermediate value) is not a constructor
```
@@ -269,10 +267,12 @@ var b = new (() => {})
Блочная форма не возвращает значение, необходимо явно вернуть значение.
```js
-var func = x => x * x; // краткий синтаксис,
- // неявно возвращает результат
-var func = (x, y) => { return x + y; }; // блочный синтаксис,
- // явно возвращает результат
+var func = (x) => x * x; // краткий синтаксис,
+// неявно возвращает результат
+var func = (x, y) => {
+ return x + y;
+}; // блочный синтаксис,
+// явно возвращает результат
```
## Возвращаемые объектные строки (литералы)
@@ -326,16 +326,16 @@ callback = callback || (() => {}); // ok
// Пустая стрелочная функция возвращает undefined
let empty = () => {};
-(() => 'foobar')();
+(() => "foobar")();
// Вернёт "foobar"
// (Это Immediately Invoked Function Expression
// смотри 'IIFE' в справочнике)
-var simple = a => a > 15 ? 15 : a;
+var simple = (a) => (a > 15 ? 15 : a);
simple(16); // 15
simple(10); // 10
-let max = (a, b) => a > b ? a : b;
+let max = (a, b) => (a > b ? a : b);
// Удобные операции над массивами: filter, map, ...
@@ -344,25 +344,27 @@ var arr = [5, 6, 13, 0, 1, 18, 23];
var sum = arr.reduce((a, b) => a + b);
// 66
-var even = arr.filter(v => v % 2 == 0);
+var even = arr.filter((v) => v % 2 == 0);
// [6, 0, 18]
-var double = arr.map(v => v * 2);
+var double = arr.map((v) => v * 2);
// [10, 12, 26, 0, 2, 36, 46]
// Более короткие цепочки promise-ов
-promise.then(a => {
- // ...
-}).then(b => {
- // ...
-});
+promise
+ .then((a) => {
+ // ...
+ })
+ .then((b) => {
+ // ...
+ });
// Стрелочные функции без параметров, которые визуально легче разбирать
-setTimeout( () => {
- console.log('Я буду раньше');
- setTimeout( () => {
+setTimeout(() => {
+ console.log("Я буду раньше");
+ setTimeout(() => {
// deeper code
- console.log('Я буду позже');
+ console.log("Я буду позже");
}, 1);
}, 1);
```
diff --git a/files/ru/web/javascript/reference/functions/default_parameters/index.md b/files/ru/web/javascript/reference/functions/default_parameters/index.md
index 5e31425816deab..34fece756cd85f 100644
--- a/files/ru/web/javascript/reference/functions/default_parameters/index.md
+++ b/files/ru/web/javascript/reference/functions/default_parameters/index.md
@@ -8,6 +8,7 @@ tags:
- Экспериментальный
translation_of: Web/JavaScript/Reference/Functions/Default_parameters
---
+
{{jsSidebar("Functions")}}
**Параметры по умолчанию** позволяют задавать формальным параметрам функции значения по умолчанию в случае, если функция вызвана без аргументов, или если параметру явным образом передано значение `undefined`.
@@ -36,15 +37,15 @@ function multiply(a, b) {
}
multiply(5, 2); // 10
-multiply(5); // NaN !
+multiply(5); // NaN !
```
Чтобы такого не происходило, в теле функции использовался код подобный тому, что находится во второй строчке, где в случае, если функция `multiply` вызывалась только c одним аргументом, параметру `b` присваивалось значение `1`:
```js
function multiply(a, b) {
- b = typeof b !== 'undefined' ? b : 1;
- return a*b;
+ b = typeof b !== "undefined" ? b : 1;
+ return a * b;
}
multiply(5, 2); // 10
@@ -55,7 +56,7 @@ multiply(5); // 5
```js
function multiply(a, b = 1) {
- return a*b;
+ return a * b;
}
multiply(5, 2); // 10
@@ -75,12 +76,12 @@ function test(num = 1) {
}
// num не передано, или передано undefined:
-test(); // 'number' (num получил значение 1)
+test(); // 'number' (num получил значение 1)
test(undefined); // 'number' (и здесь num получил значение 1)
// num передано значение null или другое "ложное" значение:
-test(''); // 'string' (num получил значение '')
-test(null); // 'object' (num получил значение null)
+test(""); // 'string' (num получил значение '')
+test(null); // 'object' (num получил значение null)
```
### Параметры по умолчанию вычисляются в момент вызова функции
@@ -101,7 +102,7 @@ append(2); // [2], а не [1, 2]
```js
function callSomething(thing = something()) {
- return thing;
+ return thing;
}
let numberOfTimesCalled = 0;
@@ -119,51 +120,57 @@ callSomething(); // 2
В параметрах по умолчанию можно использовать значения предыдущих (расположенных левее в списке) параметров:
```js
-function greet(name, greeting, message = greeting + ' ' + name) {
- return [name, greeting, message];
+function greet(name, greeting, message = greeting + " " + name) {
+ return [name, greeting, message];
}
-greet('David', 'Hi'); // ["David", "Hi", "Hi David"]
-greet('David', 'Hi', 'Happy Birthday!'); // ["David", "Hi", "Happy Birthday!"]
+greet("David", "Hi"); // ["David", "Hi", "Hi David"]
+greet("David", "Hi", "Happy Birthday!"); // ["David", "Hi", "Happy Birthday!"]
```
Следующий пример ещё раз иллюстрирует эту возможность, а также позволяет ещё раз сравнить два способа достижения одного и того же результата: с использованием инициализации параметров по умолчанию и без её использования:
```js
function go() {
- return ":P"
+ return ":P";
}
-function withDefaults(a, b = 5, c = b, d = go(), e = this,
- f = arguments, g = this.value) {
- return [a,b,c,d,e,f,g];
+function withDefaults(
+ a,
+ b = 5,
+ c = b,
+ d = go(),
+ e = this,
+ f = arguments,
+ g = this.value,
+) {
+ return [a, b, c, d, e, f, g];
}
-function withoutDefaults(a, b, c, d, e, f, g){
- switch(arguments.length){
+function withoutDefaults(a, b, c, d, e, f, g) {
+ switch (arguments.length) {
case 0:
- a
+ a;
case 1:
- b = 5
+ b = 5;
case 2:
- c = b
+ c = b;
case 3:
d = go();
case 4:
- e = this
+ e = this;
case 5:
- f = arguments
+ f = arguments;
case 6:
g = this.value;
default:
}
- return [a,b,c,d,e,f,g];
+ return [a, b, c, d, e, f, g];
}
-withDefaults.call({value:"=^_^="});
+withDefaults.call({ value: "=^_^=" });
// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
-
-withoutDefaults.call({value:"=^_^="});
+withoutDefaults.call({ value: "=^_^=" });
// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
```
@@ -174,7 +181,9 @@ withoutDefaults.call({value:"=^_^="});
```js
// Вызовет ошибку ReferenceError!
function f(a = go()) {
- function go(){return ":P"}
+ function go() {
+ return ":P";
+ }
}
f(); // ReferenceError: go is not defined
```
@@ -184,7 +193,7 @@ f(); // ReferenceError: go is not defined
До появления версии Gecko 26, следующий код приводил к {{jsxref("SyntaxError")}}. Это было исправлено в {{bug(777060)}} и с тех пор работает корректно. Аргументы, передаваемые при вызове функции, становятся значениями формальных параметров независимо от наличия у последних инициализации по умолчанию, а также независимо от присутствия у функции других параметров, находящихся правее в списке параметров и не имеющих инициализации.
```js
-function f(x=1, y) {
+function f(x = 1, y) {
return [x, y];
}
@@ -197,7 +206,7 @@ f(2); // [2, undefined];
При инициализации параметров по умолчанию можно использовать синтаксическую конструкцию деструктурирующего присваивания:
```js
-function f([x, y] = [1, 2], {z: z} = {z: 3}) {
+function f([x, y] = [1, 2], { z: z } = { z: 3 }) {
return x + y + z;
}