Number - JavaScript

Number
======

Объект **`Number`** является объектом-обёрткой, позволяющей вам работать с числовыми значениями. Объект `Number` создаётся через конструктор `Number()`.

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

new Number(value);
var a = new Number('123'); // a === 123 is false
var b = Number('123'); // b === 123 is true
a instanceof Number; // is true
b instanceof Number; // is false
```

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

`value`

Числовое значение, которое примет объект после создания.

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

Несколько замечаний относительно использования объекта `Number`:

* Если аргумент не может быть преобразован в число, возвращается `NaN`.
* В неконструкторном контексте (то есть, без оператора `new`), объект `Number` может использоваться для проведения преобразования типов.
Свойства
--------

`Number.EPSILON`
Экспериментальная возможность

Наименьший интервал между двумя представимыми числами.

`Number.MAX_SAFE_INTEGER`
Экспериментальная возможность

Максимальное целое число, которое можно безопасно использовать в JavaScript (`253 - 1`).

`Number.MAX_VALUE`

Наибольшее представимое положительное число.

`Number.MIN_SAFE_INTEGER`
Экспериментальная возможность

Минимальное целое число, которое можно безопасно использовать в (`-(253 - 1)`).

`Number.MIN_VALUE`

Наименьшее представимое положительное число — то есть, самое близкое к нулю положительное число (которое ещё не является нулём).

`Number.NaN`

Специальное значение для представления «не числа».

`Number.NEGATIVE_INFINITY`

Специальное значение для представления отрицательной бесконечности; возвращается при переполнении.

`Number.POSITIVE_INFINITY`

Специальное значение для представления положительной бесконечности; возвращается при переполнении.

`Number.prototype` (en-US)

Позволяет добавлять свойства к объекту `Number`.

Методы
------

`Number.isNaN()`
Экспериментальная возможность

Определяет, является ли переданное значение значением `NaN`.

`Number.isFinite()`
Экспериментальная возможность

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

`Number.isInteger()`
Экспериментальная возможность

Определяет, является ли тип переданного значения «числом», а само число — целым значением.

`Number.isSafeInteger()`
Экспериментальная возможность

Определяет, является ли переданное значение безопасным целым числом (числом в диапазоне от `-(253 - 1)` до `253 - 1`).

~~`Number.toInteger()`~~

~~Использовался для вычисления переданного значения и преобразования его в целое число (или бесконечность `Infinity`), но был удалён.~~

`Number.parseFloat()`
Экспериментальная возможность

Представляет собой тот же самый метод, что и метод `parseFloat` глобального объекта.

`Number.parseInt()`
Экспериментальная возможность

Представляет собой тот же самый метод, что и метод `parseInt` глобального объекта.

Экземпляры объекта `Number`
---------------------------

Все экземпляры объекта `Number` наследуются от `Number.prototype` (en-US). Объект прототипа конструктора `Number` может быть изменён, чтобы затронуть все экземпляры объекта `Number`.

### Методы

{{page('/ru/docs/Web/JavaScript/Reference/Global\_Objects/Number/prototype', 'Methods')}}Примеры
-------

### Пример: использование объекта `Number` для присваивания значений числовым переменным

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

```js
var biggestNum = Number.MAX\_VALUE;
var smallestNum = Number.MIN\_VALUE;
var infiniteNum = Number.POSITIVE\_INFINITY;
var negInfiniteNum = Number.NEGATIVE\_INFINITY;
var notANum = Number.NaN;
```

### Пример: целочисленный диапазон для объекта `Number`

Следующий пример показывает, какие минимальное и максимальное целочисленные значения может представить объект `Number` (за подробностями обращайтесь к стандарту EcmaScript, главе *8.5 Тип Number*):

```js
var biggestInt = 9007199254740992;
var smallestInt = -9007199254740992;
```

При разборе данных, сериализованных в JSON, можно ожидать, что целые значения, выпадающие из этого диапазона будут повреждены, когда парсер JSON приведёт их к типу `Number`. Возможным обходным путём может быть использование объекта `String`.

### Пример: использование `Number` для преобразования объекта `Date`

В следующем примере объект `Date` преобразуется в числовое значение с использование объекта `Number` в качестве функции:

```js
var d = new Date("December 17, 1995 03:24:00");
console.log(Number(d));
```

Пример выведет "819199440000".

### Пример: преобразование строк с числами в числа

```js
Number("123"); // 123
Number(""); // 0
Number("0x11"); // 17
Number("0b11"); // 3
Number("0o11"); // 9
Number("foo"); // NaN
Number("100a"); // NaN
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number-objects |

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

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

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

* `NaN`
* Глобальный объект `Math`


undefined - JavaScript

undefined
=========

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

Значение глобального свойства **`undefined`** представляет значение `undefined`. Это одно из примитивных значений JavaScript.

| Атрибуты свойства `undefined` |
| --- |
| Записываемое | нет |
| Перечисляемое | нет |
| Настраиваемое | нет |

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

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

undefined
```

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

`undefined` является свойством *глобального объекта*, то есть, это переменная в глобальной области видимости. Начальным значением `undefined` является примитивное значение `undefined`.

В современных браузерах (JavaScript 1.8.5 / Firefox 4+), `undefined` является ненастраиваемым и незаписываемым свойством, в соответствии со спецификацией ECMAScript 5. Даже когда это не так, избегайте его переопределения.

Переменная, не имеющая присвоенного значения, обладает типом `undefined`. Также `undefined` возвращают метод или инструкция, если переменная, участвующая в вычислениях, не имеет присвоенного значения. Функция возвращает `undefined`, если она не возвращает какого-либо значения.

Поскольку `undefined` не является зарезервированным словом (en-US), он может использоваться в качестве идентификатора (имени переменной) в любой области видимости, за исключением глобальной.

```js
// печатает 'foo string'
(function () {
  var undefined = "foo";
  console.log(undefined, typeof undefined);
})();

// печатает 'foo string'
(function (undefined) {
  console.log(undefined, typeof undefined);
})("foo");
```

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

### Пример: строгое сравнение и `undefined`

Вы можете использовать `undefined` и операторы строгого равенства или неравенства для определения того, имеет ли переменная значение. В следующем коде переменная `x` не определена и инструкция `if` вычисляется в `true`.

```js
var x;
if (x === undefined) {
  // эти инструкции будут выполнены
} else {
  // эти инструкции не будут выполнены
}
```

**Примечание:** здесь используется оператор строгого равенства (идентичности) вместо простого оператора равенства, поскольку `x == undefined` также проверяет, является ли `x` равным `null`, в то время как оператор идентичности этого не делает. `null` не эквивалентен `undefined`. Для более подробной информации смотрите операторы сравнения (en-US).

### Пример: оператор `typeof` и `undefined`

В качестве альтернативы можно использовать оператор `typeof`:

```js
var x;
if (typeof x === "undefined") {
  // эти инструкции будут выполнены
}
```

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

```js
// переменная x не была определена ранее
if (typeof x === "undefined") {
  // вычислится в true без ошибок
  // эти инструкции будут выполнены
}

if (x === undefined) {
  // выкинет ReferenceError
}
```

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

### Пример: оператор `void` и `undefined`

Третьей альтернативой является оператор `void`.

```js
var x;
if (x === void 0) {
  // эти инструкции будут выполнены
}

// переменная y не была определена ранее
if (y === void 0) {
  // выкинет ReferenceError (в отличие от оператора `typeof`)
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-undefined |

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

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

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

* `NaN`
* `null`


Boolean - JavaScript

Boolean
=======

Объект **`Boolean`** представляет значения истинности: `true` или `false`.

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

Значение, переданное первым параметром, при необходимости преобразуется в логическое значение. Если значение опущено или равно `0`, `-0`, `null`, `false`, `NaN`, `undefined` или пустой строке (`""`), объект имеет начальное значение, равное `false`. Все остальные значения, включая любые объекты или строку `"false"`, создают объект с начальным значением, равным `true`.

Не путайте примитивные значения `true` и `false` логического типа со значениями `true` и `false` объекта `Boolean`.

Любой объект, чьё значение не является равным `undefined` или `null`, включая сам объект `Boolean` со значением, равным `false`, вычисляется в `true` при передаче его в условное выражение. Например, условие в следующей инструкции `if` вычисляется в `true`:

```js
var x = new Boolean(false);
if (x) {
  // этот код будет выполнен
}
```

Это поведение не применяется к примитивам логического типа. Например, условие в следующей инструкции `if` вычисляется в `false`:

```js
var x = false;
if (x) {
  // этот код не будет выполнен
}
```

Не используйте объект `Boolean` для преобразования нелогического значения в логическое значение. Вместо этого используйте `Boolean` в качестве функции:

```js
var x = Boolean(expression); // предпочтительно
var x = new Boolean(expression); // не используйте
```

Если вы определите любой объект, включая объект `Boolean` со значением `false`, в качестве начального значения объекта `Boolean`, новый объект `Boolean` будет иметь значение `true`.

```js
var myFalse = new Boolean(false); // начальное значение равно false
var g = new Boolean(myFalse); // начальное значение равно true
var myString = new String("Привет"); // строковый объект
var s = new Boolean(myString); // начальное значение равно true
```

Не используйте объект `Boolean` вместо примитива логического типа.

Конструктор
-----------

`Boolean()` (en-US)

Создаёт новый объект `Boolean`.

Свойства экземпляра
-------------------

Эти свойства определены в `Boolean.prototype` и есть у всех экземпляров `Boolean`.

`Boolean.prototype.constructor`

Функция-конструктор, создающая экземпляр объекта. Для экземпляров `Boolean` начальным значением является конструктор `Boolean` (en-US).

Методы экземпляра
-----------------

`Boolean.prototype.toString()`

Возвращает строку `true` или `false` в зависимости от значения объекта. Переопределяет метод `Object.prototype.toString()`.

`Boolean.prototype.valueOf()`

Возвращает примитивное значение объекта `Boolean`. Переопределяет метод `Object.prototype.valueOf()`.

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

### Создание объектов `Boolean` с начальным значением равным `false`

```js
const bNoParam = new Boolean();
const bZero = new Boolean(0);
const bNull = new Boolean(null);
const bEmptyString = new Boolean("");
const bfalse = new Boolean(false);
```

### Создание объектов `Boolean` с начальным значением равным `true`

```js
const btrue = new Boolean(true);
const btrueString = new Boolean("true");
const bfalseString = new Boolean("false");
const bSuLin = new Boolean("Su Lin");
const bArrayProto = new Boolean([]);
const bObjProto = new Boolean({});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-boolean-objects |

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

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

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

* Boolean
* Примитивные значения булева типа
* Логический тип данных в Википедии


WeakSet - JavaScript

WeakSet
=======

**`WeakSet`** — это набор значений, поддерживающих сборку мусора, включая объекты и незарегистрированные символы. Каждое значение в `WeakSet` может встречаться только один раз, оно уникально в коллекции `WeakSet`.

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

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

Ключевые отличия от `Set`:

* `WeakSet` — это набор только **объектов и символов**. В отличие от `Set` он не может содержать произвольные значения любого типа.
* `WeakSet` является *слабым* в том смысле, что ссылки на объекты в `WeakSet` хранятся *слабо*. Если нет других ссылок на значение, хранящееся в `WeakSet`, эти значения могут быть удалены сборщиком мусора.

**Примечание:** Это также означает, что нет списка текущих значений сохранённых в наборе. Объекты `WeakSet` не перечислимы.
### Вариант использования: обнаружение циклических ссылок

Функциям, которые вызывают себя рекурсивно, необходим способ защиты от циклических структур данных путём отслеживания того, какие объекты уже были обработаны.

Объекты `WeakSet` идеально подходят для этого:

```js
// Выполняем `fn` для всего, что хранится внутри объекта.
function execRecursively(fn, subject, _refs = new WeakSet()) {
  // Избегаем бесконечно рекурсии
  if (_refs.has(subject)) {
    return;
  }

  fn(subject);
  if (typeof subject === "object" && subject) {
    _refs.add(subject);
    for (const key in subject) {
      execRecursively(fn, subject[key], _refs);
    }
    _refs.delete(subject);
  }
}

const foo = {
  foo: "Foo",
  bar: {
    bar: "Bar",
  },
};

foo.bar.baz = foo; // Циклическая ссылка!
execRecursively((obj) => console.log(obj), foo);
```

Здесь `WeakSet` создаётся при первом запуске и передаётся вместе с каждым последующим вызовом функции (с использованием внутреннего параметра `_refs`).

Количество объектов или порядок их обхода не имеют значения, поэтому использование `WeakSet` более эффективно, чем `Set` для отслеживания ссылок на объекты, особенно если задействовано очень большое количество объектов.

Конструктор
-----------

`WeakSet()` (en-US)

Создаёт новый объект `WeakSet`.

Свойств экземпляра
------------------

Эти свойства определены в `WeakSet.prototype` и есть у всех экземпляров `WeakSet`.

`WeakSet.prototype.constructor`

Функция-конструктор, создающая экземпляр объекта. Для экземпляров `WeakSet` начальным значением является конструктор `WeakSet` (en-US).

`WeakSet.prototype[@@toStringTag]`

Начальным значением свойства `@@toStringTag` является строка `"WeakSet"`. Это свойство используется в `Object.prototype.toString()`.

Методы экземпляра
-----------------

`WeakSet.prototype.add()`

Добавляет `value` в объект `WeakSet`.

`WeakSet.prototype.delete()`

Удаляет `value` из `WeakSet`. После этого `WeakSet.prototype.has(value)` будет возвращать `false`.

`WeakSet.prototype.has()`

Возвращает булево значение, показывающее присутствует ли `value` в объекте `WeakSet` или нет.

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

### Использование `WeakSet`

```js
const ws = new WeakSet();
const foo = {};
const bar = {};

ws.add(foo);
ws.add(bar);

ws.has(foo); // true
ws.has(bar); // true

ws.delete(foo); // удаляем foo из набора
ws.has(foo); // false, foo был удалён
ws.has(bar); // true, bar сохранился
```

Обратите внимание, что `foo !== bar`. Хотя это похожие объекты, *это не **один и тот же объект***. И поэтому они оба добавляются в набор.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset-objects |

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

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

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

* Полифил `WeakSet` в `core-js`
* `Map` (en-US)
* `Set`
* `WeakMap`


encodeURI() - JavaScript

encodeURI()
===========

Метод **encodeURI ()** кодирует универсальный идентификатор ресурса (URI), замещая некоторые символы на одну, две, три или четыре управляющие последовательности, представляющие UTF-8 кодировку символа (четыре управляющие последовательности будут использованы только для символов, состоящих из двух «суррогатных» символов).

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

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

encodeURI(URI)
```

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

`URI`

Полный URI (en-US).

### Возвращаемое значение

Новая строка, представляющая собой строку-параметр, закодированную в виде универсального идентификатора ресурса (URI).

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

Предполагается, что URI является полным URI, поэтому метод не кодирует зарезервированные символы, имеющие особое значение в URI.

encodeURI заменяет все символы, **кроме** следующих с соответствующими UTF-8 управляющими последовательностями:

| Тип | Включения |
| --- | --- |
| Зарезервированные символы | `;` `,` `/` `?` `:` `@` `&` `=` `+` `$` |
| Неэкранируемые символы | латинские буквы, десятичные цифры, `-` `_` `.` `!` `~` `*` `'` `(` `)` |
| Score | `#` |

Заметим, что `encodeURI` сам по себе не может сформировать правильные HTTP GET и POST запросы, такие как XMLHTTPRequests, потому, что "&", "+", и "=" не закодированы, которые воспринимаются как специальные символы в GET и POST запросах. `encodeURIComponent`, однако, кодирует эти символы

Замечание: `URIError` будет брошена, если попытаться закодировать суррогат, который не является частью высоко-низкой пары, например:

```js
// низко-высокая пара - нормально
console.log(encodeURIComponent("\uD800\uDFFF"));

// один высокий суррогат бросит "URIError: malformed URI sequence"
console.log(encodeURIComponent("\uD800"));

// один низкий суррогат бросит "URIError: malformed URI sequence"
console.log(encodeURIComponent("\uDFFF"));
```

Также заметим, что следуя наиболее свежей RFC3986 для URL, которая делает квадратные скобки защищёнными (для IPv6) и таким образом не кодирует, когда формирование чего-либо, не являющегося частью URL (такое как домен), следующий сниппет поможет:

```js
function fixedEncodeURI(str) {
  return encodeURI(str).replace(/%5B/g, "[").replace(/%5D/g, "]");
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-encodeuri-uri |

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

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

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

* `decodeURI()`
* `encodeURIComponent()`
* `decodeURIComponent()`
* Base62x


ArrayBuffer - JavaScript

ArrayBuffer
===========

Объект **`ArrayBuffer`** используется для работы с бинарными данными. Он представляет собой ссылку на поток "сырых" двоичных данных, однако работать с ними напрямую возможности не даёт. Вместо этого, вы можете создать типизированный массив или объект `DataView`, который можно использовать для чтения и записи данных в **`ArrayBuffer`**.

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

new ArrayBuffer(length)
```

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

`length`

Длина создаваемого буфера в байтах.

### Возвращаемое значение

Новый объект `ArrayBuffer` определённого размера. Изначально содержимое равно 0.

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

Конструктор `ArrayBuffer` создаёт новый `ArrayBuffer` установленного в байтах размера.

### Создание буфера

* Из Base64 строки
* Из локального файла
Свойства
--------

`ArrayBuffer.length`

Длина конструктора `ArrayBuffer`, которая равна 1.

`ArrayBuffer.prototype` (en-US)

Позволяет расширить прототип всех `ArrayBuffer` объектов.

Методы
------

`ArrayBuffer.isView(arg)`

Возвращает `true` если `arg` – одно из представлений `ArrayBuffer`, например типизированный массив или `DataView`. Вернёт `false` в остальных случаях.

`ArrayBuffer.transfer(oldBuffer [, newByteLength])` (en-US)
Экспериментальная возможность

Вернёт новый `ArrayBuffer`, контент которого будет взят из данных `oldBuffer`, а затем усечён или дополнен нулевыми значениями до `newByteLength`.

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

В этом примере мы создаём 8-байтный буфер с `Int32Array` представлением:

```js
var buffer = new ArrayBuffer(8);
var view = new Int32Array(buffer);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer-objects |

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

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

Также
-----

* JavaScript типизированные массивы


Float64Array - JavaScript

Float64Array
============

Объект **`Float64Array`** представляет типизированный массив 64-битных чисел с плавающей запятой (соответствует типу `double` в языке C) с платформо-зависимым порядком байт.Если необходим контроль за порядком байт, то вместо этого объекта используйте `DataView`. Содержимое инициализируется значением `0`. Создав экземпляр **`Float64Array`** , можно получить доступ к элементам массива, используя методы объекта или стандартный синтаксис доступа к элементу массива по его индексу (с помощью скобочной нотации - квадратные скобки).

Syntax
------
```

new Float64Array(); // new in ES2017
new Float64Array(length);
new Float64Array(typedArray);
new Float64Array(object);
new Float64Array(buffer [, byteOffset [, length]]);
```

For more information about the constructor syntax and the parameters, see *TypedArray*.

Properties
----------

`Float64Array.BYTES_PER_ELEMENT`

Returns a number value of the element size. `8` in the case of an `Float64Array`.

Float64Array.length

Static length property whose value is 0. For the actual length (number of elements), see `Float64Array.prototype.length` (en-US).

`Float64Array.name` (en-US)

Returns the string value of the constructor name. In the case of the `Float64Array` type: "Float64Array".

`Float64Array.prototype` (en-US)

Prototype for the *TypedArray* objects.

Methods
-------

`Float64Array.from()` (en-US)

Creates a new `Float64Array` from an array-like or iterable object. See also `Array.from()`.

`Float64Array.of()` (en-US)

Creates a new `Float64Array` with a variable number of arguments. See also `Array.of()`.

`Float64Array` prototype
------------------------

All `Float64Array` objects inherit from `%TypedArray%.prototype` (en-US).

### Properties

`Float64Array.prototype.constructor`

Returns the function that created an instance's prototype. This is the `Float64Array` constructor by default.

`Float64Array.prototype.buffer` (en-US) Только для чтения

Returns the `ArrayBuffer` referenced by the `Float64Array` Fixed at construction time and thus **read only**.

`Float64Array.prototype.byteLength` (en-US) Только для чтения

Returns the length (in bytes) of the `Float64Array` from the start of its `ArrayBuffer`. Fixed at construction time and thus **read only.**

`Float64Array.prototype.byteOffset` (en-US) Только для чтения

Returns the offset (in bytes) of the `Float64Array` from the start of its `ArrayBuffer`. Fixed at construction time and thus **read only.**

`Float64Array.prototype.length` (en-US) Только для чтения

Returns the number of elements hold in the `Float64Array`. Fixed at construction time and thus **read only.**

### Methods

`Float64Array.prototype.copyWithin()` (en-US)

Copies a sequence of array elements within the array. See also `Array.prototype.copyWithin()`.

`Float64Array.prototype.entries()` (en-US)

Returns a new `Array Iterator` object that contains the key/value pairs for each index in the array. See also `Array.prototype.entries()`.

`Float64Array.prototype.every()` (en-US)

Tests whether all elements in the array pass the test provided by a function. See also `Array.prototype.every()`.

`Float64Array.prototype.fill()` (en-US)

Fills all the elements of an array from a start index to an end index with a static value. See also `Array.prototype.fill()`.

`Float64Array.prototype.filter()` (en-US)

Creates a new array with all of the elements of this array for which the provided filtering function returns true. See also `Array.prototype.filter()`.

`Float64Array.prototype.find()` (en-US)

Returns the found value in the array, if an element in the array satisfies the provided testing function or `undefined` if not found. See also `Array.prototype.find()`.

`Float64Array.prototype.findIndex()` (en-US)

Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found. See also `Array.prototype.findIndex()`.

`Float64Array.prototype.forEach()` (en-US)

Calls a function for each element in the array. See also `Array.prototype.forEach()`.

`Float64Array.prototype.includes()` (en-US)
Экспериментальная возможность

Determines whether a typed array includes a certain element, returning `true` or `false` as appropriate. See also `Array.prototype.includes()`.

`Float64Array.prototype.indexOf()` (en-US)

Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found. See also `Array.prototype.indexOf()`.

`Float64Array.prototype.join()`

Joins all elements of an array into a string. See also `Array.prototype.join()`.

`Float64Array.prototype.keys()` (en-US)

Returns a new `Array Iterator` that contains the keys for each index in the array. See also `Array.prototype.keys()`.

`Float64Array.prototype.lastIndexOf()` (en-US)

Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found. See also `Array.prototype.lastIndexOf()`.

`Float64Array.prototype.map()` (en-US)

Creates a new array with the results of calling a provided function on every element in this array. See also `Array.prototype.map()`.

`Float64Array.prototype.move()`
Non-standard
 Не реализовано

Former non-standard version of `Float64Array.prototype.copyWithin()` (en-US).

`Float64Array.prototype.reduce()` (en-US)

Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value. See also `Array.prototype.reduce()`.

`Float64Array.prototype.reduceRight()` (en-US)

Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value. See also `Array.prototype.reduceRight()`.

`Float64Array.prototype.reverse()` (en-US)

Reverses the order of the elements of an array — the first becomes the last, and the last becomes the first. See also `Array.prototype.reverse()`.

`Float64Array.prototype.set()`

Stores multiple values in the typed array, reading input values from a specified array.

`Float64Array.prototype.slice()` (en-US)

Extracts a section of an array and returns a new array. See also `Array.prototype.slice()`.

`Float64Array.prototype.some()` (en-US)

Returns true if at least one element in this array satisfies the provided testing function. See also `Array.prototype.some()`.

`Float64Array.prototype.sort()` (en-US)

Sorts the elements of an array in place and returns the array. See also `Array.prototype.sort()`.

`Float64Array.prototype.subarray()` (en-US)

Returns a new `Float64Array` from the given start and end element index.

`Float64Array.prototype.values()` (en-US)

Returns a new `Array Iterator` object that contains the values for each index in the array. See also `Array.prototype.values()`.

`Float64Array.prototype.toLocaleString()` (en-US)

Returns a localized string representing the array and its elements. See also `Array.prototype.toLocaleString()`.

`Float64Array.prototype.toString()` (en-US)

Returns a string representing the array and its elements. See also `Array.prototype.toString()`.

`Float64Array.prototype[@@iterator]()` (en-US)

Returns a new `Array Iterator` object that contains the values for each index in the array.

Examples
--------

Different ways to create a `Float64Array`:

```js
// From a length
var float64 = new Float64Array(2);
float64[0] = 42;
console.log(float64[0]); // 42
console.log(float64.length); // 2
console.log(float64.BYTES\_PER\_ELEMENT); // 8

// From an array
var arr = new Float64Array([21, 31]);
console.log(arr[1]); // 31

// From another TypedArray
var x = new Float64Array([21, 31]);
var y = new Float64Array(x);
console.log(y[0]); // 21

// From an ArrayBuffer
var buffer = new ArrayBuffer(32);
var z = new Float64Array(buffer, 0, 4);

// From an iterable
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var float64 = new Float64Array(iterable);
// Float64Array[1, 2, 3]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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

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

Compatibility notes
-------------------

Starting with ECMAScript 2015, `Float64Array` constructors require to be constructed with a `new` operator. Calling a `Float64Array` constructor as a function without `new`, will throw a `TypeError` from now on.

```js
var dv = Float64Array([1, 2, 3]);
// TypeError: calling a builtin Float64Array constructor
// without new is forbidden
```

```js
var dv = new Float64Array([1, 2, 3]);
```

See also
--------

* JavaScript typed arrays
* `ArrayBuffer`
* `DataView`


DataView - JavaScript

DataView
========

Представление **`DataView`** предоставляет низко-уровневый интерфейс для чтения и записи различных числовых типов в бинарном `ArrayBuffer`, независимо от порядка байтов (en-US) платформы.

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

### Порядок байтов

Многобайтовые числовые форматы представляются в памяти по-разному в зависимости от архитектуры машины (смотрите Endianness (en-US) для объяснения). Методы доступа `DataView` предоставляют явный способ обращения к данным вне зависимости от порядка байтов платформы.

```js
const littleEndian = (() => {
  const buffer = new ArrayBuffer(2);
  new DataView(buffer).setInt16(0, 256, true /\* littleEndian \*/);

  // Int16Array использует порядок байтов платформы.
  return new Int16Array(buffer)[0] === 256;
})();

console.log(littleEndian); // true или false
```

### 64-битные целые числа

Некоторые браузеры не поддерживают `DataView.prototype.setBigInt64()` (en-US) и `DataView.prototype.setBigUint64()` (en-US). Поэтому для использования 64-битных операций, которые будут работать в любом браузере, можно реализовать собственную функцию `getUint64()` для получения значений с точностью до `Number.MAX_SAFE_INTEGER`, чего достаточно в большинстве случаев.

```js
function getUint64(dataview, byteOffset, littleEndian) {
  // разбиваем 64-битное число на две 32-битных (по 4 байта) части
  const left = dataview.getUint32(byteOffset, littleEndian);
  const right = dataview.getUint32(byteOffset + 4, littleEndian);

  // объединяем два 32-битных значения
  const combined = littleEndian
    ? left + 2 \*\* 32 \* right
    : 2 \*\* 32 \* left + right;

  if (!Number.isSafeInteger(combined))
    console.warn(
      combined,
      "превышает MAX\_SAFE\_INTEGER. Точность может быть потеряна",
    );

  return combined;
}
```

В случае если вам всё же нужен полный 64-битный диапазон, можно создать `BigInt`. Хотя работа со встроенными значениями BigInt намного быстрее, чем с эквивалентами из самостоятельных реализаций, использование значений BigInt всегда будет намного медленнее, чем 32-битных целых чисел, из-за характера их переменного размера в JavaScript.

```js
const BigInt = window.BigInt,
  bigThirtyTwo = BigInt(32),
  bigZero = BigInt(0);
function getUint64BigInt(dataview, byteOffset, littleEndian) {
  // разбиваем 64-битное число на две 32-битных (по 4 байта) части
  const left = BigInt(dataview.getUint32(byteOffset | 0, !!littleEndian) >>> 0);
  const right = BigInt(
    dataview.getUint32(((byteOffset | 0) + 4) | 0, !!littleEndian) >>> 0,
  );

  // объединяем два 32-битных значения и возвращаем
  return littleEndian
    ? (right << bigThirtyTwo) | left
    : (left << bigThirtyTwo) | right;
}
```

Конструктор
-----------

`DataView()` (en-US)

Создаёт новый объект `DataView`.

Свойства экземпляра
-------------------

Эти свойства определены в `DataView.prototype` и есть у всех экземпляров `DataView`.

`DataView.prototype.buffer`

`ArrayBuffer`, связанный с представлением. Устанавливается в момент создания и **доступно только для чтения**.

`DataView.prototype.byteLength`

Размер представления в байтах. Устанавливается в момент создания и **доступно только для чтения**.

`DataView.prototype.byteOffset`

Смещение представления в байтах от начала его `ArrayBuffer`. Устанавливается в момент создания и **доступно только для чтения**.

`DataView.prototype.constructor`

Функция-конструктор, создающая экземпляр объекта. Для экземпляров `DataView` начальным значением является конструктор `DataView` (en-US).

`DataView.prototype[@@toStringTag]`

Начальным значением свойства `@@toStringTag` является строка `"DataView"`. Это свойство используется в `Object.prototype.toString()`.

Методы экземпляра
-----------------

`DataView.prototype.getBigInt64()` (en-US)

Читает 8 байтов начиная с указанного смещения этого `DataView` и интерпретирует их как 64-битное знаковое целое число.

`DataView.prototype.getBigUint64()` (en-US)

Читает 8 байтов начиная с указанного смещения этого `DataView` и интерпретирует их как 64-битное беззнаковое целое число.

`DataView.prototype.getFloat32()` (en-US)

Читает 4 байта начиная с указанного смещения этого `DataView` и интерпретирует их как 32-битное число с плавающей точкой.

`DataView.prototype.getFloat64()` (en-US)

Читает 8 байтов начиная с указанного смещения этого `DataView` и интерпретирует их как 64-битное число с плавающей точкой.

`DataView.prototype.getInt16()` (en-US)

Читает 2 байта начиная с указанного смещения этого `DataView` и интерпретирует их как 16-битное знаковое целое число.

`DataView.prototype.getInt32()` (en-US)

Читает 4 байта начиная с указанного смещения этого `DataView` и интерпретирует их как 32-битное знаковое целое число.

`DataView.prototype.getInt8()` (en-US)

Читает 1 байт начиная с указанного смещения этого `DataView` и интерпретирует его как 8-битное знаковое целое число.

`DataView.prototype.getUint16()` (en-US)

Читает 2 байта начиная с указанного смещения этого `DataView` и интерпретирует их как 16-битное беззнаковое целое число.

`DataView.prototype.getUint32()` (en-US)

Читает 4 байта начиная с указанного смещения этого `DataView` и интерпретирует их как 32-битное беззнаковое целое число.

`DataView.prototype.getUint8()` (en-US)

Читает 1 байт начиная с указанного смещения этого `DataView` и интерпретирует его как 8-битное беззнаковое целое число.

`DataView.prototype.setBigInt64()` (en-US)

Принимает BigInt и сохраняет его как 64-битное знаковое целое число в 8 байтах начиная с указанного смещения этого `DataView`.

`DataView.prototype.setBigUint64()` (en-US)

Принимает BigInt и сохраняет его как 64-битное беззнаковое целое число в 8 байтах начиная с указанного смещения этого `DataView`.

`DataView.prototype.setFloat32()` (en-US)

Принимает число и сохраняет его как 32-битное число с плавающей точкой в 4 байтах начиная с указанного смещения этого `DataView`.

`DataView.prototype.setFloat64()` (en-US)

Принимает число и сохраняет его как 64-битное число с плавающей точкой в 8 байтах начиная с указанного смещения этого `DataView`.

`DataView.prototype.setInt16()`

Принимает число и сохраняет его как 16-битное знаковое целое число в 2 байтах по указанному смещению этого `DataView`.

`DataView.prototype.setInt32()`

Принимает число и сохраняет его как 32-битное знаковое целое число в 4 байтах по указанному смещению этого `DataView`.

`DataView.prototype.setInt8()`

Принимает число и сохраняет его как 8-битное знаковое целое число в байте по указанному смещению этого `DataView`.

`DataView.prototype.setUint16()` (en-US)

Принимает число и сохраняет его как 16-битное беззнаковое целое число в 2 байтах по указанному смещению этого `DataView`.

`DataView.prototype.setUint32()` (en-US)

Принимает число и сохраняет его как 32-битное беззнаковое целое число в 4 байтах по указанному смещению этого `DataView`.

`DataView.prototype.setUint8()` (en-US)

Принимает число и сохраняет его как 8-битное беззнаковое целое число в байте по указанному смещению этого `DataView`.

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

### Использование DataView

```js
const buffer = new ArrayBuffer(16);
const view = new DataView(buffer, 0);

view.setInt16(1, 42);
view.getInt16(1); // 42
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview-objects |

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

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

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

* Полифил `DataView` в `core-js`
* `ArrayBuffer`
* `SharedArrayBuffer`


EvalError - JavaScript

EvalError
=========

Объект **`EvalError`** представляет ошибку, возникающую в глобальной функции `eval()`. JavaScript больше не генерирует это исключение, однако объект `EvalError` остается для совместимости.

`EvalError` является сериализуемым объектом (en-US), поэтому он может быть клонирован с помощью `structuredClone()` (en-US) или передан между воркерами с использованием `postMessage()`.

`EvalError` является подклассом `Error`.

Конструктор
-----------

`EvalError()` (en-US)

Создаёт новый объект `EvalError`.

Свойства экземпляра
-------------------

*Также наследует свойства своего родителя `Error`*.

Эти свойства определены в `EvalError.prototype` и есть у всех экземпляров `EvalError`.

`EvalError.prototype.constructor`

Функция-конструктор, создающая экземпляр объекта. Для экземпляров `EvalError` начальным значением является конструктор `EvalError` (en-US).

`EvalError.prototype.name`

Представляет название типа ошибки. Начальным значением `EvalError.prototype.name` является `"EvalError"`.

Методы экземпляра
-----------------

*Наследует методы своего родителя `Error`*.

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

### Создание `EvalError`

```js
try {
  throw new EvalError("Привет");
} catch (e) {
  console.log(e instanceof EvalError); // true
  console.log(e.message); // "Привет"
  console.log(e.name); // "EvalError"
  console.log(e.stack); // Стек ошибок
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-evalerror |

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

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

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

* `Error`
* `eval()`


Int32Array - JavaScript

Int32Array
==========

Объект **`Int32Array`** представляет типизированный массив 32-битных целых чисел со знаком с дополнением до двух с платформо-зависимым порядком байт. Если необходим контроль за порядком байт, то вместо этого объекта используйте `DataView`. Содержимое инициализируется значением `0`. Создав экземпляр **`Int32Array`**, можно получить доступ к элементам массива, используя методы объекта или стандартный синтаксис доступа к элементу массива по его индексу (с помощью скобочной нотации).

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

new Int32Array(); // добавлено в ES2017
new Int32Array(length);
new Int32Array(typedArray);
new Int32Array(object);
new Int32Array(buffer [, byteOffset [, length]]);
```

Для получения дополнительной информации о синтаксисе конструктора и параметрах *TypedArray*.

Свойства
--------

`Int32Array.BYTES_PER_ELEMENT`

Возвращает числовое значение размера элемента. `4` в случае с `Int32Array`.

Int32Array.length

Свойство статического размера, значение которого равно 3. Для актуального размера (количества элементов), смотрите `Int32Array.prototype.length` (en-US).

`Int32Array.name` (en-US)

Возвращает строковое значение названия конструктора. В случае с типом `Int32Array`: "Int32Array".

`Int32Array.prototype` (en-US)

Прототип для *TypedArray* объектов.

Методы
------

`Int32Array.from()` (en-US)

Создаёт новый `Int32Array` из массивоподобного или итеративного объекта. Смотрите также `Array.from()`.

`Int32Array.of()` (en-US)

Создаёт новый `Int32Array` with a variable number of arguments. See also `Array.of()`.

`Int32Array` прототип
---------------------

All `Int32Array` objects inherit from `%TypedArray%.prototype` (en-US).

### Свойства

`Int32Array.prototype.constructor`

Returns the function that created an instance's prototype. This is the `Int32Array` constructor by default.

`Int32Array.prototype.buffer` (en-US) Только для чтения

Returns the `ArrayBuffer` referenced by the `Int32Array` Fixed at construction time and thus **read only**.

`Int32Array.prototype.byteLength` (en-US) Только для чтения

Returns the length (in bytes) of the `Int32Array` from the start of its `ArrayBuffer`. Fixed at construction time and thus **read only.**

`Int32Array.prototype.byteOffset` (en-US) Только для чтения

Returns the offset (in bytes) of the `Int32Array` from the start of its `ArrayBuffer`. Fixed at construction time and thus **read only.**

`Int32Array.prototype.length` (en-US) Только для чтения

Returns the number of elements hold in the `Int32Array`. Fixed at construction time and thus **read only.**

### Методы

`Int32Array.prototype.copyWithin()` (en-US)

Copies a sequence of array elements within the array. See also `Array.prototype.copyWithin()`.

`Int32Array.prototype.entries()` (en-US)

Returns a new `Array Iterator` object that contains the key/value pairs for each index in the array. See also `Array.prototype.entries()`.

`Int32Array.prototype.every()` (en-US)

Tests whether all elements in the array pass the test provided by a function. See also `Array.prototype.every()`.

`Int32Array.prototype.fill()` (en-US)

Fills all the elements of an array from a start index to an end index with a static value. See also `Array.prototype.fill()`.

`Int32Array.prototype.filter()` (en-US)

Creates a new array with all of the elements of this array for which the provided filtering function returns true. See also `Array.prototype.filter()`.

`Int32Array.prototype.find()` (en-US)

Returns the found value in the array, if an element in the array satisfies the provided testing function or `undefined` if not found. See also `Array.prototype.find()`.

`Int32Array.prototype.findIndex()` (en-US)

Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found. See also `Array.prototype.findIndex()`.

`Int32Array.prototype.forEach()` (en-US)

Calls a function for each element in the array. See also `Array.prototype.forEach()`.

`Int32Array.prototype.includes()` (en-US)
Экспериментальная возможность

Determines whether a typed array includes a certain element, returning `true` or `false` as appropriate. See also `Array.prototype.includes()`.

`Int32Array.prototype.indexOf()` (en-US)

Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found. See also `Array.prototype.indexOf()`.

`Int32Array.prototype.join()`

Joins all elements of an array into a string. See also `Array.prototype.join()`.

`Int32Array.prototype.keys()` (en-US)

Returns a new `Array Iterator` that contains the keys for each index in the array. See also `Array.prototype.keys()`.

`Int32Array.prototype.lastIndexOf()` (en-US)

Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found. See also `Array.prototype.lastIndexOf()`.

`Int32Array.prototype.map()` (en-US)

Creates a new array with the results of calling a provided function on every element in this array. See also `Array.prototype.map()`.

`Int32Array.prototype.move()`
Non-standard
 Не реализовано

Former non-standard version of `Int32Array.prototype.copyWithin()` (en-US).

`Int32Array.prototype.reduce()` (en-US)

Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value. See also `Array.prototype.reduce()`.

`Int32Array.prototype.reduceRight()` (en-US)

Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value. See also `Array.prototype.reduceRight()`.

`Int32Array.prototype.reverse()` (en-US)

Reverses the order of the elements of an array — the first becomes the last, and the last becomes the first. See also `Array.prototype.reverse()`.

`Int32Array.prototype.set()`

Stores multiple values in the typed array, reading input values from a specified array.

`Int32Array.prototype.slice()` (en-US)

Extracts a section of an array and returns a new array. See also `Array.prototype.slice()`.

`Int32Array.prototype.some()` (en-US)

Returns true if at least one element in this array satisfies the provided testing function. See also `Array.prototype.some()`.

`Int32Array.prototype.sort()` (en-US)

Sorts the elements of an array in place and returns the array. See also `Array.prototype.sort()`.

`Int32Array.prototype.subarray()` (en-US)

Returns a new `Int32Array` from the given start and end element index.

`Int32Array.prototype.values()` (en-US)

Returns a new `Array Iterator` object that contains the values for each index in the array. See also `Array.prototype.values()`.

`Int32Array.prototype.toLocaleString()` (en-US)

Returns a localized string representing the array and its elements. See also `Array.prototype.toLocaleString()`.

`Int32Array.prototype.toString()` (en-US)

Returns a string representing the array and its elements. See also `Array.prototype.toString()`.

`Int32Array.prototype[@@iterator]()` (en-US)

Returns a new `Array Iterator` object that contains the values for each index in the array.

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

Разные способы создания `Int32Array`:

```js
// С указанием размера
var int32 = new Int32Array(2);
int32[0] = 42;
console.log(int32[0]); // 42
console.log(int32.length); // 2
console.log(int32.BYTES\_PER\_ELEMENT); // 4

// Из массива (Array)
var arr = new Int32Array([21, 31]);
console.log(arr[1]); // 31

// Из другого типизированного массива (TypedArray)
var x = new Int32Array([21, 31]);
var y = new Int32Array(x);
console.log(y[0]); // 21

// Из ArrayBuffer
var buffer = new ArrayBuffer(16);
var z = new Int32Array(buffer, 0, 4);

// Из итерируемого объекта (iterable)
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var int32 = new Int32Array(iterable);
// Int32Array[1, 2, 3]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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

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

Compatibility notes
-------------------

Начиная с ECMAScript 2015, конструкторы `Int32Array` требуют оператор `new`. Вызов `Int32Array` конструктора как функцию без оператора `new`, вызовет ошибку `TypeError`.

```js
var dv = Int32Array([1, 2, 3]);
// TypeError: calling a builtin Int32Array constructor
// without new is forbidden
```

```js
var dv = new Int32Array([1, 2, 3]);
```

See also
--------

* JavaScript typed arrays
* `ArrayBuffer`
* `DataView`


Object - JavaScript

Object
======

Тип **`Object`** представляет один из типов данных JavaScript. Он используется для хранения различных коллекций с ключами и более сложных сущностей. Объекты могут быть созданы с использованием конструктора `Object()` (en-US) или синтаксиса инициализатора / литерала объекта.

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

Почти все объекты в JavaScript являются экземплярами `Object`; типичный объект наследует свойства (включая методы) от `Object.prototype`, хотя эти свойства могут быть затенены (т.е. переопределены). Единственные объекты, которые не наследуют от `Object.prototype`, - это те, у которых прототип `null`, или которые происходят от других объектов с прототипом `null`.

Изменения в объекте `Object.prototype` видны всем объектам с помощью цепочки прототипов, если свойства и методы, подверженные этим изменениям, не переопределены дальше по цепочке прототипов. Это предоставляет очень мощный, хотя и потенциально опасный механизм для переопределения или расширения поведения объектов. Для обеспечения большей безопасности, `Object.prototype` - единственный объект в основном языке JavaScript, у которого неизменяемый прототип - прототип `Object.prototype` всегда `null` и не может быть изменен.

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

```js
// Инициализатор объекта или литерал
{ [ nameValuePair1[, nameValuePair2[, ...nameValuePairN] ] ] }

// Вызов в качестве конструктора
new Object([value])
```

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

`nameValuePair1, nameValuePair2, ... nameValuePairN`

Пары из имён (строки) и значений (любые значения), где имя отделяется от значения двоеточием.

`value`

Любое значение.

Свойства конструктора `Object`
------------------------------

`Object.length`

Имеет значение 1.

`Object.prototype` (en-US)

Позволяет добавлять свойства ко всем объектам типа `Object`.

Методы конструктора `Object`
----------------------------

`Object.assign()`

Создаёт новый объект путём копирования значений всех собственных перечислимых свойств из одного или более исходных объектов в целевой объект.

`Object.create()`

Создаёт новый объект с указанными объектом прототипа и свойствами.

`Object.defineProperty()`

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

`Object.defineProperties()`

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

`Object.freeze()`

Замораживает объект: другой код не сможет удалить или изменить никакое свойство.

`Object.getOwnPropertyDescriptor()`

Возвращает дескриптор свойства для именованного свойства объекта.

`Object.getOwnPropertyNames()`

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

`Object.getOwnPropertySymbols()`

Возвращает массив всех символьных свойств, найденных непосредственно в переданном объекте.

`Object.getPrototypeOf()`

Возвращает прототип указанного объекта.

`Object.is()`

Определяет, являются ли два значения различимыми (то есть, одинаковыми)

`Object.isExtensible()`

Определяет, разрешено ли расширение объекта.

`Object.isFrozen()`

Определяет, был ли объект заморожен.

`Object.isSealed()`

Определяет, является ли объект запечатанным (sealed).

`Object.keys()`

Возвращает массив, содержащий имена всех **собственных** перечислимых свойств переданного объекта.

`Object.observe()`

Асинхронно наблюдает за изменениями в объекте.

`Object.preventExtensions()`

Предотвращает любое расширение объекта.

`Object.seal()`

Предотвращает удаление свойств объекта другим кодом.

`Object.setPrototypeOf()`

Устанавливает прототип (т.е. внутреннее свойство `[[Prototype]]`)

Экземпляры и прототип объекта `Object`
--------------------------------------

Все объекты в JavaScript являются потомками `Object`; все объекты наследуют методы и свойства из прототипа объекта `Object.prototype` (en-US), хотя они и могут быть переопределены. Например, прототипы других конструкторов переопределяют свойство `constructor` и предоставляют свои собственные методы `toString()`. Изменения в объекте прототипа `Object` распространяются на все объекты до тех пор, пока свойства и методы, учитывающие эти изменения, не переопределяются дальше по цепочке прототипов.

### Свойства

`Object()` (en-US)

Превращает входные данные в объект.

`Object.prototype.constructor`

Указывает функцию, которая создает прототип объекта.

`Object.prototype.__proto__`
Устарело

Указывает на объект, который использовался в качестве прототипа при создании экземпляра объекта.

### Методы

`Object.prototype.__defineGetter__()`

Связывает функцию со свойством, которое при обращении к нему выполняет эту функцию и возвращает ее возвращаемое значение.

`Object.prototype.__defineSetter__()`

Связывает функцию со свойством, которое при установке выполняет ту функцию, которая изменяет свойство.

`Object.prototype.__lookupGetter__()`

Возвращает функцию, привязанную в качестве средства получения к указанному свойству.

`Object.prototype.__lookupSetter__()`

Возвращает функцию, привязанную в качестве установщика к указанному свойству.

`Object.prototype.hasOwnProperty()`

Возвращает логическое значение, указывающее, содержит ли объект указанное свойство как прямое свойство этого объекта, а не унаследованное через цепочку прототипов.

`Object.prototype.isPrototypeOf()`

Возвращает логическое значение, указывающее, содержит ли объект указанное свойство как прямое свойство этого объекта, а не унаследованное через цепочку прототипов.

`Object.prototype.propertyIsEnumerable()`

Возвращает логическое значение, указывающее, является ли указанное свойство свойством объекта enumerable own.

`Object.prototype.toLocaleString()`

Вызывает `toString()`.

`Object.prototype.toString()`

Возвращает строковое представление объекта.

`Object.prototype.valueOf()`

Возвращает примитивное значение указанного объекта.

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

### Пример: использование `Object` с типами `undefined` и `null`

Следующие примеры сохраняют пустой объект `Object` в переменную `o`:

```js
const o = new Object();
const o = new Object(undefined);
const o = new Object(null);
```

### Пример: использование `Object` для создания объектов `Boolean`

Следующий пример сохраняет объекты `Boolean` в переменную `o`:

```js
// эквивалентно o = new Boolean(true);
const o = new Object(true);
```

```js
// эквивалентно o = new Boolean(false);
const o = new Object(Boolean());
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object-objects |

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

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

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

* Инициализатор объекта


Function - JavaScript

Function
========

На самом деле каждая JavaScript-функция является объектом `Function`. Это легко проверить, выполнив проверку `(function(){}).constructor === Function`, которая вернёт true.

Конструктор
-----------

`Function()`

Создаёт новый объект `Function`. Вызов конструктора напрямую позволяет создавать функции программным путём. Такой способ представляет угрозу для безопасности, а также несёт разные (хотя не такие значительные) проблемы с производительностью при использовании с `Global_Objects/eval`. Однако в отличие от eval, конструктор `Function` создаёт функции, выполняемые только в глобальной области видимости.

Свойства экземпляра
-------------------

`Function.prototype.arguments`

 Массив с переданными функции аргументами.
 Это устаревшее свойство объекта `Function`. Вместо него используйте объект `arguments` (доступный внутри функции).

`Function.prototype.caller`

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

`Function.prototype.displayName`

Отображаемое имя функции.

`Function.prototype.length`

Содержит количество аргументов в функции.

`Function.prototype.name`

Имя функции.

Методы экземпляра
-----------------

`Function.prototype.apply(thisArg [, argsArray])`

Вызывает функцию и устанавливает её `this` на переданный `thisArg`. Аргументы могут быть переданы в виде объекта `Array`.

`Function.prototype.bind(thisArg[, arg1[, arg2[, ...argN]]])`

Создает новую функцию, при вызове которой её `this` будет установлен на `thisArg`. Можно также указать ряд аргументов, которые будут добавлены к аргументам при вызове новой привязанной функции.

`Function.prototype.call(thisArg[, arg1, arg2, ...argN])`

Вызывает функцию и устанавливает её `this` на переданное значение. Аргументы могут быть переданы как есть.

`Function.prototype.toString()`

 Возвращает строку с исходным кодом функции.
 Переопределяет метод `Object.prototype.toString`.

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

### Сравнение конструктора Function и объявления функции

Функции, созданные через конструктор `Function`, не имеют доступа к собственному контексту исполнения, т.е. они всегда создаются в глобальной области видимости. При выполнении таких функций, они смогут обращаться только к своим локальным и глобальным переменным, но не к переменным в той области видимости, в которой вызывался конструктор `Function`. В этом они отличаются от использования `Global_Objects/eval` с функциями-выражениями.

```js
var x = 10;

function createFunction1() {
  var x = 20;
  return new Function("return x;"); // здесь |x| ссылается на глобальный |x|
}

function createFunction2() {
  var x = 20;
  function f() {
    return x; // здесь |x| ссылается на локальный |x| выше
  }
  return f;
}

var f1 = createFunction1();
console.log(f1()); // 10
var f2 = createFunction2();
console.log(f2()); // 20
```

Хотя этот код работает в браузерах, в окружении Node.js вызов `f1()` приведёт к ошибке `ReferenceError`, потому что `x` не будет найден. Это происходит из-за того, что область видимости верхнего уровня в Node не является глобальной областью видимости, поэтому `x` ссылается на локальную переменную в пределах текущего модуля.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-objects |

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

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

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

* Функции и их область видимости
* Инструкция `function`
* Выражение `function`
* Инструкция `function*`
* Выражение `function*`
* `AsyncFunction`
* `GeneratorFunction`


parseFloat() - JavaScript

parseFloat()
============

Функция **`parseFloat()`** принимает строку в качестве аргумента и возвращает десятичное число (число с плавающей точкой)

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

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

parseFloat(строка)
```

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

`строка`

Текстовая строка, из которой вам надо выделить десятичное число.

### Возвращаемое значение

Число с плавающей точкой, полученное из строки. Если первый символ не может быть сконвертирован в число, то возвращается `NaN`.

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

`parseFloat` - это высокоуровневая функция, не привязанная ни к одному объекту.

`parseFloat` разбирает текстовую строку, ищет и возвращает из неё десятичное число. Если функция встретит знак, отличный от (+ или -), цифр(0-9), разделительной точки, или показателя степени, она вернёт значение, предшествующее этому знаку, игнорируя все последующие символы . Допускаются позади и впереди идущие пробелы.

Если первый символ нельзя привести к числовому виду, `parseFloat` вернёт `NaN`.

С точки зрения математики, значение `NaN` не является числом в какой-либо системе счисления. Чтобы определить, вернёт ли `parseFloat` значение `NaN` в качестве результата, можно вызвать функцию `isNaN`. Если `NaN` участвует в арифметических операциях, результатом также будет `NaN`.

`parseFloat` также может вернуть значение `Infinity` ("бесконечность"). Вы можете использовать функцию `isFinite`, чтобы определить, является ли результат конечным числом (not `Infinity`, `-Infinity`, или `NaN`).

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

### `parseFloat` возвращает число

Все примеры ниже вернут **3.14**
```

parseFloat(3.14);
parseFloat('3.14');
parseFloat('314e-2');
parseFloat('0.0314E+2');
parseFloat('3.14какие-нибудь не цифровые знаки');

var foo = Object.create(null);
foo.toString = function () { return "3.14"; };
parseFloat(foo);

var foo = Object.create(null);
foo.valueOf = function () { return "3.14"; };
parseFloat(foo);
```

### `parseFloat` возвращает NaN

Пример ниже вернёт `NaN`

```js
parseFloat("FF2");
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-parsefloat-string |

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

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

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

* `parseInt()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `Number.toFixed()`
* `isNaN()`


escape() - JavaScript

escape()
========

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Устаревший метод **`escape()`** возвращает новую строку, в которой определённые символы заменены шестнадцатеричной управляющей последовательностью. Используйте методы `encodeURI` или `encodeURIComponent` вместо него.

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

escape(str)
```

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

`str`

Строка для кодирования.

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

Функция `escape()` является свойством *глобального объекта*, т.е. относится к глобальным функциям. Эта функция кодирует специальные символы, за исключением: `@*_+-./`

The hexadecimal form for characters, whose code unit value is 0xFF or less, is a two-digit escape sequence: %xx. For characters with a greater code unit, the four-digit format %**u**xxxx is used.

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

```js
escape("abc123"); // "abc123"
escape("текст"); // "%u0442%u0435%u043A%u0441%u0442"
escape("ć"); // "%u0107"

/\* специальные символы \*/
escape("@\*\_+-./"); // "@\*\_+-./"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-escape-string |

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

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

See also
--------

* `encodeURI`
* `encodeURIComponent`


RegExp - JavaScript

RegExp
======

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

Конструктор **`RegExp`** создаёт объект регулярного выражения для сопоставления текста с шаблоном.

Введение в то, что представляют собой регулярные выражения, читайте в главе «Регулярные выражения» в руководстве по JavaScript.

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

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

Возможны как литеральная запись, так и запись через конструктор:
```

/pattern/flags
new RegExp(pattern, flags)
```

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

`pattern`

Текст регулярного выражения.

`flags`

Если определён, может принимать любую комбинацию нижеследующих значений:

`g`

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

`i`

игнорирование регистра при сопоставлении

`m`

сопоставление по нескольким строкам; символы начала и конца (^ и $) начинают работать по нескольким строкам (то есть, происходит сопоставление с началом или концом *каждой* строки (строки разделяются символами \n или \r), а не только с началом или концом всей вводимой строки)

`y`
Экспериментальная возможность

«липкий» поиск; сопоставление в целевой строке начинается с индекса, на который указывает свойство `lastIndex` этого регулярного выражения (и не пытается сопоставиться с любого более позднего индекса).

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

Существует два способа создания объекта `RegExp`: литеральная запись и использование конструктора. При записи строк параметры в литеральной записи не используют символы кавычек, в то время как параметры функции-конструктора используют кавычки. Так что следующие выражения создают одинаковые регулярные выражения:

```js
/ab+c/i;
new RegExp("ab+c", "i");
```

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

Конструктор объекта регулярного выражения, например, `new RegExp('ab+c')`, обеспечивает компиляцию регулярного выражения во время выполнения. Используйте функцию-конструктор, если вы знаете, что шаблон регулярного выражения будет меняться или если вы не знаете шаблон и получаете его из внешних источников, например, из пользовательского ввода.

При использовании функции-конструктора необходимо использовать обычные правила экранирования в строках (предварять специальные символы символом обратного слеша «\»). Например, следующие выражения эквивалентны:

```js
var re = /\w+/;
var re = new RegExp("\\w+");
```

Значение специальных символов в регулярных выражениях
-----------------------------------------------------

* Символьные классы
* Наборы символов
* Границы
* Группировка и обратные ссылки
* Квантификаторы

| Символьные классы |
| --- |
| Символ | Значение |
| `.` |
 (Точка, десятичная запятая) сопоставляется с любым символом
 *за исключением* символов новой строки: `\n`,
 `\r`, `\u2028` или `\u2029`.

 Обратите внимание, что флаг многострочности `m` не изменяет
 поведение точки. Так что для сопоставления с шаблона с несколькими
 строками используйте набор символов `[^]` (конечно, если
 только вам не нужно поддерживать старые версии IE), он сопоставляется
 с любым символом, включая символы новой строки.

 Например, шаблон `/.н/` сопоставляется с подстрокой «ан»,
 но не подстрокой «ну», во фразе «ну что, потанцуем».
  |
| `\d` |
 Сопоставляется с символом цифры в базовом латинском алфавите.
 Эквивалентен набору символов `[0-9]`.

 Например, шаблоны `/\d/` и
 `/[0-9]/` сопоставляются с подстрокой «2» в строке «B2 —
 это номер люкс».
  |
| `\D` |
 Сопоставляется с любым символом, который не является цифрой в базовом
 латинском алфавите. Эквивалентен набору символов `[^0-9]`.

 Например, шаблоны `/\D/` и
 `/[^0-9]/` сопоставляются с подстрокой «B» в строке «B2 —
 это номер люкс».
  |
| `\w` |
 Сопоставляется с любым алфавитно-цифровым символом из базового
 латинского алфавита, включая символ подчёркивания. Эквивалентен набору
 символов `[A-Za-z0-9_]`.

 Например, шаблон `/\w/` сопоставляется с подстрокой «a» в
 строке «apple», с подстрокой «5» в строке «$5.28» и с подстрокой «3» в
 строке «3D».
  |
| `\W` |
 Сопоставляется с любым символом из базового латинского алфавита, не
 являющимся символом, из которых состоят слова. Эквивалентен набору
 символов `[^A-Za-z0-9_]`.

 Например, шаблоны `/\W/` и
 `/[^A-Za-z0-9_]/` сопоставляются с подстрокой «%» в строке
 «50%».
  |
| `\s` |
 Сопоставляется с одиночным пробельным символом, который включает в
 себя пробел, табуляцию, подачу страницы, перевод строки и другие
 пробельные символы Юникода. Эквивалентен набору символов
 `[
\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]`.

 Например, шаблон `/\s\w*/` сопоставляется с подстрокой «
 bar» в строке «foo bar».
  |
| `\S` |
 Сопоставляется с одиночным символом, не являющимся пробельным.
 Эквивалентен набору символов
 `[^
\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]`.

 Например, шаблон `/\S\w*/` сопоставляется с подстрокой
 «foo» в строке «foo bar».
  |
| `\t` | Сопоставляется с символом табуляции. |
| `\r` | Сопоставляется с символом возврата каретки. |
| `\n` | Сопоставляется с символом перевода строки. |
| `\v` | Сопоставляется с символом вертикальной табуляции. |
| `\f` | Сопоставляется с символом подачи страницы. |
| `[\b]` |
 Сопоставляется с символом забоя (не перепутайте его с символьным классом
 `\b`).
  |
| `\0` | Сопоставляется с нулевым символом. Не ставьте за ним другую цифру. |
| `\c*X*` |
 Где `*X*` является буквой от «A» до «Z».
 Сопоставляется с управляющим символом в строке.

 Например, шаблон `/\cM/` сопоставляется с символом
 control-M в строке.
  |
| `\x*hh*` |
 Сопоставляется с символом с кодом `*hh*` (две
 шестнадцатеричные цифры).
  |
| `\u*hhhh*` |
 Сопоставляется с символом со значением Юникода
 `*hhhh*` (четыре шестнадцатеричные цифры).
  |
| `\` |
 Для символов, которые обычно трактуются буквально, указывает, что
 следующий символ является специальным и не должен интерпретироваться
 буквально.

 Например, шаблон `/b/` сопоставляется с символом «b».
 Поместив перед ним символ обратного слеша, то есть превратив шаблон в
 `/\b/`, символ приобретёт специальное значение,
 обозначающее сопоставление с границей слова.

*или*

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

 Например, звёздочка «\*» является специальным символом, обозначающим
 ноль или более вхождений предшествующего символа при сопоставлении;
 поэтому шаблон `/a*/` означает сопоставление с нулём или
 более символов «a». Для буквального сопоставления со звёздочкой
 `*` предварите её символом обратного слеша; например,
 шаблон `/a\*/` сопоставляется со строкой «a\*».
  |
| Наборы символов |
| --- |
| Символ | Значение |
| `[xyz]` |
 Набор символов. Сопоставляется с любым из заключённых в квадратные
 скобки символов. С помощью дефиса вы можете определить диапазон
 символов.

 Например, шаблон `[абвгд]` означает тоже самое, что и
 шаблон `[а-д]`. Они сопоставляются с символом «г» в слове
 «грудинка» и символом «б» в слове «отбивная».
  |
| `[^xyz]` |
 Отрицательный или дополнительный набор символов. То есть он
 сопоставляется со всеми символами, что не заключены в квадратные
 скобки. С помощью дефиса вы можете определить диапазон символов.

 Например, шаблон `[^абвгд]` означает тоже самое, что и
 шаблон `[^а-д]`. Они сопоставляются с символом «е» в слове
 «бекон» и символом «о» в слове «отбивная».
  |
| Границы |
| --- |
| Символ | Значение |
| `^` |
 Сопоставляется c началом ввода. Если установлен флаг многострочности,
 также сопоставляется с позицией сразу за символом переноса строки.

 Например, шаблон `/^Б/` не сопоставляется с буквой «Б» в
 строке «буква Б», но сопоставляется с первой буквой «Б» в строке
 «Буква Б».
  |
| `$` |
 Сопоставляется c концом ввода. Если установлен флаг многострочности,
 также сопоставляется с позицией сразу перед символом переноса строки.

 Например, шаблон `/т$/` не сопоставляется с буквой «т» в
 слове «кормить», но сопоставляется с ней в слове «кормит».
  |
| `\b` |
 Сопоставляется с границей слова нулевой ширины, например с позицией
 между буквой и пробелом (не путайте его с набором символов
 `[\b]`).

 Например, шаблон `/\bпол/` сопоставляется с подстрокой
 «пол» в строке «в полдень»; шаблон `/но\b/` сопоставляется
 с подстрокой «но» в строке «возможно завтра».
  |
| `\B` |
 Сопоставляется с границей не-слов нулевой ширины, например с позицией
 между двумя буквами или двумя пробелами.

 Например, шаблон `/\Bдень/` сопоставляется с подстрокой
 «день» в строке «в полдень»; шаблон `/за\B/` сопоставляется
 с подстрокой «за» в строке «возможно завтра».
  |
| Группировка и обратные ссылки |
| --- |
| Символ | Значение |
| `(*x*)` |
 Сопоставляется с `*x*` и запоминает сопоставление.
 Называется «захватывающие скобки».

 Например, шаблон `/(foo)/` сопоставляется с подстрокой
 «foo» и запоминает её в строке «foo bar». Сопоставленную подстроку
 можно достать из элементов `[1], ..., [n]` результирующего
 массива или из предопределённых свойств
 `$1, ..., $9` объекта `RegExp`.

 Захват групп ведёт к проседанию производительности. Если вам не нужно
 повторно ссылаться на захваченную подстроку, лучше использовать скобки
 без захвата (смотрите ниже).
  |
| `\*n*` |
 Где `*n*` является целым положительным числом.
 Обратная ссылка на последнюю сопоставившуюся подстроку в
 *n*-ных по счёту круглых скобках в регулярном выражении
 (нумерация скобок идёт слева направо).

 Например, шаблон `/яблоко(,)\sапельсин\1/` сопоставится
 подстроке «яблоко, апельсин,» в строке «яблоко, апельсин, вишня,
 персик». Более подробный пример смотрите после этой таблицы.
  |
| `(?:*x*)` |
 Сопоставляется с `*x*`, но не запоминает сопоставление. Называется «незахватывающие скобки».
 Сопоставленную подстроку нельзя достать из элементов
 `[1], ..., [n]` результирующего массива или из
 предопределённых свойств `$1, ..., $9` объекта
 `RegExp`.
  |
| Квантификаторы |
| --- |
| Символ | Значение |
| `*x**` |
 Сопоставляется с предшествующим элементом *x* ноль или более
 раз.

 Например, шаблон `/ела*/` сопоставляется с подстрокой «ел»
 в строке «Призрак просвистел» и подстрокой «ела» в строке «Птица
 пропела», но ни с чем не сопоставится в строке «Козёл хмыкнул».
  |
| `*x*+` |
 Сопоставляется с предшествующим элементом *x* один или более
 раз. Эквивалентен квантификатору `{1,}`.

 Например, шаблон `/о+/` сопоставляется с символом «о» в
 строке «конфета» и со всеми символами «о» в строке «коооооонфета».
  |
| `*x**?``*x*+?` |
 Сопоставляется с предшествующим элементом *x* подобно
 квантификаторам `*` и `+`, описанным выше,
 однако ищет минимально возможное сопоставление.

 Например, шаблон `/".*?"/` сопоставляется с подстрокой
 «"foo"» в строке «"foo" "bar"» и не сопоставляется со строкой «"foo"
 "bar"», поскольку за звёздочкой `*` следует символ вопроса
 `?`.
  |
| `*x*?` |
 Сопоставляется с предшествующим элементом *x* ноль или один
 раз.

 Например, шаблон `/о?то?/` сопоставляется с подстрокой «от»
 в строке «кот» и подстрокой «то» в строке «ток».

 Если символ используется сразу после какого-то из квантификаторов
 `*`, `+`, `?`, или `{}`,
 то он делает этот квантификатор «нежадным» (сопоставление происходит
 минимально возможное количество раз), в противоположность «жадному»
 поведению квантификатора по умолчанию (сопоставление происходит
 максимально возможное количество раз).

 Также символ используется в квантификаторах предпросмотра
 `(?=)`, `(?!)` и `(?:)`, также
 описанных в этой таблице.
  |
| `*x*(?=*y*)` |
 Сопоставляется с `*x*`, только если за `*x*` следует `*y*`. Например, шаблон `/Джек(?=Шпрот)/` сопоставляется со
 строкой «Джек» только если за ней следует строка «Шпрот». Шаблон
 `/Джек(?=Шпрот|Мороз)/` сопоставляется со строкой «Джек»
 только если за ней следуют строки «Шпрот» или «Мороз». Однако, ни
 «Шпрот», ни «Мороз» не являются частью результата сопоставления.
  |
| `*x*(?!*y*)` |
 Сопоставляется с `*x*`, только если за `*x*` не следует
 `*y*`. Например, шаблон `/\d+(?!\.)/` сопоставляется с числом
 только если за ним не следует десятичная запятая.

 Выражение `/\d+(?!\.)/.exec('3.141')` сопоставится с «141»
 но не с «3.141».
  |
| `(?<=*y*)*x*` |
`Сопоставляется с
*x*`, только если `*x*` предшествует
 `*y*`

 Например, /`(?<=Пётр)Иванов/` сопоставится с "Иванов"
 только если ему будет предшествовать "Петр".`/(?<=Пётр|Владислав)Иванов/`
 сопоставится с "Иванов" только если ему будет предшествовать "Пётр"
 или "Владислав".В любом случае, ни "Пётр" ни "Владислав" не
 войдут в результат сопоставления.
  |
| `(?<!*y*)*x*` |

|  |
| --- |
|
`Сопоставляется с
*x*`, только если `*x*` не предшествует
 `*y*`

 Например, `/(?<!-)\d+/` сопоставится с цифрой,
 только если ей не предшествует минус.`/(?<!-)\d+/.exec('3')`
 вернёт "3".`/(?<!-)\d+/.exec('-3')` не
 сопоставится с цифрой, тк цифре перед цифрой 3 присутствует
 минус.
  |

 |
| `*x*|*y*` | Сопоставляется либо с `*x*`, либо с `*y*`.

 Например, шаблон `/зелёное|красное/` сопоставится с
 подстрокой «зелёное» в строке «зелёное яблоко» и подстрокой «красное»
 в строке «красное яблоко».
  |
| `*x*{*n*}` |
 Где `*n*` является целым положительным числом.
 Сопоставляется точно с `*n*` вхождениями
 предшествующего элемента *x*.

 Например, шаблон `/о{2}/` не сопоставится с символом «о» в
 слове «конфета», но сопоставится со всеми символами «о» в слове
 «коонфета» и с первыми двумя символами «о» в слове «кооонфета».
  |
| `*x*{*n*,}` |
 Где `*n*` является целым положительным числом.
 Сопоставляется по крайней мере с `*n*` вхождениями
 предшествующего элемента *x*.

 Например, шаблон `/о{2,}/` не сопоставится с символом «о» в
 слове «конфета», но сопоставится со всеми символами «о» в словах
 «коонфета» и даже в «кооооооонфета».
  |
| `*x*{*n*,*m*}` |
 Где `*n*` и `*m*` являются целыми
 положительными числами. Сопоставляется по крайней мере с
 `*n*` но не более, чем с
 `*m*` вхождениями предшествующего элемента
 *x*.

 Например, шаблон `/о{1,3}/` ни с чем не сопоставится в
 слове «кнфета», с символом «о» в слове «конфета», с двумя символами
 «о» в слове «коонфета» и с первыми тремя символами «о» в слове
 «кооооооонфета». Обратите внимание, что при сопоставлении со словом
 «кооооооонфета» сопоставимость только подстрока «ооо», хотя слово
 содержало гораздо больше символов «о».
  |

Свойства
--------

`RegExp.prototype` (en-US)

Позволяет добавлять свойства ко всем объектам регулярных выражений.

`RegExp.length`

Значение `RegExp.length` равно 2.

Методы
------

Глобальный объект `RegExp` не имеет собственных методов, однако, он наследует некоторые методы через цепочку прототипов.

Экземпляры регулярного выражения
--------------------------------

### Свойства

{{page('/ru/docs/Web/JavaScript/Reference/Global\_Objects/RegExp/prototype', 'Properties')}}### Методы

{{page('/ru/docs/Web/JavaScript/Reference/Global\_Objects/RegExp/prototype', 'Methods')}}Примеры
-------

### Пример: использование регулярных выражений для смены формата данных

Следующий скрипт использует метод `replace()` экземпляра строки `String` для сопоставления с именем в формате *имя фамилия* и выводит его в формате *фамилия, имя*. В тесте замены скрипт использует заменители `$1` и `$2`, которые заменяются на результаты соответствующих сопоставившихся подгрупп регулярного выражения.

```js
var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);

// пример с русскими буквами
var re = /([а-яё]+)\s([а-яё]+)/i;
var str = "Джон Смит";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);
```

Пример выведет «Smith, John» и «Смит, Джон»

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

Символы конца строки различаются на различных платформах (Unix, Windows и так далее). Разбиение строк из этого примера работает на всех платформах.

```js
var text = "Некоторый текст\nЕщё текст\r\nИ ещё\rЭто конец";
var lines = text.split(/\r\n|\r|\n/);
console.log(lines); // выведет [ 'Некоторый текст', 'Ещё текст', 'И ещё', 'Это конец' ]
```

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

### Пример: использование регулярных выражений на нескольких строках

```js
var s = "Please yes\nmake my day!";
s.match(/yes.\*day/);
// Вернёт null
s.match(/yes[^]\*day/);
// Вернёт 'yes\nmake my day'
```

### Пример: использование регулярных выражений с флагом «липучести»

Этот пример демонстрирует, как можно использовать флаг «липучести» регулярных выражений для сопоставления с отдельными строками многострочного ввода.

```js
var text = "Первая строка\nВторая строка";
var regex = /(\S+) строка\n?/y;

var match = regex.exec(text);
console.log(match[1]); // напечатает 'Первая'
console.log(regex.lastIndex); // напечатает '14'

var match2 = regex.exec(text);
console.log(match2[1]); // напечатает 'Вторая'
console.log(regex.lastIndex); // напечатает '27'

var match3 = regex.exec(text);
console.log(match3 === null); // напечатает 'true'
```

Во время выполнения можно проверить, поддерживается ли флаг «липучести», при помощи блока `try { … } catch { … }`. Для этого надо использовать либо выражение с `eval(…)`, либо конструктор `RegExp(строка-регулярки, строка-с-флагами)` (поскольку нотация `/регулярка/флаги` обрабатывается во время компиляции, исключение будет выброшено до того, как выполнение достигнет блока `catch`). Например:

```js
var supports_sticky;
try {
  RegExp("", "y");
  supports_sticky = true;
} catch (e) {
  supports_sticky = false;
}
console.log(supports_sticky); // напечатает 'true'
```

### Пример: регулярные выражения и символы Юникода

Как уже сказано выше, символьные классы `\w` и `\W` сопоставляются только с базовыми символами ASCII; то есть, с символами от «a» до «z», от «A» до «Z», от «0» до «9» и символом «\_». Для сопоставления с символами из других языков, например, с кириллическими или иврита, используйте форму `\uhhhh`, где «hhhh» — это значение символа Юникода, записанное в шестнадцатеричной форме. Этот пример демонстрирует, как можно выделить символы Юникода, составляющие слова.

```js
var text = "Образец text на русском языке";
var regex = /[\u0400-\u04FF]+/g;

var match = regex.exec(text);
console.log(match[0]); // напечатает 'Образец'
console.log(regex.lastIndex); // напечатает '7'

var match2 = regex.exec(text);
console.log(match2[0]); // напечатает 'на' [не 'text']
console.log(regex.lastIndex); // напечатает '15'

// и так далее
```

Вот на этом внешнем ресурсе можно составить полный диапазон блоков Юникода для различных письменностей: regexp-unicode-block.

### Пример: извлечение имени поддомена из URL

```js
var url = "http://xxx.domain.com";
console.log(/[^.]+/.exec(url)[0].substr(7)); // напечатает 'xxx'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp-regular-expression-objects |

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

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

### Примечания по Gecko

Начиная с Gecko 34, в случае захвата группы с квантификаторами, предотвращающими появление группы в результате сопоставления, сопоставившийся текст для захваченной группы теперь имеет значение `undefined` вместо пустой строки:

```js
// Firefox 33 или более ранние
"x".replace(/x(.)?/g, function (m, group) {
  console.log("'group:" + group + "'");
}); // 'group:'

// Firefox 34 или более новые
"x".replace(/x(.)?/g, function (m, group) {
  console.log("'group:" + group + "'");
}); // 'group:undefined'
```

Обратите внимание, что для поддержания обратной совместимости, свойства `RegExp.$N` по-прежнему возвращают пустую строку вместо значения `undefined` (bug 1053944).

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

* Глава про регулярные выражения в руководстве по JavaScript
* `String.prototype.match()`
* `String.prototype.replace()`


Symbol - JavaScript

Symbol
======

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

**Символ (анг. Symbol)** — это уникальный и неизменяемый тип данных, который может быть использован как идентификатор для свойств объектов. *Символьный объект (анг. symbol object)* — это объект-обёртка (англ. wrapper) для примитивного символьного типа.

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

Symbol([описание])
```

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

`описание` Необязательный

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

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

Чтобы создать новый символьный примитив, достаточно написать `Symbol()`, указав по желанию строку в качестве описания этого символа:

```js
var sym1 = Symbol();
var sym2 = Symbol("foo");
var sym3 = Symbol("foo");
```

Код выше создаёт три новых символа. Заметьте, что `Symbol("foo")` не выполняет приведение (англ. coercion) строки "foo" к символу. Это выражение создаёт каждый раз новый символ:

```js
Symbol("foo") === Symbol("foo"); // false
```

Код ниже с оператором `new` бросит исключение `TypeError`:

```js
var sym = new Symbol(); // TypeError
```

Это удерживает разработчиков от создания явного объекта-обёртки `Symbol` вместо нового символьного значения. Создание явных объектов-обёрток для примитивных типов доступно (например, `new Boolean`, `new String`, `new Number`).

Если вам действительно необходимо обернуть символ в объект, вы можете использовать функцию `Object()`:

```js
var sym = Symbol("foo");
typeof sym; // "symbol"
var symObj = Object(sym);
typeof symObj; // "object"
```

### Разделяемые символы в глобальном символьном реестре

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

### Поиск символьных свойств у объектов

Метод `Object.getOwnPropertySymbols()` возвращает массив символов и позволяет получить символьные свойства конкретного объекта. Следует заметить, что при инициализации объекты не получают символьных свойств, так что этот массив будет пуст, пока вы не зададите ему какое-либо символьное свойство.

Свойства
--------

`Symbol.length`

Содержит длину, всегда равную 0 (нулю).

`Symbol.prototype` (en-US)

Содержит прототип конструктора `Symbol`.

### Известные символы

В добавок к вашим собственным символам, JavaScript имеет несколько встроенных символов, представляющих внутренние механизмы языка, которые не были доступны разработчикам в версиях ECMAScript 5 и более ранних. Эти символы доступны посредством следующих свойств:

#### Итерационные символы

`Symbol.iterator`

Метод, возвращающий итератор по умолчанию для объекта. Используется конструкцией `for...of`.

#### Символы регулярных выражений

`Symbol.match`

Метод для сопоставления объекта со строкой, также используемый для определения возможности объекта выступать в качестве регулярного выражения. Используется функцией `String.prototype.match()`.

`Symbol.replace`

Метод, заменяющий совпавшие подстроки в строке. Используется функцией `String.prototype.replace()`.

`Symbol.search`

Метод, возвращающий индекс вхождения подстроки, соответствующей регулярному выражению. Используется функцией `String.prototype.search()`.

`Symbol.split`

Метод, разбивающий строку на части в местах, соответствующих регулярному выражению. Используется функцией `String.prototype.split()`.

#### Другие символы

`Symbol.hasInstance`

Метод, определяющий, распознает ли конструктор некоторый объект как свой экземпляр. Используется оператором `instanceof`.

`Symbol.isConcatSpreadable`

Булево значение, показывающее, должен ли объект быть сведён к плоскому представлению (англ. flatten) в виде массива его элементов функцией `Array.prototype.concat()`.

`Symbol.unscopables`

Массив строковых имён свойств. Позволяет скрыть свойства от инструкции with (прежде всего для обратной совместимости).

`Symbol.species`

Метод, определяющий конструктор для порождённых объектов.

`Symbol.toPrimitive`

Метод, преобразующий объект в примитив (примитивное значение).

`Symbol.toStringTag`

Строковое значение, используемое в качестве описания объекта по умолчанию. Используется функцией `Object.prototype.toString()`

Методы
------

`Symbol.for(key)`

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

`Symbol.keyFor(sym)`

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

`Прототип Symbol`
-----------------

Все символы наследуют от `Symbol.prototype` (en-US).

### Свойства

{{page('en-US/Web/JavaScript/Reference/Global\_Objects/Symbol/prototype','Properties')}}### Методы

{{page('en-US/Web/JavaScript/Reference/Global\_Objects/Symbol/prototype','Methods')}}Примеры
-------

### Использование оператора `typeof` с символами

Оператор `typeof` позволяет идентифицировать символ.

```js
typeof Symbol() === "symbol";
typeof Symbol("foo") === "symbol";
typeof Symbol.iterator === "symbol";
```

### Преобразование типов с символами

Следующее необходимо помнить при преобразовании типа символов.

* При попытке конвертировать символ в число, будет брошено исключение `TypeError` (напр., `+sym` или `sym | 0`).
* Результатом нестрогого сравнения, `Object(sym) == sym`, будет `true`.
* `Symbol("foo") + "bar"` бросает исключение `TypeError` (невозможно преобразовать символ в строку). Это удерживает разработчика от, к примеру, случайного создания строгого поля у объекта из символа.
* Более "безопасный" вызов `String(sym)` работает с символами как вызов `Symbol.prototype.toString()` (en-US). Заметьте, что в то же время `new String(sym)` бросит исключение.
### Символы и конструкция `for...in`

Символы не перечисляются при итерации `for...in`. В дополнение к этому, `Object.getOwnPropertyNames()` не вернёт символьные свойства объекта. Тем не менее, их можно получить с помощью `Object.getOwnPropertySymbols()`.

```js
var obj = {};

obj[Symbol("a")] = "a";
obj[Symbol.for("b")] = "b";
obj["c"] = "c";
obj.d = "d";

for (var i in obj) {
  console.log(i); // выведет "c" и "d"
}
```

### Символы и `JSON.stringify()`

JSON.stringify() игнорирует свойства с ключами `Symbol`:

```js
JSON.stringify({ [Symbol("foo")]: "foo" });
// '{}'
```

Подробности см. `JSON.stringify()`.

### Объекты-обёртки для Symbol в качестве имён свойств

Когда объект-обёртка символа используется в качестве имени свойства, этот объект сводится к символу, который он оборачивает:

```js
var sym = Symbol("foo");
var obj = { [sym]: 1 };
obj[sym]; // 1
obj[Object(sym)]; // снова 1
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol-objects |

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

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

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

* Глоссарий: Символьный тип данных (en-US)
* `typeof`
* Типы и структуры данных JavaScript
* "ES6 In Depth: Symbols" on hacks.mozilla.org


decodeURI() - JavaScript

decodeURI()
===========

Метод **`decodeURI()`** декодирует унифицированный идентификатор ресурса (URI), созданный при помощи метода `encodeURI` или другой подобной процедуры.

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

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

decodeURI(encodedURI)
```

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

`encodedURI`

Полный закодированный унифицированный идентификатор ресурса.

### Возвращаемое значение

Новая строка, представляющая собой незакодированную версию данного унифицированного идентификатора ресурса.

### Exceptions

Throws an `URIError` ("malformed URI sequence") exception when `encodedURI` contains invalid character sequences.

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

Заменяет каждую управляющую последовательность в закодированном URI соответствующим символом. Не декодирует последовательности, которые невозможно сформировать с помощью `encodeURI`. Символ "#" декодированию не подвергается.

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

### Декодирование кириллического URL

```js
decodeURI(
  "https://developer.mozilla.org/ru/docs/JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B",
);
// "https://developer.mozilla.org/ru/docs/JavaScript\_шеллы"
```

### Catching errors
```

try {
  var a = decodeURI('%E0%A4%A');
} catch(e) {
  console.error(e);
}

// URIError: malformed URI sequence
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-decodeuri-encodeduri |

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

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

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

* `decodeURIComponent`
* `encodeURI`
* `encodeURIComponent`


JSON.parse() - JavaScript

JSON.parse()
============

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

Метод **`JSON.parse()`** разбирает строку JSON, возможно с преобразованием получаемого в процессе разбора значения.

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

JSON.parse(text[, reviver])
```

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

`text`

Разбираемая строка JSON. Смотрите документацию по объекту `JSON` для описания синтаксиса JSON.

`reviver` Необязательный

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

### Возвращаемое значение

Возвращает объект `Object`, соответствующий переданной строке JSON `text`.

### Выбрасываемые исключения

Выбрасывает исключение `SyntaxError`, если разбираемая строка не является правильным JSON.

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

### Пример: использование метода `JSON.parse()`

```js
JSON.parse("{}"); // {}
JSON.parse("true"); // true
JSON.parse('"foo"'); // "foo"
JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
JSON.parse("null"); // null
```

### Пример: использование параметра `reviver`

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

В конечном итоге, функция `reviver` вызывается с пустой строкой и самым верхним значением, чтобы обеспечить преобразование самого верхнего значения. Убедитесь, что вы правильно обрабатываете этот случай — обычно для этого нужно просто вернуть само значение — или метод `JSON.parse()` вернёт `undefined`.

```js
JSON.parse('{"p": 5}', function (k, v) {
  if (k === "") {
    return v;
  } // самое верхнее значение - возвращаем его
  return v \* 2; // иначе возвращаем v \* 2.
}); // { p: 10 }

JSON.parse('{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}', function (k, v) {
  console.log(k); // пишем имя текущего свойства, последним именем будет ""
  return v; // возвращаем неизменённое значение свойства
});

// 1
// 2
// 4
// 6
// 5
// 3
// ""
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-json.parse |

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

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

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

* Использование родного объекта `JSON` (en-US)
* `JSON.stringify()`


JSON.stringify() - JavaScript

JSON.stringify()
================

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

Метод **`JSON.stringify()`** возвращает JavaScript-значение, преобразованное в JSON-строку. Возможна замена значений, если как `replacer` передана функция, или включение только определённых свойств, если как `replacer` указан массив.

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

JSON.stringify(value[, replacer[, space]])
```

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

`value`

Значение, преобразуемое в строку JSON.

`replacer` Необязательный

 Если является функцией, преобразует значения и свойства по ходу их преобразования в строку; если является массивом, определяет набор свойств, включаемых в объект в окончательной строке.
 Подробное описание функции `replacer` даётся в статье Использование родного объекта `JSON` (en-US) руководства по JavaScript.

`space` Необязательный

Делает результат красиво отформатированным (расставляя пробелы).

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

Метод `JSON.stringify()` преобразует значение в представляющую его нотацию JSON со следующими оговорками:

* Порядок преобразования в строку свойств объектов, не являющихся массивами, не гарантируется. Не полагайтесь на порядок свойств во время преобразования.
* Объекты `Boolean`, `Number` и `String` преобразуются в соответствующие примитивные значения, в соответствии с традиционным соглашением о семантике преобразований.
* Значение `undefined`, функция или символ, встреченные во время преобразования, будут либо опущены (если они найдены в объекте), либо превращены в `null` (если они найдены в массиве).
* Все свойства, имеющие ключ в виде символа, будут полностью проигнорированы, даже при использовании функции `replacer`.

```js
JSON.stringify({}); // '{}'
JSON.stringify(true); // 'true'
JSON.stringify("foo"); // '"foo"'
JSON.stringify([1, "false", false]); // '[1,"false",false]'
JSON.stringify({ x: 5 }); // '{"x":5}'

JSON.stringify({ x: 5, y: 6 });
// '{"x":5,"y":6}' or '{"y":6,"x":5}'
JSON.stringify([new Number(1), new String("false"), new Boolean(false)]);
// '[1,"false",false]'

// Символы:
JSON.stringify({ x: undefined, y: Object, z: Symbol("") });
// '{}'
JSON.stringify({ [Symbol("foo")]: "foo" });
// '{}'
JSON.stringify({ [Symbol.for("foo")]: "foo" }, [Symbol.for("foo")]);
// '{}'
JSON.stringify({ [Symbol.for("foo")]: "foo" }, function (k, v) {
  if (typeof k === "symbol") {
    return "символ";
  }
});
// '{}'
```

### Параметр `space`

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

```js
JSON.stringify({ a: 2 }, null, " ");
// '{
// "a": 2
// }'
```

Использование символа табуляции имитирует стандартное красивое форматирование:

```js
JSON.stringify({ uno: 1, dos: 2 }, null, "\t");
// вернёт строку:
// '{
// "uno": 1,
// "dos": 2
// }'
```

### Поведение метода `toJSON()`

Если преобразуемый в строку объект имеет свойство с именем `toJSON` и значением свойства, установленным в функцию, то этот метод `toJSON()` изменит стандартное поведение преобразования в JSON: вместо преобразования объекта будет использоваться значение, возвращаемое методом `toJSON()`. Например:

**Предупреждение:** Функции не являются допустимыми данными в JSON, так что они не будут работать. Кроме того, некоторые объекты, например, объект `Date`, станут строками после применения `JSON.parse()`.

```js
var obj = {
  foo: "foo",
  toJSON: function () {
    return "bar";
  },
};
JSON.stringify(obj); // '"bar"'
JSON.stringify({ x: obj }); // '{"x":"bar"}'
```

### Пример использования метода `JSON.stringify()` вместе с `localStorage`

В случае, если вы хотите сохранить объект таким образом, чтобы его можно было восстановить даже после закрытия браузера, имеет смысл воспользоваться следующим примером, демонстрирующим применение метода `JSON.stringify()`:

```js
// Создаём некоторый объект
var session = {
  screens: [],
  state: true,
};
session.screens.push({ name: "экранА", width: 450, height: 250 });
session.screens.push({ name: "экранБ", width: 650, height: 350 });
session.screens.push({ name: "экранВ", width: 750, height: 120 });
session.screens.push({ name: "экранГ", width: 250, height: 60 });
session.screens.push({ name: "экранД", width: 390, height: 120 });
session.screens.push({ name: "экранЕ", width: 1240, height: 650 });

// Преобразуем его в строку JSON с помощью метода JSON.stringify(),
// затем сохраняем его в localStorage под именем session
localStorage.setItem("session", JSON.stringify(session));

// Пример того, как можно преобразовать строку, полученную с помощью метода
// JSON.stringify() и сохранённую в localStorage обратно в объект
var restoredSession = JSON.parse(localStorage.getItem("session"));

// Переменная restoredSession содержит объект, который был сохранён
// в localStorage
console.log(restoredSession);
```

### Пример использования параметра `replacer`

```js
var foo = {
  foundation: "Mozilla",
  model: "box",
  week: 45,
  transport: "car",
  month: 7,
};

JSON.stringify(foo, function (key, value) {
  if (typeof value === "string") {
    return undefined; // удаляем все строковые свойства
  }
  return value;
}); // '{"week":45,"month":7}'

JSON.stringify(foo, ["week", "month"]);
// '{"week":45,"month":7}', сохранились только свойства week и month
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-json.stringify |

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

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

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

* Использование родного объекта `JSON` (en-US)
* `JSON.parse()`