recursal/MDN huggingface dataset:
Руководство JavaScript
======================

"Руководство по JavaScript" покажет вам как использовать JavaScript и даст общее представление о языке. Если вам нужна исчерпывающая информация о возможностях языка, посмотрите руководство JavaScript.

Главы
-----

Это руководство разделено на несколько глав:

* Введение
Об этом руководстве
О JavaScript
JavaScript и Java
ECMAScript
Инструменты
Hello World
* Грамматика и типы
Базовый синтаксис и комментарии
Объявления
Область видимости переменных
Поднятие переменных
Структуры и типы данных
Литералы
* Порядок выполнения и обработка ошибок
`if...else`
`switch`
`try`/`catch`/`throw`
Объекты `Error`
Объект `Promise`
* Циклы и итерации
`for while do...while break/continue for..in for..of`

* Функции
Объявление функций
Вызов функций
Область видимости функций
Замыкания
Аргументы и параметры
Стрелочные функции
* Выражения и операторы
Присваивание и Сравнение
Арифметические операторы
Побитовые операторы и логические операторы
Условный (тернарный) операторы
* Числа и даты Числовые литералы
Объект `Number`
Объект `Math`
Объект `Date`
* Форматирование текста
Строковые литералы
Объект `String`
Шаблонные литералы
Интернационализация
Регулярные выражения

* Индексированные коллекции
Массивы
Типизированные массивы
* Коллекции
`Map`
`WeakMap`
`Set`
`WeakSet`
* Работа с объектами
Объекты и свойства
Создание объектов
Определение методов
Геттеры и Сеттеры
* Подробнее про объектную модель (en-US)
Прототипно-ориентированное ООП (en-US)
Создание иерархии объектов (en-US)
Наследование (en-US)

* Промисы
Гарантии
Цепочка вызовов
Распространённые ошибки
Композиция
Порядок выполнения
* Итераторы и Генераторы
Итераторы
Итерируемые объекты
Генераторы
* Мета
программирование
Объект `Proxy`
Обработчики и ловушки
Отзываемый `Proxy`
Рефлексия
* Следующая статья »
Стандартные встроенные объекты
==============================

Сводка
------

Эта глава описывает все стандартные встроенные объекты JavaScript, вместе с их методами и свойствами.

Термин «глобальные объекты» (или стандартные встроенные объекты) здесь не следует путать с самим *глобальным объектом*. Далее в главе под этим обозначением понимаются *объекты в глобальном пространстве имён* (но только, если не используется строгий режим ECMAScript 5! В противном случае они возвращают `undefined`). Сам же *глобальный объект* в глобальном пространстве имён доступен через оператор `this`. На самом деле, глобальное пространство имён *состоит из* свойств глобального объекта (в том числе включая унаследованные свойства, если они есть).

Другие объекты в глобальном пространстве имён создаются либо с помощью пользовательских скриптов, либо предоставляются приложением хоста. Объекты хоста, доступные в контекстах браузера, задокументированы в справке по API (en-US). Для получения дополнительной информации о различии между DOM и ядром JavaScript, смотрите обзор технологии JavaScript.

Стандартные объекты (по категориям)
-----------------------------------

### Значения

Глобальные свойства, возвращающие простое значение.

* `Infinity`
* `NaN`
* `undefined`
* литерал `null`
### Функции

Глобальные функции, возвращающие результат определённой подпрограммы.

* `eval()`
* `uneval()` (en-US) 
Non-standard
* `isFinite()`
* `isNaN()`
* `parseFloat()`
* `parseInt()`
* `decodeURI()`
* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()`
* `escape()` 
Устарело
* `unescape()` 
Устарело
### Фундаментальные объекты

Общие языковые объекты, функции и ошибки.

* `Object`
* `Function`
* `Boolean`
* `Symbol`
* `Error`
* `EvalError`
* `InternalError`
* `RangeError`
* `ReferenceError`
* `SyntaxError`
* `TypeError`
* `URIError`
### Числа и даты

Объекты, имеющие дело с числами, датами и математическими вычислениями.

* `Number`
* `Math`
* `Date`
### Обработка текста

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

* `String`
* `RegExp`
### Индексированные коллекции

Коллекции, упорядоченные по индексам. Массивоподобные объекты.

* `Array`
* `Int8Array`
* `Uint8Array` (en-US)
* `Uint8ClampedArray`
* `Int16Array` (en-US)
* `Uint16Array` (en-US)
* `Int32Array`
* `Uint32Array` (en-US)
* `Float32Array`
* `Float64Array`
### Коллекции по ключу

Коллекции объектов по ключу. Элементы обходятся в порядке вставки.

* `Map` (en-US)
* `Set`
* `WeakMap`
* `WeakSet`
### Структурированные данные

Буферы данных и Объектная нотация JavaScript (**J**ava**S**cript **O**bject **N**otation).

* `ArrayBuffer` (en-US)
* `DataView` (en-US)
* `JSON`
### Объекты управляющих абстракций

* `Promise`
### Рефлексия

* `Reflect` 
Экспериментальная возможность
* `Proxy` 
Экспериментальная возможность
### Интернационализация

Дополнения к ядру ECMAScript, отвечающие за функциональность, чувствительную к языку.

* `Intl`
* `Intl.Collator`
* `Intl.DateTimeFormat`
* `Intl.NumberFormat`
### Нестандартные объекты

* `Generator` 
Non-standard
* `Iterator` (en-US) 
Non-standard
* `ParallelArray` 
Non-standard
* `StopIteration` 
Non-standard
### Прочее

* Аргументы функции (`arguments`)
Определение методов
===================

Начиная с ECMAScript 6, существует короткий синтаксис для определения методов в инициализаторе объекта. По сути, это сокращение для функции, которая назначена имени метода.

Синтаксис
---------
```

var obj = {
  property([parameters]) {},
  get property() {},
  set property(value) {},
  * generator() {}
};
```

Описание
--------

Короткий синтаксис похожий на синтаксис getter'ов и setter'ов представленных в ECMAScript 5.

Следующий код:


```js
var obj = {
  foo: function () {},
  bar: function () {},
};
```


Вы теперь можете сократить до:


```js
var obj = {
  foo() {},
  bar() {},
};
```

### Сокращение методов-генераторов

Методы-генераторы также могут быть определены используя короткий синтаксис. Обратите внимание, что звёздочка (\*) в коротком синтаксисе должна быть перед именем свойства генератора. То есть, `* g(){}` будет работать, а `g *(){}` не будет.


```js
// Используя свойство с именем (pre-ES6)
var obj2 = {
  g: function\* () {
    var index = 0;
    while (true) yield index++;
  },
};

// Тот же объект используя короткий синтаксис
var obj2 = {
  \*g() {
    var index = 0;
    while (true) yield index++;
  },
};

var it = obj2.g();
console.log(it.next().value); // 0
console.log(it.next().value); // 1
```

### Определения методов (ES6) не могут быть конструкторами

Все определения методов кроме методов-генераторов не могут быть конструкторами и будут выбрасывать `TypeError` если вы попытаетесь создать их экземпляр.


```js
var obj = {
  method() {},
};
new obj.method(); // TypeError: obj.method is not a constructor

var obj = {
  \*g() {},
};
new obj.g(); // Генератор
```

Примеры
-------

### Простой тестовый пример


```js
var obj = {
  a: "foo",
  b() {
    return this.a;
  },
};
console.log(obj.b()); // "foo"
```

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

Короткий синтаксис также поддерживает вычисляемые имена свойств.


```js
var bar = {
  foo0: function () {
    return 0;
  },
  foo1() {
    return 1;
  },
  ["foo" + 2]() {
    return 2;
  },
};

console.log(bar.foo0()); // 0
console.log(bar.foo1()); // 1
console.log(bar.foo2()); // 2
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-method-definitions |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `get`
* `set`
* Lexical grammar
setter
======

Оператор **`set`** связывает свойство объекта с функцией, которая будет вызвана при попытке установить это свойство.

Синтаксис
---------
```

{set prop(val) { . . . }}
{set [expression](val) { . . . }}
```

### Параметры

`prop`

Имя свойства для привязки к заданной функции.


`val`

Псевдоним переменной, которая хранит значение, неудавшегося определения `prop.`

expression

Начиная с ECMAScript 6, вы также можете использовать выражения для вычисляемого имя свойства для привязки к данной функции.

Описание
--------

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

Обратите внимание на следующие моменты при работе с синтаксисом `set`:

* Он может иметь идентификатор, который является либо числом, либо строкой;
* Он должен иметь ровно один параметр (смотрите Incompatible ES5 change: literal getter and setter functions must now have exactly zero or one arguments для более подробной информации);
* Он не должен объявляться в литерале объекта, с другим набором или вводом данных для того же самого свойства.
 ( `{ set x(v) { }, set x(v) { } }` и `{ x: ..., set x(v) { } }` запрещены)

Сеттер может быть удалён оператором `delete`.

Примеры
-------

### Определение сеттера при инициализации новых объектов

Это позволит определить псевдо-параметр `current` объекта `o`, который задаёт значение, обновляющее значение `log`:


```js
var o = {
  set current(str) {
    this.log[this.log.length] = str;
  },
  log: [],
};
```


`обратите внимание, что current` не определён и любые попытки доступа к нему вернут `undefined`.

### Удаление сеттера оператором `delete`

Если вы хотите удалить сеттер, вы можете просто его `удалить`:


```js
delete o.current;
```

### Определение сеттера для существующих объектов используя `defineProperty`

Чтобы добавить сеттер на существующий объект в любое время, используйте `Object.defineProperty()`.


```js
var o = { a: 0 };

Object.defineProperty(o, "b", {
  set: function (x) {
    this.a = x / 2;
  },
});

o.b = 10; // Запускает сеттер, который присваивает 10 / 2 (5) свойству 'a'
console.log(o.a); // 5
```

### Использование вычисляемого имени свойства


```js
var expr = "foo";

var obj = {
  baz: "bar",
  set [expr](v) {
    this.baz = v;
  },
};

console.log(obj.baz); // "bar"
obj.foo = "baz"; // запускает сеттер
console.log(obj.baz); // "baz"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-method-definitions |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* getter
* `delete`
* `Object.defineProperty()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()`
* Defining Getters and Setters в руководстве по JavaScript
arguments.callee
================

Свойство `callee псевдомассива arguments` хранит ссылку на функцию-родитель.

Описание
--------

**Предупреждение:** **Внимание:** В ES5 strict mode использование `arguments.callee` запрещено.

### Зачем вообще использовать `arguments.callee`?

В ранних версиях javaScript отсутствовала такая фишка, как Named Function Expression и единственным спасением было свойство **callee**. К примеру:


```js
var f = function test() {
  alert(typeof test); //undefined
  alert(typeof arguments.callee); //function
};
```


В нынешние времена, когда мы уже можем работать с *NFE*, надобность в использовании свойства **callee** сама собой отпадает\*\*.\*\*


```js
var f = function test() {
  alert(typeof test); //function
};
```


Действительно незаменимым оно остаётся всего в одной ситуации. Когда мы создаём анонимную функцию напрямую через конструктор *Function.*


```js
var b = new Function("", "alert(typeof arguments.callee)");
```

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

### Использование `arguments.callee` для создания рекурсии


```js
var factorial = function (n) {
  return n == 1 ? 1 : n \* arguments.callee(n - 1);
};

factorial(7);
```

Specifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-arguments-exotic-objects |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `Function`
arguments.length
================

**`arguments.length`** свойство, содержащее число аргументов переданных в функцию.

Синтаксис
---------
```

arguments.length
```

Описание
--------

arguments.length свойство содержащее число аргументов переданных в функцию. Оно может быть больше или меньше опряденного параметра count (см. `Function.length`).

Примеры
-------

### `Использование arguments.length`

В этом примере мы определяем функцию, которая может сложить 2 или более чисел вместе.


```js
function adder(base /\*, n2, ... \*/) {
  base = Number(base);
  for (var i = 1; i < arguments.length; i++) {
    base += Number(arguments[i]);
  }
  return base;
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-arguments-exotic-objects |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Function`
* `Function.length`
Оператор группировки
====================

Оператор группировки `( )` контролирует порядок выполнения в выражениях.

Интерактивный пример
--------------------

Синтаксис
---------
```

 ( )
```

Описание
--------

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

Примеры
-------

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


```js
let a = 1;
let b = 2;
let c = 3;

// обычный порядок
a + b \* c; // 7
// выполнится так
a + (b \* c); // 7

// теперь переопределим порядок
// сложение будет до умножения
(a + b) \* c; // 9

// что эквивалентно следующему
a \* c + b \* c; // 9
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-grouping-operator |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Приоритет операторов
* `delete`
* `typeof`
Логическое нулевое присваивание (??=)
=====================================

Оператор логического нулевого присваивания (`x ??= y`) присваивает значение переменной `x`, если она содержит похожее на null значение (en-US) (`null` или `undefined`).

Интерактивный пример
--------------------

Синтаксис
---------


```js
expr1 ??= expr2;
```

Описание
--------

### Сокращённое вычисление

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

`(выражение без null или undefined) ?? следующее выражение` останавливает вычисление на левом выражении, если его результат отличен от `null` или `undefined`.

Сокращённое вычисление означает, что `следующее выражение` **не будет вычислено**, соответственно не будет никаких последствий, связанных с ним (например, если `следующее выражение` содержит вызов функции, то он никогда не произойдёт).

Логическое нулевое присваивание также поддерживает сокращённое вычисление, поэтому `x ??= y` по сути то же самое, что и выражение ниже:


```js
x ?? (x = y);
```


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


```js
x = x ?? y;
```

Примеры
-------

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


```js
function config(options) {
  options.duration ??= 100;
  options.speed ??= 25;
  return options;
}

config({ duration: 125 }); // { duration: 125, speed: 25 }
config({}); // { duration: 100, speed: 25 }
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Оператор нулевого слияния (`??`)
* Похожее на null значение (en-US)
* Истиноподобное значение
* Ложноподобное значение
Присваивание логического И (&&=)
================================

Оператор присваивания логического И (`x &&= y`) присваивает значение переменной `x` только в случае, если её текущее значение истинноподобно.

Интерактивный пример
--------------------

Синтаксис
---------


```js
expr1 &&= expr2;
```

Описание
--------

### Сокращённое вычисление

Логический оператор И вычисляется слева направо, делая возможным сокращённое вычисление выражения, согласно следующему правилу:

`(ложноподобное выражение) && следующее выражение` — вычисление останавливается на ложноподобном выражении;

 Сокращённое вычисление хорошо тем, что `следующее выражение` не будет **вычислено**, т.е. всё, связанное с ним, будет проигнорировано (например, если
 `следующее выражение` представляет собой вызов функции, то он никогда не произойдёт).

Оператор присваивания логического И также поддерживает сокращённое вычисление, поэтому `x &&= y` по сути то же самое, что и выражение ниже:


```js
x && (x = y);
```


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


```js
x = x && y;
```

Примеры
-------

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


```js
let x = 0;
let y = 1;

x &&= 0; // 0
x &&= 1; // 0
y &&= 1; // 1
y &&= 0; // 0
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Логическое И (&&)
* Оператор нулевого слияния (`??`)
* Присваивание побитового И (`&=`) (en-US)
* Истиноподобное значение
* Ложноподобное значение
Присваивание логического ИЛИ (||=)
==================================

Оператор присваивания логического ИЛИ (`x ||= y`) присваивает значение переменной `x` только в случае, если её текущее значение ложноподобно.

Интерактивный пример
--------------------

Синтаксис
---------


```js
expr1 ||= expr2;
```

Описание
--------

### Сокращённое вычисление

Оператор логического ИЛИ работает следующим образом:


```js
x || y;
// возвращает x, если x истинноподобен
// возвращает y, если x не истинноподобен
```


Оператор логического ИЛИ OR производит вычисление по сокращённой схеме: второй операнд будет вычисляться только в случае, если при вычислении первого операнда не удалось получить значение.

Оператор присваивания логического ИЛИ также поддерживает сокращённое вычисление, т.е. выполнит операцию присваивания только при вычислении правого выражения. Проще говоря, `x ||= y` эквивалентно следующему коду:


```js
x || (x = y);
```


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


```js
x = x || y;
```


Обратите внимание, что математические и побитовые операторы присваивания работают по-разному.

Примеры
-------

### Определение значения по умолчанию

Если в элементе с идентификатором "lyrics" нет содержимого, то следующее выражение вставит в него надпись:


```js
document.getElementById("lyrics").textContent ||= "Нет слов.";
```


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

Примечание: обратите внимание на значение в левом операнде. Если это пустая строка (ложноподобное значение), то должно использовать оператор `||=`, в противном случае — оператор `??=` (если ожидается получение значения `null` или `undefined`).

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Логическое ИЛИ(||)
* Оператор нулевого слияния (`??`)
* Оператор присваивания побитового ИЛИ (`|=`) (en-US)
* Истиноподобное значение
* Ложноподобное значение
Сложение с присваиванием (+=)
=============================

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

Интерактивный пример
--------------------

Синтаксис
---------
```

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

Примеры
-------

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


```js
// Assuming the following variables
// foo = 'foo'
// bar = 5
// baz = true

// Number + Number -> addition
bar += 2; // 7

// Boolean + Number -> addition
baz += 1; // 2

// Boolean + Boolean -> addition
baz += false; // 1

// Number + String -> concatenation
bar += "foo"; // "5foo"

// String + Boolean -> concatenation
foo += false; // "foofalse"

// String + String -> concatenation
foo += "bar"; // "foobar"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Assignment operators in the JS guide
* Оператор сложения
Bitwise AND (&)
===============

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

Интерактивный пример
--------------------

Синтаксис
---------
```

a & b
```

Описание
--------

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

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


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

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

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

| a | b | a И b |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |


```js
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
```


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

Примеры
-------

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


```js
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
5 & 2; // 0
```

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-BitwiseANDExpression |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Bitwise operators in the JS guide
* Bitwise AND assignment operator (en-US)