DataView.prototype.setInt32() - JavaScript

DataView.prototype.setInt32()
=============================

Метод **`setInt32()`** экземпляров `DataView` принимает число и сохраняет его в форме 32-битного целого числа со знаком в 4 байтах начиная с определённого в этом `DataView` смещении. Ограничений по выравниванию нет, многобайтовые значения могут храниться с любым смещением в пределах границ.

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

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

```js
setInt32(byteOffset, value)
setInt32(byteOffset, value, littleEndian)
```

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

`byteOffset`

Смещение в байтах от начала `DataView`, в котором будут храниться данные.

`value`

Устанавливаемое значение. На данный момент значение кодируется в байтах.

`littleEndian` Необязательный

Указывает, в каком формате сохранять данные — с прямым или обратным порядком байтов (en-US) ("big-endian" или "little-endian"). Если `false` или `undefined`, значение записывается с прямым порядком байтов ("big-endian").

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

`undefined`.

### Исключения

`RangeError`

Возникает, если `byteOffset` выходит за пределы `DataView`.

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

### Использование setInt32()

```js
const buffer = new ArrayBuffer(10);
const dataview = new DataView(buffer);
dataview.setInt32(0, 3);
dataview.getInt32(1); // 768
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setint32 |

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

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

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

* Типизированные массивы в JavaScript
* `DataView`
* `ArrayBuffer`
* `Int32Array`


DataView.prototype.byteLength - JavaScript

DataView.prototype.byteLength
=============================

Свойство-геттер **`byteLength`** возвращает длину `DataView` в байтах.

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

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

Свойство `byteLength` доступно только для чтения. Его значение определяется при создании объекта `DataView` и не может быть изменено. Если при создании `DataView` не были переданы параметры `byteOffset` или `byteLength`, то свойство будет равно `byteLength` связанного `ArrayBuffer` или `SharedArrayBuffer`.

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

### Использование свойства byteLength

```js
const buffer = new ArrayBuffer(8);
const dataview = new DataView(buffer);
dataview.byteLength; // 8 (соответствует byteLength буфера)

const dataview2 = new DataView(buffer, 1, 5);
dataview2.byteLength; // 5 (как указано при создании DataView)

const dataview3 = new DataView(buffer, 2);
dataview3.byteLength; // 6 (из-за byteOffset, заданного при создании DataView)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-dataview.prototype.bytelength |

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

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

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

* `DataView`
* `ArrayBuffer`
* `SharedArrayBuffer`


DataView.prototype.byteOffset - JavaScript

DataView.prototype.byteOffset
=============================

Свойство **`byteOffset`** экземпляров `DataView` возвращает смещение (в байтах) этого `DataView` относительно начала своего `ArrayBuffer` или `SharedArrayBuffer`.

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

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

`byteOffset` — это свойство, функция доступа которого равна `undefined`, то есть это свойство доступно только для чтения. Значение устанавливается при создании `DataView` и не может быть изменено.

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

### Использование свойства byteOffset

```js
const buffer = new ArrayBuffer(8);
const dataview = new DataView(buffer);
dataview.byteOffset; // 0 (смещение не установлено)

const dataview2 = new DataView(buffer, 3);
dataview2.byteOffset; // 3 (как установлено при создании DataView)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-dataview.prototype.byteoffset |

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

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

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

* `DataView`
* `ArrayBuffer`
* `SharedArrayBuffer`


DataView.prototype.setInt8() - JavaScript

DataView.prototype.setInt8()
============================

Метод **`setInt8()`** экземпляров `DataView` принимает число и сохраняет его в форме 8-битного целого числа со знаком в байте, определённом в смещении этого `DataView`.

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

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

```js
setInt8(byteOffset, value)
```

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

`byteOffset`

Смещение в байтах от начала `DataView`, в котором будут храниться данные.

`value`

Устанавливаемое значение. На данный момент значение кодируется в байтах.

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

`undefined`.

### Исключения

`RangeError`

Возникает, если `byteOffset` выходит за пределы `DataView`.

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

### Использование setInt8()

```js
const buffer = new ArrayBuffer(10);
const dataview = new DataView(buffer);
dataview.setInt8(0, 3);
dataview.getInt8(0); // 3
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setint8 |

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

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

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

* Типизированные массивы в JavaScript
* `DataView`
* `ArrayBuffer`
* `Int8Array`


DataView.prototype.buffer - JavaScript

DataView.prototype.buffer
=========================

Свойство **`buffer`** экземпляров `DataView` возвращает значение `ArrayBuffer` или `SharedArrayBuffer`, на которое ссылается `DataView` при создании.

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

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

`buffer` — это свойство, функция доступа которого равна `undefined`, то есть это свойство доступно только для чтения. Значение устанавливается при создании `DataView` и не может быть изменено.

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

### Использование свойства buffer

```js
const buffer = new ArrayBuffer(8);
const dataview = new DataView(buffer);
dataview.buffer; // ArrayBuffer { byteLength: 8 }
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-dataview.prototype.buffer |

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

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

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

* `DataView`
* `ArrayBuffer`
* `SharedArrayBuffer`


Symbol.search - JavaScript

Symbol.search
=============

Широко известный символ **`Symbol.search`** указывает метод, который вернёт индекс внутри строки, соответствующей регулярному выражению. Эта функция вызывается методом `String.prototype.search()`.

Для получения дополнительной информации см. `RegExp.prototype[@@search]()` и `String.prototype.search()`.

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

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.search |

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

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

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

* `Symbol.match`
* `Symbol.replace`
* `Symbol.split`
* `RegExp.prototype[@@search]()`


Symbol.for() - JavaScript

Symbol.for()
============

Метод **`Symbol.for(key)`** ищет ранее созданный разделяемый символ по заданному ключу и возвращает его, если он найден. В противном случае создаётся новый разделяемый символ для данного ключа в глобальном реестре символов.

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

Symbol.for(key);
```

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

key

Строка, обязательный. Идентификатор символа (также используется в качестве описания символа).

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

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

### Глобальный реестр

Глобальный реестр символов — это список со следующей структурой записей и пустой при инициализации:

| Поле | Значение |
| --- | --- |
| [[key]] | Строка, используемая в качестве идентификатора. |
| [[symbol]] | Символ, хранящийся глобально. |

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

```js
Symbol.for("foo"); // создаёт новый глобальный символ
Symbol.for("foo"); // возвращает символ, созданный прежде

// Одинаковый глобальный символ, но не локальный
Symbol.for("bar") === Symbol.for("bar"); // true
Symbol("bar") === Symbol("bar"); // false

// Идентификатор также используется в качестве описания
var sym = Symbol.for("mario");
sym.toString(); // "Symbol(mario)"
```

Чтобы предотвратить конфликт имён ваших глобальных символов и глобальных символов из других библиотек, может оказаться неплохой идеей использование префиксов:

```js
Symbol.for("mdn.foo");
Symbol.for("mdn.bar");
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.for |

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

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

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

* `Symbol.prototype.keyFor()`


Symbol.toStringTag - JavaScript

Symbol.toStringTag
==================

Известный символ **`Symbol.toStringTag`** - это строковое значение свойства, которое используется при создании строки описания объекта по умолчанию. Доступ к нему осуществляется через `Object.prototype.toString()` метод.Интерактивный пример
--------------------

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

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

Многие Javascript типы имеют теги по умолчанию:

```js
Object.prototype.toString.call("foo"); // "[object String]"
Object.prototype.toString.call([1, 2]); // "[object Array]"
Object.prototype.toString.call(3); // "[object Number]"
Object.prototype.toString.call(true); // "[object Boolean]"
Object.prototype.toString.call(undefined); // "[object Undefined]"
Object.prototype.toString.call(null); // "[object Null]"
// ... and more
```

Другие имеют встроенный символ `toStringTag`:

```js
Object.prototype.toString.call(new Map()); // "[object Map]"
Object.prototype.toString.call(function\* () {}); // "[object GeneratorFunction]"
Object.prototype.toString.call(Promise.resolve()); // "[object Promise]"
// ... and more
```

При создании собственного класса JavaScript по умолчанию использует тег "Object":

```js
class ValidatorClass {}

Object.prototype.toString.call(new ValidatorClass()); // "[object Object]"
```

С помощью `toStringTag` можно установить свой собственный тег:

```js
class ValidatorClass {
  get [Symbol.toStringTag]() {
    return "Validator";
  }
}

Object.prototype.toString.call(new ValidatorClass()); // "[object Validator]"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.tostringtag |

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

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

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

* `Object.prototype.toString()`


Symbol.split - JavaScript

Symbol.split
============

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

Для подробной информации, смотрите `RegExp.prototype[@@split]()` и `String.prototype.split()`.

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

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

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.split |

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

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

See also
--------

* `Symbol.match`
* `Symbol.replace`
* `Symbol.search`
* `RegExp.prototype[@@split]()`


Symbol.isConcatSpreadable - JavaScript

Symbol.isConcatSpreadable
=========================

**`Symbol.isConcatSpreadable`** - это известный символ, который используется для определения, должен ли объект редуцироваться к сумме своих элементов при использовании метода `Array.prototype.concat()`.

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

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

`@@isConcatSpreadable-символ` (`Symbol.isConcatSpreadable`) можно определить как собственное или унаследованное свойство с булевым значением. Оно контролирует поведение массивов и массивоподобных объектов:

* Для массивов поведением по умолчанию будет редуцирование к сумме своих элементов. `Symbol.isConcatSpreadable` поможет избежать редукции в подобных случаях.
* Для массивоподобных объектов поведением по умолчанию будет `сохранение своей структуры.isConcatSpreadable` может вызвать редуцирование в подобных случаях.
Примеры
-------

### Массивы

По умолчанию, `Array.prototype.concat()` возвращает массив, объединяющий элементы исходных массивов:

```js
var alpha = ["a", "b", "c"],
  numeric = [1, 2, 3];

var alphaNumeric = alpha.concat(numeric);

console.log(alphaNumeric); // Result: ['a', 'b', 'c', 1, 2, 3]
```

Если значение `Symbol.isConcatSpreadable` = `false`, то можно отменить поведение по умолчанию:

```js
var alpha = ["a", "b", "c"],
  numeric = [1, 2, 3];

numeric[Symbol.isConcatSpreadable] = false;
var alphaNumeric = alpha.concat(numeric);

console.log(alphaNumeric); // Result: ['a', 'b', 'c', [1, 2, 3] ]
```

### Массивоподобные объекты

Для массивоподобных объектов поведением по умолчанию будет сохранение своей структуры. Чтобы вызвать его разложение до суммы элементов в итоговом массиве, нужно задать значение `true` для `Symbol.isConcatSpreadable`:

```js
var x = [1, 2, 3];

var fakeArray = {
  [Symbol.isConcatSpreadable]: true,
  length: 2,
  0: "hello",
  1: "world",
};

x.concat(fakeArray); // [1, 2, 3, "hello", "world"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.isconcatspreadable |

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

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

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

* `Array.prototype.concat()`


Symbol.hasInstance - JavaScript

Symbol.hasInstance
==================

**`Symbol.hasInstance`** — известный символ, который используется для определения является ли объект экземпляром конструктора. Этот символ используется для изменения поведения оператора `instanceof`.

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

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

Поведение `instanceof` может быть изменено, например, следующим образом:

```js
class MyArray {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}
console.log([] instanceof MyArray); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.hasinstance |

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

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

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

* `instanceof`


Symbol.prototype[@@toPrimitive] - JavaScript

Symbol.prototype[@@toPrimitive]
===============================

Метод **`[@@toPrimitive]()`** преобразует объект Symbol в примитивное значение.

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

Symbol()[Symbol.toPrimitive](hint)
```

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

Примитивное значение указанного объекта Symbol `Symbol`.

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

Метод `[@@toPrimitive]()` возвращает примитивное значение объекта Symbol как тип данных Symbol. Аргумент `hint` не используется.

JavaScript вызывает метод `[@@toPrimitive]()` для преобразования объекта в примитив. JavaScript автоматически вызывает метод, когда на месте объекта ожидается примитивное значение.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype-@@toprimitive |

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

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

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

* `Symbol.toPrimitive`


Symbol.keyFor() - JavaScript

Symbol.keyFor()
===============

Метод **`Symbol.keyFor(sym)`** получает ключ для заданного символа из глобального реестра символов.Интерактивный пример
--------------------

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

Symbol.keyFor(sym);
```

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

sym

Символ, обязательный. Символ, ключ которого требуется найти

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

Строка с ключом заданного символа, если он есть в глобальном реестре символов, либо `undefined`, если его там нет.

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

```js
var globalSym = Symbol.for("foo"); // Создаёт новый глобальный символ
Symbol.keyFor(globalSym); // "foo"

var localSym = Symbol();
Symbol.keyFor(localSym); // undefined

// Известные символы не является символами,
// которые находятся в глобальном реестре символов
Symbol.keyFor(Symbol.iterator); // undefined
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.keyfor |

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

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

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

* `Symbol.for()`


Symbol.species - JavaScript

Symbol.species
==============

**`Symbol.species`** **—** известный символ, позволяющий определить конструктор, использующийся для создания порождённых объектов.

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

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

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

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

Вам может понадобиться возвращать объекты типа `Array` в методах вашего производного класса `MyArray`. Например, при использовании метода вроде `map()`, использующего конструктор по умолчанию, вам может потребоваться возвращать объект родительского типа `Array`, вместо `MyArray`. Символ **`species`** позволит вам это сделать:

```js
class MyArray extends Array {
  // Перегружаем species для использования родительского конструктора Array
  static get [Symbol.species]() {
    return Array;
  }
}
var a = new MyArray(1, 2, 3);
var mapped = a.map((x) => x \* x);

console.log(mapped instanceof MyArray); // false
console.log(mapped instanceof Array); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.species |

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

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

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

* `Map[@@species]` (en-US)
* `Set[@@species]` (en-US)


Symbol.iterator - JavaScript

Symbol.iterator
===============

**`Symbol.iterator`** — известный символ, задающий итератор объекта, используемый по умолчанию. Применяется в конструкции `for...of`.

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

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

Каждый раз, когда объект должен быть проитерирован (как, например, в начале цикла `for..of`), метод `@@iterator` вызывается без аргументов, а возвращённый итератор используется непосредственно для получения значений.

Некоторые встроенные типы имеют стандартное итерационное поведение, в то время как другие типы (как `Object`) таким свойством не обладают. Метод `@@iterator` имеют следующие встроенные типы:

* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()` (en-US)
* `String.prototype[@@iterator]()`
* `Map.prototype[@@iterator]()` (en-US)
* `Set.prototype[@@iterator]()` (en-US)

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

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

### Пользовательские итерируемые объекты

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

```js
var myIterable = {};
myIterable[Symbol.iterator] = function\* () {
  yield 1;
  yield 2;
  yield 3;
};
[...myIterable]; // [1, 2, 3]
```

### Плохо оформленные итераторы

Если метод `@@iterator` объекта не возвращает итератор, то это плохо оформленный итерируемый объект, его использование, скорее всего, приведёт к возникновению исключений или неправильному поведению:

```js
var nonWellFormedIterable = {}
nonWellFormedIterable[Symbol.iterator] = () => 1
[...nonWellFormedIterable] // TypeError: [] is not a function
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.iterator |

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

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

See also
--------

* Протоколы перебора
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()` (en-US)
* `String.prototype[@@iterator]()`
* `Map.prototype[@@iterator]()` (en-US)
* `Set.prototype[@@iterator]()` (en-US)


Symbol.replace - JavaScript

Symbol.replace
==============

**`Symbol.replace`** — известный символ, задающий метод для замены подстрок в строке. Эта функция вызывается методом `String.prototype.replace()`.

Смотрите также `RegExp.prototype[@@replace]()` (en-US) и `String.prototype.replace()` для получения дополнительных сведений.

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

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.replace |

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

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

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

* `Symbol.match`
* `Symbol.search`
* `Symbol.split`
* `RegExp.prototype[@@replace]()` (en-US)


Symbol.prototype.valueOf() - JavaScript

Symbol.prototype.valueOf()
==========================

Метод **`valueOf()`** возвращает примитивное значение символьного объекта.

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

Symbol().valueOf();
```

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

Метод `valueOf` объекта `Symbol` возвращает примитивное значение символьного объекта как экземпляр типа Symbol.

JavaScript вызывает метод `valueOf` для конвертации объекта в примитивное значение. Вам нечасто потребуется вызывать метод `valueOf` самостоятельно; JavaScript автоматически вызывает его, когда натыкается на объект там, где ожидался примитив.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype.valueof |

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

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

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

* `Object.prototype.valueOf()`


Symbol.match - JavaScript

Symbol.match
============

**`Symbol.match`** — известный символ, определяющий соответствие строки регулярному выражению. Этот метод вызывается функцией `String.prototype.match()`.

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

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

Данный метод также используется для того, чтобы определить, обладает ли объект поведением регулярного выражения. Например, методы `String.prototype.startsWith()`, `String.prototype.endsWith()` и `String.prototype.includes()` проверяют, является ли первый аргумент регулярным выражением, и бросают `TypeError`, если это так. Соответственно, если символ `match` установлен в `false` (или имеет ложное значение) — это говорит о том, что объект не предназначен для использования в качестве регулярного выражения.

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

### Блокировка проверки i`sRegExp`

Следующий код выбросит `TypeError`:

```js
"/bar/".startsWith(/bar/); // Бросает TypeError, так как /bar/ является
// регулярным выражением и Symbol.match не изменён.
```

Несмотря на это, если вы зададите свойству `Symbol.match` значение `false`, проверка `isRegExp` (которая использует свойство `match`) покажет, что объект не является регулярным выражением — как следствие, методы `startsWith` и `endsWith` не станут бросать `TypeError`.

```js
var re = /foo/;
re[Symbol.match] = false;
"/foo/".startsWith(re); // true
"/baz/".endsWith(re); // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.match |

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

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

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

* `Symbol.replace`
* `Symbol.search`
* `Symbol.split`


Symbol.unscopables - JavaScript

Symbol.unscopables
==================

Широко известный символ **`Symbol.unscopables`** используется для указания значения объекта, чьи собственные и наследуемые имена свойств исключаются из привязок связанного объекта оператора `with`.

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

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

`Символ @@unscopables` (`Symbol.unscopables`) может быть определён к любому объекту, чтобы исключить имена свойств из-за того, что они отображаются как лексические переменные с привязкой окружения `with`. Обратите внимание: если использовать "Строгий режим", оператор `with` будет недоступен и вероятнее всего также не понадобится этот символ.

Если вы зададите свойству значение `true` в объекте `unscopables` сделает его "*unscopable*" и, следовательно, оно не будет задействовано в области лексических переменных. Придав свойству значение `false`, Вы сделаете его `scopable` и, как следствие, оно будет задействовано в области лексических переменных.

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

Приведённый код отлично работает в ES5 и ниже. Однако в ECMAScript 2015 и более поздних версиях был введён метод `Array.prototype.keys()`. Это означает, что внутри окружения `with`, "ключи" будут методом, а не переменной. Вот где теперь встроенные свойства символа `Array.prototype[@@unscopables]` вступают в игру и препятствуют тому, чтобы некоторые из методов Array были включены в оператор `with`.

```js
var keys = [];

with (Array.prototype) {
  keys.push("что-то");
}

Object.keys(Array.prototype[Symbol.unscopables]);
// ["copyWithin", "entries", "fill", "find", "findIndex",
// "includes", "keys", "values"]
```

`Вы также можете задать unscopables` для собственных объектов.

```js
var obj = {
  foo: 1,
  bar: 2,
};

obj[Symbol.unscopables] = {
  foo: false,
  bar: true,
};

with (obj) {
  console.log(foo); // 1
  console.log(bar); // ReferenceError: bar is not defined
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.unscopables |

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

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

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

* `Array.prototype[@@unscopables]`
* оператор `with` (не доступен в режиме Strict)


Symbol.toPrimitive - JavaScript

Symbol.toPrimitive
==================

**`Symbol.toPrimitive`** является символом (symbol), который описывает свойство объекта как функцию, которая вызывается при преобразовании объекта в соответствующее примитивное значение.

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

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

С помощью свойства **`Symbol.toPrimitive`** (которое описывается как функция), объект может быть приведён к примитивному типу. Функция вызывается со строковым аргументом **`hint`**, который передаёт желаемый тип примитива. Значением аргумента **`hint`** может быть одно из следующих значений `"number"`, `"string"`, и `"default"`.

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

Описанные ниже примеры показывают как с помощью свойства **`Symbol.toPrimitive`** можно привести объект к примитивному типу.

```js
// Объект без свойства Symbol.toPrimitive
var obj1 = {};
console.log(+obj1); // NaN
console.log(`${obj1}`); // "[object Object]"
console.log(obj1 + ""); // "[object Object]"

// Объект со свойством Symbol.toPrimitive
var obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint == "number") {
      return 10;
    }
    if (hint == "string") {
      return "hello";
    }
    return true;
  },
};
console.log(+obj2); // 10 -- желаемый тип (hint) - "number"
console.log(`${obj2}`); // "hello" -- желаемый тип (hint) - "string"
console.log(obj2 + ""); // "true" -- желаемый тип (hint) - "default"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.toprimitive |

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

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

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

* `Date.prototype[@@toPrimitive]` (en-US)
* `Symbol.prototype[@@toPrimitive]`
* `Object.prototype.toString()`
* `Object.prototype.valueOf()`


WeakSet.prototype.has() - JavaScript

WeakSet.prototype.has()
=======================

Метод **`has()`** определяет, содержит ли WeakSet определённый элемент, возвращая в зависимости от этого true или false.

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

ws.has(value);
```

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

value

Обязателен. Искомый объект.

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

Boolean

Если объект был найден в WeakSet вернёт true, иначе false.

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

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

```js
var ws = new WeakSet();
var obj = {};
ws.add(window);

mySet.has(window); // вернёт true
mySet.has(obj); // вернёт false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset.prototype.has |

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

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

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

* `WeakSet`
* `WeakSet.prototype.add()`
* `WeakSet.prototype.delete()`


WeakSet.prototype.add() - JavaScript

WeakSet.prototype.add()
=======================

Метод **`add()`** добавляет новый объект в конец объекта WeakSet.

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

ws.add(value);
```

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

value

Обязателен. Объект, добавляемый в WeakSet.

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

### Использование метода add

```js
var ws = new WeakSet();

ws.add(window); // добавляет объект window в WeakSet

ws.has(window); // true

// Weakset принимает в качестве параметров только объекты
ws.add(1);
// результат в Chrome: "TypeError: Invalid value used in weak set"
// результат в Firefox: "TypeError: 1 is not a non-null object"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset.prototype.add |

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

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

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

* `WeakSet`
* `WeakSet.prototype.delete()`
* `WeakSet.prototype.has()`


WeakSet.prototype.delete() - JavaScript

WeakSet.prototype.delete()
==========================

Метод **`delete()`** удаляет указанный элемент из объекта `WeakSet`.

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

ws.delete(value);
```

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

value

Обязателен. Объект, удаляемый из WeakSet.

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

Если объект был успешно удалён, возвращается true, иначе false.

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

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

```js
var ws = new WeakSet();
var obj = {};

ws.add(window);

ws.delete(obj); // Вернёт false. Удаляемый объект не найден в WeakSet.
ws.delete(window); // Вернёт true. Объект успешно удалён.

ws.has(window); // Вернёт false. Объект window был удалён из WeakSet.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset.prototype.delete |

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

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

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

* `WeakSet`
* `WeakSet.prototype.clear()`


Set.prototype.has() - JavaScript

Set.prototype.has()
===================

Метод **`has()`** возвращает логическое значение, показывающее, существует ли элемент с указанным значением в объекте `Set` или нет.

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

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

mySet.has(value);
```

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

value

Обязательный. Значение, которое необходимо проверить на наличие в коллекции `Set`.

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

Boolean

Возвращает `true`, если в коллекции `Set` существует элемент с указанным значением; в противном случае `false`.

**Примечание:** С технической точки зрения, `has()` использует алгоритм `sameValueZero` для определения наличия указанного элемента.

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

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

```js
var mySet = new Set();
mySet.add("foo");

mySet.has("foo"); // возвращает true
mySet.has("bar"); // возвращает false

var set1 = new Set();
var obj1 = { key1: 1 };
set1.add(obj1);

set1.has(obj1); // возвращает true
set1.has({ key1: 1 }); // возвращает false, поскольку это разные ссылки на объекты
set1.add({ key1: 1 }); // сейчас set1 содержит 2 объекта
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.has |

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

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

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

* `Set`
* `Set.prototype.add()`
* `Set.prototype.delete()`


Set.prototype.values() - JavaScript

Set.prototype.values()
======================

Метод **`values()`** возвращает новый `Итератор`, который содержит значения для каждого элемента в объекте `Set` в порядке их добавления.

Метод **`keys()`** является синонимом этого метода (для схожести с объектами `Map` (en-US)). Он ведёт себя точно так же и возвращает **значения** элементов `Set`.

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

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

mySet.values();
```

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

Новый **`Итератор`**, содержащий значения для каждого элемента `Set`, в порядке их добавления.

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

### Использование `values()`

```js
var mySet = new Set();
mySet.add("foo");
mySet.add("bar");
mySet.add("baz");

var setIter = mySet.values();

console.log(setIter.next().value); // "foo"
console.log(setIter.next().value); // "bar"
console.log(setIter.next().value); // "baz"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.values |

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

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

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

* `Set.prototype.entries()`


Set.prototype.add() - JavaScript

Set.prototype.add()
===================

Метод **`add()`** добавляет новый элемент с заданным значением в конец объекта `Set`.

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

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

mySet.add(value);
```

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

value

Обязательное. Значение элемента, добавляемого в объект `Set`.

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

Объект `Set`.

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

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

```js
var mySet = new Set();

mySet.add(1);
mySet.add(5).add("some text"); // можно делать цепочки

console.log(mySet);
// Set [1, 5, "some text"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.add |

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

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

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

* `Set`
* `Set.prototype.delete()`
* `Set.prototype.has()`


Set() конструктор - JavaScript

Set() конструктор
=================

**Конструктор Set** позволяет создавать объекты Set, в которых хранятся уникальные значения любого типа, будь то примитивные значения или ссылки на объекты.

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

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

new Set([iterable])
```

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

`iterable` Необязательный

Если передаётся итеративный объект, все его элементы будут добавлены в новый Set.

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

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

Новый объект Set.

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

### Использование объекта Set

```js
let mySet = new Set();

mySet.add(1); // Set [ 1 ]
mySet.add(5); // Set [ 1, 5 ]
mySet.add(5); // Set [ 1, 5 ]
mySet.add("какой-то текст"); // Set [ 1, 5, 'какой-то текст' ]
let o = { a: 1, b: 2 };
mySet.add(o);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set-constructor |

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

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

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

* Set


Set.prototype.entries() - JavaScript

Set.prototype.entries()
=======================

Метод **`entries()`** возвращает новый **`Итератор`**, который содержит массив **`[значение, значение]`** для каждого элемента в объекте `Set` в порядке их добавления. Для объекта `Set` не существует ключа `key`, как в объекте `Map`. Тем не менее, чтобы API было схож с объектом `Map`, каждая *запись* содержит значение как в *ключе,* так и в *значении*, возвращая массив `[значение, значение]`.

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

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

mySet.entries()
```

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

Новый `Итератор`, который содержит массив `[значение, значение]` для каждого элемента, полученного в `Set` в порядке их добавления.

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

### Использование `entries()`

```js
var mySet = new Set();
mySet.add("foobar");
mySet.add(1);
mySet.add("baz");

var setIter = mySet.entries();

console.log(setIter.next().value); // ["foobar", "foobar"]
console.log(setIter.next().value); // [1, 1]
console.log(setIter.next().value); // ["baz", "baz"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.entries |

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

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

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

* `Set.prototype.keys()` (en-US)
* `Set.prototype.values()`


Set.prototype.clear() - JavaScript

Set.prototype.clear()
=====================

Метод **`clear()`** удаляет все элементы из объекта `Set`.

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

mySet.clear();
```

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

`undefined`.

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

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

```js
var mySet = new Set();
mySet.add(1);
mySet.add("foo");

mySet.size; // 2
mySet.has("foo"); // true

mySet.clear();

mySet.size; // 0
mySet.has("bar"); // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.clear |

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

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

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

* `Set`
* `Set.prototype.delete()`


Set.prototype.size - JavaScript

Set.prototype.size
==================

Метод доступа **`size`** возвращает количество (уникальных) элементов в объекте `Set`

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

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

Значение `size` является целым числом, которое показывает как много записей имеет объект `Set`. Функция для установки `size` равна `undefined`; вы не можете изменить это свойство.

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

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

```js
var mySet = new Set();
mySet.add(1);
mySet.add(5);
mySet.add("некоторый текст");

mySet.size; // 3
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-set.prototype.size |

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

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

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

* `Set`


Set.prototype.forEach() - JavaScript

Set.prototype.forEach()
=======================

Метод **`forEach()`** выполняет функцию по одному разу для каждого элемента из `Set` в порядке их расположения.

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

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

mySet.forEach(callback[, thisArg])
```

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

`callback`

Функция, которая будет выполнена для каждого элемента, принимает три параметра:

`currentValue`, `currentKey`

Текущий элемент из `Set`. Т.к. в `Set` нет ключей, в каждом будет лежать value.

`set`

Сам объект `Set` для которого был вызван `forEach()`.

`thisArg`

Значение, используемое как `this` в ходе выполнения `callback`.

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

`undefined`.

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

Метод `forEach()` выполняет `callback` по одному разу для каждого значения, которое находится в объекте `Set`. Функция не будет выполняться для значений, которые были удалены. Тем не менее функция выполнится с элементами, значение которых `undefined`.

`callback` вызывается с **тремя аргументами**:

* **значение элемента**
* **ключ элемента**
* **`Set` объект обхода**

В объектах типа `Set` нет ключей, поэтому оба первых аргумента принимают **значение** содержащееся в `Set`. Это делает метод `forEach()` для объекта Set совместимым с методами `forEach()` других объектов, таких как `Map` (en-US) и `Array`.

`Если аргумент thisArg` был передан в `forEach()`, то он будет передан в `callback` , во время исполнения, для использование его в качестве `this`. Иначе в `this` будет хранится значение `undefined`. Значение `this` используемое в `callback` определено согласно с обычными правилами определения `this` используемого функцией

Каждое значение используется только один раз, исключая те случаи, когда оно было удалено и передобавлено до того, как `forEach()` завершился. `callback` не будет выполнена для элементов, которые были удалены до их использования. Новые значения, которые были добавлены до того как `forEach()` завершился будут использованы.

`forEach()` выполняет `callback` однажды для каждого элемента из объекта `Set`; Он не возвращает никакого значения.

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

### Содержимое объекта `Set`

Приведённый код показывает состояние каждого элемента в объекте `Set`:

```js
function logSetElements(value1, value2, set) {
  console.log("s[" + value1 + "] = " + value2);
}

new Set(["foo", "bar", undefined]).forEach(logSetElements);

// logs:
// "s[foo] = foo"
// "s[bar] = bar"
// "s[undefined] = undefined"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.foreach |

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

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

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

* `Array.prototype.forEach()`
* `Map.prototype.forEach()` (en-US)


Set.prototype.delete() - JavaScript

Set.prototype.delete()
======================

Метод **`delete()`** удаляет уникальный элемент из объекта `Set`.Интерактивный пример
--------------------

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

mySet.delete(value);
```

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

value

Обязательный. Значение элемента для удаления из объекта `Set`.

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

`true`, если элемент был успешно удалён из объекта `Set`, иначе `false`.

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

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

```js
var mySet = new Set();
mySet.add("foo");

mySet.delete("bar"); // Вернёт false. Отсутствует элемент "bar" для удаления.
mySet.delete("foo"); // Вернёт true. Успешно удалён.

mySet.has("foo"); // Вернёт false. Элемент "foo" больше не присутствует.
```

Давайте проверим как удалить Object из Set.

```js
var setObj = new Set(); // Создаём новый Set.

setObj.add({ x: 10, y: 20 }); // Добавляем объект в набор.

setObj.add({ x: 20, y: 30 }); // Добавляем объект в набор.

// Удаляем любой point с `x > 10`.
setObj.forEach(function (point) {
  if (point.x > 10) {
    setObj.delete(point);
  }
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.delete |

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

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

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

* `Set`
* `Set.prototype.clear()`


Number.prototype.toFixed() - JavaScript

Number.prototype.toFixed()
==========================

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

Метод **`toFixed()`** форматирует число, используя запись с фиксированной запятой.

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

numObj.toFixed([digits])
```

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

`digits`

Необязательный параметр. Количество цифр после десятичной запятой; может быть значением между 0 и 20 включительно, хотя реализации могут поддерживать и больший диапазон значений. Если аргумент опущен, он считается равным 0.

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

Строка, представляющая `numObj`, не использующая экспоненциальную запись и содержащая ровно `digits` цифр после десятичной запятой. Число округляется при необходимости, а дробная часть дополняется нулями таким образом, чтобы иметь указанную длину. Если `numObj` больше или равно `1e+21`, этот метод просто вызывает метод `Number.prototype.toString()` и возвращает строку в экспоненциальной записи.

### Выбрасываемые исключения

`RangeError`

Если параметр `digits` слишком маленький или слишком большой. Значения между 0 и 20 включительно не будут порождать исключение `RangeError`. Также реализации могут поддерживать большие и меньшие значения.

`TypeError`

Если этот метод вызывается на объекте, не являющимся объектом `Number`.

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

### Пример: использование `toFixed`

```js
var numObj = 12345.6789;

numObj.toFixed(); // Вернёт '12346': обратите внимание на округление, дробной части нет
numObj.toFixed(1); // Вернёт '12345.7': обратите внимание на округление
numObj.toFixed(6); // Вернёт '12345.678900': обратите внимание на дополнение нулями
(1.23e20).toFixed(2); // Вернёт '123000000000000000000.00'
(1.23e-10).toFixed(2); // Вернёт '0.00'
(2.34).toFixed(1); // Вернёт '2.3'
-(2.34).toFixed(1); // Вернёт -2.3 (в соответствии с приоритетом операций,
// отрицательные числовые литералы не возвращают строку...)
(-2.34).toFixed(1); // Вернёт '-2.3' (...до тех пор, пока вы не заключите их в круглые скобки)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.tofixed |

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

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

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

* `Number.prototype.toExponential()`
* `Number.prototype.toPrecision()`
* `Number.prototype.toString()`


Number.NEGATIVE_INFINITY - JavaScript

Number.NEGATIVE\_INFINITY
=========================

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

Свойство **`Number.NEGATIVE_INFINITY`** представляет значение отрицательной бесконечности.

Вам не нужно создавать объект `Number` для доступа к этому статическому свойству (используйте `Number.NEGATIVE_INFINITY`).

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

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

Значение `Number.NEGATIVE_INFINITY` является тем же самым по модулю, только отрицательным значением, что содержит свойство `Infinity` глобального объекта.

Это значение ведёт себя несколько иначе, нежели математическая бесконечность:

* Любое положительное значение, включая `POSITIVE_INFINITY`, умноженное на `NEGATIVE_INFINITY` даёт `NEGATIVE_INFINITY`.
* Любое отрицательное значение, включая `NEGATIVE_INFINITY`, умноженное на `NEGATIVE_INFINITY` даёт `POSITIVE_INFINITY`.
* Ноль, умноженный на `NEGATIVE_INFINITY`, даёт `NaN`.
* `NaN`, умноженный на `NEGATIVE_INFINITY`, даёт `NaN`.
* `NEGATIVE_INFINITY`, делённое на любое отрицательное значение, исключая `NEGATIVE_INFINITY`, даёт `POSITIVE_INFINITY`.
* `NEGATIVE_INFINITY`, делённое на любое положительное значение, исключая `POSITIVE_INFINITY`, даёт `NEGATIVE_INFINITY`.
* `NEGATIVE_INFINITY`, делённое на `NEGATIVE_INFINITY` или `POSITIVE_INFINITY`, даёт `NaN`.
* Любое число, делённое на `NEGATIVE_INFINITY`, даёт ноль.

Вы можете использовать свойство `Number.NEGATIVE_INFINITY` для проверки на ошибки и возвращать конечное число в случае успеха. Однако, обратите внимание, что в этом случае более уместным было бы использование функции `isFinite`.

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

### Пример: использование `NEGATIVE_INFINITY`

В следующем примере переменной `smallNumber` присваивается значение, меньшее минимального. Когда выполняется инструкция `if`, переменная `smallNumber` имеет значение `-Infinity`, так что перед продолжением вычислений она устанавливается в более приемлемое значение.

```js
var smallNumber = -Number.MAX\_VALUE \* 2;

if (smallNumber == Number.NEGATIVE\_INFINITY) {
  smallNumber = returnFinite();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.negative\_infinity |

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

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

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

* `Number.POSITIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`


Number.prototype.toPrecision() - JavaScript

Number.prototype.toPrecision()
==============================

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

Метод **`toPrecision()`** возвращает строку, представляющую объект `Number` с указанной точностью.

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

numObj.toPrecision([precision])
```

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

`precision`

Необязательный параметр. Целое число, определяющее количество значащих цифр.

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

Строка, представляющая объект `Number` в записи с фиксированной запятой или в экспоненциальной записи, округлённое до `precision` значащих цифр. Смотрите обсуждение округления в описании метода `toFixed()`, которое таким же образом применяется и к методу `toPrecision()`.

Если аргумент `precision` опущен, поведение аналогично методу `Number.prototype.toString()`. Если он не является целым числом, он будет округлён к ближайшему целому числу.

### Выбрасываемые исключения

`RangeError`

Если параметр `precison` не находится в диапазоне от 1 до 100 (включительно), будет выброшено исключение `RangeError`. Также реализации могут поддерживать большие и меньшие значения. ECMA-262 требует точности только до 21 значащей цифры.

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

### Пример: использование `toPrecision`

```js
var numObj = 5.123456;

console.log(numObj.toPrecision()); // выведет '5.123456'
console.log(numObj.toPrecision(5)); // выведет '5.1235'
console.log(numObj.toPrecision(2)); // выведет '5.1'
console.log(numObj.toPrecision(1)); // выведет '5'

numObj = 0.000123;

console.log(numObj.toPrecision()); // выведет '0.000123'
console.log(numObj.toPrecision(5)); // выведет '0.00012300'
console.log(numObj.toPrecision(2)); // выведет '0.00012'
console.log(numObj.toPrecision(1)); // выведет '0.0001'

// Обратите внимание, что если заданного количества разрядов
// недостаточно для точного отображения целой части числа,
// значение может быть возвращено в экспоненциальной записи.
console.log((1234.5).toPrecision(2)); // выведет '1.2e+3'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.toprecision |

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

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

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

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()`
* `Number.prototype.toString()`


Number.prototype.toString() - JavaScript

Number.prototype.toString()
===========================

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

Метод **`toString()`** возвращает строковое представление указанного объекта `Number`.

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

numObj.toString([radix])
```

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

`radix`

Необязательный параметр. Целое число между 2 и 36, определяющее основание системы счисления, используемой для представления числового значения.

### Выбрасываемые исключения

`RangeError`

Если в метод `toString()` передано основание не в диапазоне от 2 до 36, будет выброшено исключение `RangeError`.

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

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

Метод `toString()` разбирает свой первый аргумент и пытается вернуть строковое представление в системе счисления с указанным основанием. Для оснований, больших 10, при обозначении цифр, больших 9, используются буквы латинского алфавита. Например, для шестнадцатеричных чисел (основание 16), используются буквы с `a` по `f`.

Если параметр `radix` не указан, предпочитаемое основание предполагается равным 10.

Если число `numObj` отрицательно, его знак сохраняется. Это правило действует даже если основание равно 2; возвращённая строка является двоичным представлением положительного числа `numObj`, перед которым ставится знак `-`, а **не** дополнительным кодом числа `numObj`.

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

### Пример: использование `toString`

```js
var count = 10;

console.log(count.toString()); // Выведет '10'
console.log((17).toString()); // Выведет '17'

var x = 6;

console.log(x.toString(2)); // Выведет '110'
console.log((254).toString(16)); // Выведет 'fe'

console.log((-10).toString(2)); // Выведет '-1010'
console.log((-0xff).toString(2)); // Выведет '-11111111'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.tostring |

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

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

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

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()`
* `Number.prototype.toPrecision()`


Number.isNaN() - JavaScript

Number.isNaN()
==============

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

Метод **`Number.isNaN()`** определяет, является ли переданное значение `NaN`. Это более надёжная версия оригинальной глобальной функции `isNaN()`.

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

Number.isNaN(value)
```

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

`value`

Значение, проверяемое на `NaN`.

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

Поскольку оба оператора проверки на равенство, `==` (en-US) и `===` (en-US), вычисляются в `false` при проверке, что `NaN` *и есть* `NaN`, появляется необходимость в функции `Number.isNaN()`. Эта ситуация отличается от всех других возможных сравнений в JavaScript.

В отличие от глобальной функции `isNaN()`, `Number.isNaN()` не имеет проблемы принудительного преобразования параметра в число. Это значит, что в него безопасно передавать значения, которые обычно превращаются в `NaN`, но на самом деле `NaN` не являются. Также это значит, что метод возвращает `true` только для числовых значений, имеющих значение `NaN`.

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

```js
Number.isNaN(NaN); // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0); // true

// При использовании глобальной функции isNaN() это всё будет true
Number.isNaN("NaN"); // false
Number.isNaN(undefined); // false
Number.isNaN({}); // false
Number.isNaN("blabla"); // false

// А это всё в любом случае будет false
Number.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);
Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");
```

Полифил
-------

```js
Number.isNaN =
  Number.isNaN ||
  function (value) {
    return typeof value === "number" && isNaN(value);
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isnan |

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

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

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

* `Number`
* `isNaN()`


Number.prototype.valueOf() - JavaScript

Number.prototype.valueOf()
==========================

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

Метод **`valueOf()`** возвращает примитивное значение объекта `Number`.

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

numObj.valueOf()
```

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

Нет.

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

Этот метод обычно вызывается внутренними механизмами движка JavaScript, а не явно в коде.

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

### Пример: использование `valueOf()`

```js
var numObj = new Number(10);
console.log(typeof numObj); // object

var num = numObj.valueOf();
console.log(num); // 10
console.log(typeof num); // number
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.valueof |

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

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

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

* `Number.prototype.toSource()` (en-US)


Number.parseInt() - JavaScript

Number.parseInt()
=================

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

Метод **`Number.parseInt()`** разбирает строковый аргумент и возвращает целое число. Этот метод ведёт себя идентично глобальной функции `parseInt()` и является частью ECMAScript 6 (его целью является модуляризация глобальных сущностей).

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

Number.parseInt(string[, radix])
```

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

`string`

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

`radix`

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

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

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

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

Этот метод имеет ту же функциональность, что и глобальная функция `parseInt()`:

```js
Number.parseInt === parseInt; // true
```

Пожалуйста, обратитесь к документации по глобальной функции `parseInt()` для просмотра подробного описания и примеров.

Полифил
-------

```js
if (Number.parseInt === undefined) {
  Number.parseInt = window.parseInt;
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parseint |

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

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

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

* Объект `Number`, которому принадлежит этот метод.
* Глобальная функция `parseInt()`.


Number.MIN_VALUE - JavaScript

Number.MIN\_VALUE
=================

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

Свойство **`Number.MIN_VALUE`** представляет минимальное положительное числовое значение, представимое в JavaScript.

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

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

Свойство `MIN_VALUE` является положительным ближайшим к нулю числом, которое может быть представлено в JavaScript.

`MIN_VALUE` имеет значение, приблизительно равное `5e-324`. Значения, меньшие `MIN_VALUE`, преобразуются в 0 (так называемое «исчезновение порядка» или «антипереполнение»).

Поскольку `MIN_VALUE` является статическим свойством объекта `Number`, вы всегда должны использовать его как `Number.MIN_VALUE`, а не как свойство созданного вами объекта `Number`.

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

### Пример: использование `MIN_VALUE`

В следующем примере кода производится деление одного значения на другое. Если результат больше или равен `MIN_VALUE`, вызывается функция `func1`; в противном случае вызывается функция `func2`.

```js
if (num1 / num2 >= Number.MIN\_VALUE) {
  func1();
} else {
  func2();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.min\_value |

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

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

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

* `Number.MAX_VALUE`


Number.isSafeInteger() - JavaScript

Number.isSafeInteger()
======================

Метод **`Number.isSafeInteger()`** определяет, является ли переданное значение *безопасным целым числом*.

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

Безопасное целое число это такое число, которое:

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

Например, число `253 - 1` является безопасным целым числом: оно может быть представлено точно и никакое другое целое число не округляется к нему ни в каком режиме округления IEEE-754. В противовес ему, число `253` *не является* безопасным целым числом: оно может быть точно представлено в IEEE-754, но целое число `253 + 1` не может быть напрямую представлено в IEEE-754 и округляется к числу `253` в режимах округления к ближайшему и к нулю. Безопасные целые числа состоят из всех целых чисел в диапазоне от `-(253 - 1)` до `253 - 1` включительно (± `9007199254740991` или ± 9,007,199,254,740,991).

Обработка значений, больших или меньших чем ~9 квадриллионов, с высокой точностью требует использования библиотеки, умеющей работать с длиной арифметикой. Ознакомьтесь с Что Каждому Программисту Необходимо Знать об Арифметике с Вещественными числами для получения дополнительной информации о представлении чисел, с плавающей запятой.

Для больших целочисленных значений, рассмотрите возможность использования типа `BigInt`.

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

Number.isSafeInteger(testValue)
```

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

`testValue`

Значение, проверяемое на целочисленную «безопасность».

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

`Boolean` значение, сообщающее о том, является ли переданное значение безопасным целочисленным числом или же нет.

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

```js
Number.isSafeInteger(3); // true
Number.isSafeInteger(Math.pow(2, 53)); // false
Number.isSafeInteger(Math.pow(2, 53) - 1); // true
Number.isSafeInteger(NaN); // false
Number.isSafeInteger(Infinity); // false
Number.isSafeInteger("3"); // false
Number.isSafeInteger(3.1); // false
Number.isSafeInteger(3.0); // true
```

Полифил
-------

```js
Number.isSafeInteger =
  Number.isSafeInteger ||
  function (value) {
    return (
      Number.isInteger(value) && Math.abs(value) <= Number.MAX\_SAFE\_INTEGER
    );
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.issafeinteger |

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

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

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

* Объект `Number`, которому принадлежит этот метод.
* `Number.MIN_SAFE_INTEGER`
* `Number.MAX_SAFE_INTEGER`
* `BigInt`


Number.NaN - JavaScript

Number.NaN
==========

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

Свойство **`Number.NaN`** представляет «не число». Эквивалентно глобальному объекту `NaN`.

Вам не нужно создавать объект `Number` для доступа к этому статическому свойству (используйте `Number.NaN`).

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

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.nan |

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

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

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

* Глобальный объект `NaN`.
* Объект `Number`, которому принадлежит это свойство.


Number.POSITIVE_INFINITY - JavaScript

Number.POSITIVE\_INFINITY
=========================

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

Свойство **`Number.POSITIVE_INFINITY`** представляет значение положительной бесконечности.

Вам не нужно создавать объект `Number` для доступа к этому статическому свойству (используйте `Number.POSITIVE_INFINITY`).

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

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

Значение `Number.POSITIVE_INFINITY` является тем же самым значением, что содержит свойство `Infinity` глобального объекта.

Это значение ведёт себя несколько иначе, нежели математическая бесконечность:

* Любое положительное значение, включая `POSITIVE_INFINITY`, умноженное на `POSITIVE_INFINITY` даёт `POSITIVE_INFINITY`.
* Любое отрицательное значение, включая `NEGATIVE_INFINITY`, умноженное на `POSITIVE_INFINITY` даёт `NEGATIVE_INFINITY`.
* Ноль, умноженный на `POSITIVE_INFINITY`, даёт `NaN`.
* `NaN`, умноженный на `POSITIVE_INFINITY`, даёт `NaN`.
* `POSITIVE_INFINITY`, делённое на любое отрицательное значение, исключая `NEGATIVE_INFINITY`, даёт `NEGATIVE_INFINITY`.
* `POSITIVE_INFINITY`, делённое на любое положительное значение, исключая `POSITIVE_INFINITY`, даёт `POSITIVE_INFINITY`.
* `POSITIVE_INFINITY`, делённое на `NEGATIVE_INFINITY` или `POSITIVE_INFINITY`, даёт `NaN`.
* Любое число, делённое на `POSITIVE_INFINITY`, даёт ноль.

Вы можете использовать свойство `Number.POSITIVE_INFINITY` для проверки на ошибки и возвращать конечное число в случае успеха. Однако, обратите внимание, что в этом случае более уместным было бы использование функции `isFinite`.

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

### Пример: использование `POSITIVE_INFINITY`

В следующем примере переменной `bigNumber` присваивается значение, большее максимального. Когда выполняется инструкция `if`, переменная `bigNumber` имеет значение `Infinity`, так что перед продолжением вычислений она устанавливается в более приемлемое значение.

```js
var bigNumber = Number.MAX\_VALUE \* 2;

if (bigNumber == Number.POSITIVE\_INFINITY) {
  bigNumber = returnFinite();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.positive\_infinity |

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

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

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

* `Number.NEGATIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`


Number.MAX_SAFE_INTEGER - JavaScript

Number.MAX\_SAFE\_INTEGER
=========================

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

Константа **`Number.MAX_SAFE_INTEGER`** представляет максимальное безопасное целочисленное значение в JavaScript (`253 - 1`).

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

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

Константа `MAX_SAFE_INTEGER` имеет значение `9007199254740991`. Смысл этого числа в том, что в JavaScript используется формат чисел с плавающей запятой двойной точности, как определено в стандарте IEEE 754, а он может безопасно представлять числа только в диапазоне от `-(253 - 1)` до `253 - 1`.

Поскольку `MAX_SAFE_INTEGER` является статическим свойством объекта `Number`, вы всегда должны использовать его как `Number.MAX_SAFE_INTEGER`, а не как свойство созданного вами объекта `Number`.

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

```js
Number.MAX\_SAFE\_INTEGER; // 9007199254740991
Math.pow(2, 53) - 1; // 9007199254740991
```

Полифил
-------

```js
if (!Number.MAX\_SAFE\_INTEGER) {
  Number.MAX\_SAFE\_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_safe\_integer |

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

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

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

* `Number.MIN_SAFE_INTEGER`
* `Number.isSafeInteger()`


Number.isInteger() - JavaScript

Number.isInteger()
==================

Метод **`Number.isInteger()`** определяет, является ли переданное значение целым числом.

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

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

Number.isInteger(value)
```

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

`value`

Значение, проверяемое на целочисленность.

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

`Boolean` сообщающий о том, является ли переданное значение целочисленным числом.

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

Если целевое значение является целым числом, возвращает `true`. Если значение `NaN` или `Infinity`, то возвращает `false`. Метод также возвращает `true`, если это вещественное число с точкой, которое может быть представлено в целочисленном виде.

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

```js
Number.isInteger(0); // true
Number.isInteger(1); // true
Number.isInteger(-100000); // true
Number.isInteger(99999999999999999999999); // true

Number.isInteger(0.1); // false
Number.isInteger(Math.PI); // false

Number.isInteger(NaN); // false
Number.isInteger(Infinity); // false
Number.isInteger(-Infinity); // false
Number.isInteger("10"); // false
Number.isInteger(true); // false
Number.isInteger(false); // false
Number.isInteger([1]); // false

Number.isInteger(5.0); // true
Number.isInteger(5.000000000000001); // false
Number.isInteger(5.0000000000000001); // true
```

Полифил
-------

```js
Number.isInteger =
  Number.isInteger ||
  function (value) {
    return (
      typeof value === "number" &&
      isFinite(value) &&
      Math.floor(value) === value
    );
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isinteger |

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

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

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

* Объект `Number`, которому принадлежит этот метод.


Number.parseFloat() - JavaScript

Number.parseFloat()
===================

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

Метод **`Number.parseFloat()`** разбирает строковый аргумент и возвращает число с плавающей запятой. Этот метод ведёт себя идентично глобальной функции `parseFloat()` и является частью ECMAScript 6 (его целью является модуляризация глобальных сущностей).

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

Number.parseFloat(string)
```

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

`string`

Строка, представляющая значение, которое вы хотите разобрать.

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

Пожалуйста, обратитесь к документации по глобальной функции `parseFloat()` для просмотра подробного описания и примеров.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parsefloat |

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

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

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

* Объект `Number`, которому принадлежит этот метод.
* Глобальная функция `parseFloat()`.


Number.MAX_VALUE - JavaScript

Number.MAX\_VALUE
=================

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

Свойство **`Number.MAX_VALUE`** представляет максимальное числовое значение, представимое в JavaScript.

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

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

Свойство `MAX_VALUE` имеет значение, приблизительно равное `1.79E+308`. Значения, большие `MAX_VALUE` представляются как «бесконечность».

Поскольку `MAX_VALUE` является статическим свойством объекта `Number`, вы всегда должны использовать его как `Number.MAX_VALUE`, а не как свойство созданного вами объекта `Number`.

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

### Пример: использование `MAX_VALUE`

В следующем примере кода производится умножение двух значений. Если результат меньше или равен `MAX_VALUE`, вызывается функция `func1`; в противном случае вызывается функция `func2`.

```js
if (num1 \* num2 <= Number.MAX\_VALUE) {
  func1();
} else {
  func2();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_value |

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

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

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

* `Number.MIN_VALUE`


Number.EPSILON - JavaScript

Number.EPSILON
==============

Свойство **`Number.EPSILON`** представляет собой разницу между единицей и наименьшим значением, большим единицы, которое может быть представлено типом `Number`.

Вам не нужно создавать объект типа `Number` для доступа к этому статическому свойству (используйте `Number.EPSILON`).

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

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

Свойство `EPSILON` имеет значение, приблизительно равное `2.2204460492503130808472633361816E-16` или `2-52`.

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

### Проверка на равенство
```

x = 0.2;
y = 0.3;
z = 0.1;
equal = (Math.abs(x - y + z) < Number.EPSILON);
```

Полифил
-------

```js
if (Number.EPSILON === undefined) {
  Number.EPSILON = Math.pow(2, -52);
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.epsilon |

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

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

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

* Объект `Number`, которому принадлежит это свойство.


Number.prototype.toExponential() - JavaScript

Number.prototype.toExponential()
================================

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

Метод **`toExponential()`** возвращает строку, представляющую объект `Number` в экспоненциальной записи.

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

numObj.toExponential([fractionDigits])
```

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

`fractionDigits`

Необязательный параметр. Целое число, определяющее количество цифр после десятичной запятой. По умолчанию используется столько цифр, сколько необходимо для указания числа.

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

Строка, представляющая объект `Number` в экспоненциальной записи с одной цифрой перед десятичной запятой, округлённое до `fractionDigits` цифр после десятичной запятой. Если аргумент `fractionDigits` опущен, количество цифр после десятичной запятой по умолчанию устанавливается в количество цифр, необходимых для однозначного представления значения.

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

Если число имеет больше цифр, чем запрошено параметром `fractionDigits`, оно будет округлено к ближайшему числу, представляемому `fractionDigits` цифрами. Смотрите обсуждение округления в описании метода `toFixed()`, которое так же применяется и к методу `toExponential()`.

### Выбрасываемые исключения

`RangeError`

Если параметр `fractionDigits` слишком маленький или слишком большой. Значения между 0 и 20 включительно не будут порождать исключение `RangeError`. Также реализации могут поддерживать большие и меньшие значения.

`TypeError`

Если этот метод вызывается на объекте, не являющимся объектом `Number`.

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

### Пример: использование `toExponential`

```js
var numObj = 77.1234;

console.log(numObj.toExponential()); // выведет 7.71234e+1
console.log(numObj.toExponential(4)); // выведет 7.7123e+1
console.log(numObj.toExponential(2)); // выведет 7.71e+1
console.log((77.1234).toExponential()); // выведет 7.71234e+1
console.log((77).toExponential()); // выведет 7.7e+1
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.toexponential |

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

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

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

* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`
* `Number.prototype.toString()`


Number.isFinite() - JavaScript

Number.isFinite()
=================

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

Метод **`Number.isFinite()`** определяет, является ли переданное значение конечным числом.

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

Number.isFinite(testValue)
```

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

`testValue`

Значение, проверяемое на конечность.

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

В отличии от глобальной функции `isFinite()`, этот метод принудительно не преобразует параметр в число. Это означает, что он возвращает `true` только для конечных значений числового типа.

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

```js
Number.isFinite(Infinity); // false
Number.isFinite(NaN); // false
Number.isFinite(-Infinity); // false

Number.isFinite(0); // true
Number.isFinite(2e64); // true

Number.isFinite("0"); // false, при использовании глобальной
// функции isFinite('0') было бы true
```

Полифил
-------

```js
Number.isFinite =
  Number.isFinite ||
  function (value) {
    return typeof value === "number" && isFinite(value);
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isfinite |

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

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

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

* Объект `Number`, которому принадлежит этот метод.


Number.prototype.toLocaleString() - JavaScript

Number.prototype.toLocaleString()
=================================

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

Метод **`toLocaleString()`** возвращает строку с языкозависимым представлением числа.

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

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

numObj.toLocaleString([locales[, options]])
```

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

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

**Примечание:** API интернационализации ECMAScript, реализованное в Firefox 29, добавляет аргумент `locales` к методу `Number.toLocaleString()`. Если этот аргумент равен `undefined`, этот метод возвращает локализованные цифры на языке, определяемом ОС, в то время, как предыдущие версии Firefox возвращали цифры на английском языке. Это изменение было помечено, как регрессия, затрагивающая обратную совместимость, которая скоро может быть исправлена. (Firefox bug 999003)

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

### Пример: использование `toLocaleString`

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

```js
var number = 3500;

console.log(number.toLocaleString()); // Отобразит '3,500' в локали U.S. English
```

### Пример: проверка поддержки аргументов `locales` и `options`

Аргументы `locales` и `options` поддерживаются ещё не всеми браузерами. Для проверки того, поддерживает ли их уже реализация, можно затребовать несуществующую метку языка и проверить, будет ли выброшено исключение `RangeError`:

```js
function toLocaleStringSupportsLocales() {
  var number = 0;
  try {
    number.toLocaleString("i");
  } catch (e) {
    return e.name === "RangeError";
  }
  return false;
}
```

### Пример: использование аргумента `locales`

Этот пример показывает некоторые локализованные числовые форматы. Для получения формата языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент `locales`:

```js
var number = 123456.789;

// В Германии в качестве разделителя целой и дробной части используется запятая, а в качестве разделителя разрядов - точка
console.log(number.toLocaleString("de-DE"));
// → 123.456,789

// В России в качестве разделителя целой и дробной части используется запятая, а в качестве разделителя разрядов - пробел
console.log(number.toLocaleString("ru-RU"));
// → 123 456,789

// В большинстве арабоговорящих стран используют настоящие арабские цифры
console.log(number.toLocaleString("ar-EG"));
// → ١٢٣٤٥٦٫٧٨٩

// В Индии используют разделители для тысяч/лакх/крор
console.log(number.toLocaleString("en-IN"));
// → 1,23,456.789

// Ключ расширения nu запрашивает систему нумерации, например, китайскую десятичную
console.log(number.toLocaleString("zh-Hans-CN-u-nu-hanidec"));
// → 一二三,四五六.七八九

// Если запрашиваемый язык может не поддерживаться, например
// балийский, откатываемся на запасной язык, в данном случае индонезийский
console.log(number.toLocaleString(["ban", "id"]));
// → 123.456,789
```

### Пример: использование аргумента `options`

Результат, предоставляемый методом `toLocaleString()`, может быть настроен с помощью аргумента `options`:

```js
var number = 123456.789;

// Запрашиваем формат валюты
console.log(
  number.toLocaleString("de-DE", { style: "currency", currency: "EUR" }),
);
// → 123.456,79 €

console.log(
  number.toLocaleString("ru-RU", { style: "currency", currency: "RUB" }),
);
// → 123 456,79 ₽

// Японская йена не использует младшие единицы
console.log(
  number.toLocaleString("ja-JP", { style: "currency", currency: "JPY" }),
);
// → ￥123,457

// Ограничиваем до трёх значащих цифр
console.log(number.toLocaleString("en-IN", { maximumSignificantDigits: 3 }));
// → 1,23,000
```

Производительность
------------------

При форматировании большого количества чисел лучшим вариантом будет создание объекта `NumberFormat` и использование функции, предоставляемой его свойством `NumberFormat.format`.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.tolocalestring |
| ECMAScript Internationalization API Specification # sup-number.prototype.tolocalestring |

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

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

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

* `Number.prototype.toString()`


Number.MIN_SAFE_INTEGER - JavaScript

Number.MIN\_SAFE\_INTEGER
=========================

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

Константа **`Number.MIN_SAFE_INTEGER`** представляет минимальное безопасное целочисленное значение в JavaScript (`-(253 - 1)`).

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

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

Константа `MIN_SAFE_INTEGER` имеет значение `-9007199254740991`. Смысл этого числа в том, что в JavaScript используется формат чисел с плавающей запятой двойной точности, как определено в стандарте IEEE 754, а он может безопасно представлять числа только в диапазоне от `-(253 - 1)` до `253 - 1`.

Поскольку `MIN_SAFE_INTEGER` является статическим свойством объекта `Number`, вы всегда должны использовать его как `Number.MIN_SAFE_INTEGER`, а не как свойство созданного вами объекта `Number`.

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

```js
Number.MIN\_SAFE\_INTEGER; // -9007199254740991
-(Math.pow(2, 53) - 1); // -9007199254740991
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.min\_safe\_integer |

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

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

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

* `Number.MAX_SAFE_INTEGER`
* `Number.isSafeInteger()`


Promise.race() - JavaScript

Promise.race()
==============

Метод **Promise.race(iterable)** возвращает выполненный или отклонённый промис, в зависимости от того, с каким результатом завершится первый из переданных промисов, со значением или причиной отклонения этого промиса.

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

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

```js
Promise.race(iterable);
```

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

`iterable`

Итерируемый объект, такой как (`Array`). Смотри iterable (en-US).

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

Выполненный или отклонённый `Promise` в зависимости от результата первого завершённого из переданных в итерируемом объекте промисов.

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

Метод `race` возвращает `Promise` с результатом, первого завершённого из переданных промисов. Т.е. возвратит resolve или reject, в зависимости от того, что случится первым.

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

### Использование `Promise.race` – пример с `setTimeout`

```js
var p1 = new Promise(function (resolve, reject) {
  setTimeout(resolve, 500, "один");
});
var p2 = new Promise(function (resolve, reject) {
  setTimeout(resolve, 100, "два");
});

Promise.race([p1, p2]).then(function (value) {
  console.log(value); // "два"
  // Оба вернули resolve, однако p2 вернул результат первым
});

var p3 = new Promise(function (resolve, reject) {
  setTimeout(resolve, 100, "три");
});
var p4 = new Promise(function (resolve, reject) {
  setTimeout(reject, 500, "четыре");
});

Promise.race([p3, p4]).then(
  function (value) {
    console.log(value); // "три"
    // p3 быстрее, поэтому выведется значение его resolve
  },
  function (reason) {
    // Не вызывается
  },
);

var p5 = new Promise(function (resolve, reject) {
  setTimeout(resolve, 500, "пять");
});
var p6 = new Promise(function (resolve, reject) {
  setTimeout(reject, 100, "шесть");
});

Promise.race([p5, p6]).then(
  function (value) {
    // Не вызывается
  },
  function (reason) {
    console.log(reason); // "шесть"
    // p6 быстрее, выводится его rejects
  },
);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.race |

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

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

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

* `Promise`


Promise.reject() - JavaScript

Promise.reject()
================

Метод **`Promise.reject(reason)`** возвращает объект `Promise, который был отклонён по указанной причине`.

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

Promise.reject(reason);
```

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

reason

Причина по которой `Promise` был отклонён.

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

Отклонённый с указанной причиной `Promise`.

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

`Promise.reject` возвращает `Promise` который был отклонён. В целях отладки и выборочного отлова ошибок, удобно использовать в качестве причины объекты `Error`.

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

### Использование статического метода Promise.reject()

```js
Promise.reject(new Error("провал")).then(
  function (success) {
    // не вызывается
  },
  function (error) {
    console.log(error); // печатает "провал" + Stacktrace
    throw error; // повторно выбрасываем ошибку, вызывая новый reject
  },
);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.reject |

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

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

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

* `Promise`
* Выборочный отлов ошибок с использованием библиотеки BlueBird Promise


Promise.allSettled() - JavaScript

Promise.allSettled()
====================

Метод **`Promise.allSettled()`** возвращает промис, который исполняется когда все полученные промисы завершены (исполнены или отклонены), содержащий массив результатов исполнения полученных промисов.

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

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

promise.allSettled(iterable);
```

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

`iterable`

Любой итерируемый объект, такой как `Array`, в котором каждый элемент является `Promise`.

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

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

Объект каждого результата содержит свойство `status`. Если `status` имеет значение `fulfilled` (выполнено), то объект будет содержать свойство `value`. Если `status` имеет значение `rejected` (отклонено), то объект будет содержать свойство `reason`. Свойство `value` (или `reason`) будет содержать значение с которым был выполнен (или отклонён) промис.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.allsettled |

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

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

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

* Promises
* Использование промисов
* Graceful asynchronous programming with promises
* `Promise`
* `Promise.all()`


Promise.any() - JavaScript

Promise.any()
=============

`Метод Promise.any()` принимает итерируемый объект содержащий объекты промисов `Promise`. Как только один из промисов (`Promise)` выполнится успешно (`fulfill`), метод возвратит единственный объект `Promise` со значением выполненного промиса. Если ни один из промисов не завершится успешно (если все промисы завершатся с ошибкой, т.е. `rejected`), тогда возвращённый объект Promise будет отклонён (`rejected`) с одним из значений: массив содержащий причины ошибки (отклонения), или `AggregateError` (en-US) — подкласс `Error`, который объединяет выброшенные ошибки вместе. По существу, метод `Promise.any()` является противоположностью для `Promise.all()`.

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

Promise.any(iterable);
```

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

`iterable`

Итерируемый(iterable (en-US)) объект, например `Array`.

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

* **Исполненный** `Promise`, если переданный итерируемый объект пуст.
* **Исполненный асинхронно** `Promise`, если переданный итерируемый объект не содержит промисов.
* Во всех других случаях `Promise` со статусом ожидания(**pending)**. Возвращённый промис будет **исполнен**(resolved/rejected) **асинхронно** (как только стэк вызовов окажется пустым), когда один (любой) промис из *переданного итерируемого объекта исполнится*, либо все промисы будут отклонены.
Описание
--------

Метод полезен, когда нужно вернуть первый исполненный промис. После того как один из промисов будет исполнен, метод не будет дожидаться исполнения остальных. В отличие от `Promise.all()`, который содержит *массив(Array)* значений исполненных промисов, `Promise.any()` содержит только одно значение (при условии, что хотя бы один из промисов исполнен успешно). Такой подход может быть выгодным, когда нужно, чтобы выполнился только один промис, неважно какой. Также, в отличие от `Promise.race()`, который возвращает промис, содержащий значение первого **завершённого(resolved или rejected)**, этот метод возвращает промис содержащее значение первого **успешно выполненного(resolved)** промиса. Метод будет игнорировать исполнение промисов с ошибкой(rejection) вплоть до первого исполненного успешно (fulfilment).

### Успешное исполнение(Fulfilment)

Если один из промисов исполнится успешно, возвращённый промис асинхронно исполнится успешно со значением выполненного промиса, независимо от завершения остальных промисов.

* Если передан пустой итерируемый объект, тогда метод возвращает (синхронно) выполненный промис.
* Если один из переданных промисов исполнится успешно, или в переданном итерируемом объекте не содержится промисов, промис возвращённый из метода `Promise.any` асинхронно исполнится успешно.
### Исполнение с ошибкой(Rejection)

Если все переданные промисы будут отклонены (rejected), `Promise.any` асинхронно будет отклонено в одном из двух вариантов (которые ещё не были согласованы): либо

* Массив(Array) содержащий причины отклонения всех промисов переданных в итерируемом объекте, либо
* Объект `AggregateError` (en-US), расширяющий `Error`, который содержит указатель на массив(Array) исключений.
Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.any |

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

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

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

* `Promise`
* `Promise.allSettled()`
* `Promise.all()`
* `Promise.race()`


Promise.prototype.finally() - JavaScript

Promise.prototype.finally()
===========================

Метод **`finally()`** возвращает `Promise`. Когда промис был выполнен, вне зависимости успешно или с ошибкой, указанная функция будет выполнена. Это даёт возможность запустить один раз определённый участок кода, который должен выполниться вне зависимости от того, с каким результатом выполнился `Promise`.

Это позволяет вам избавиться от дубликации кода в обработчиках `then()` и `catch()`.

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

p.finally(onFinally);

p.finally(function() {
   // завершён (успешно или с ошибкой)
});

p.finally(() => {
// завершён (успешно или с ошибкой)
});
```

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

`onFinally`

Функция `Function` вызываемая когда промис завершен.

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

Возвращает `Promise` для которого в качестве обработчика `finally` задана функция `onFinally`.

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

`finally()` может быть полезен, если необходимо произвести какие-либо вычисления или очистку, как только `Promise` (промис) завершено, вне зависимости от результата.

`finally()` очень схож с вызовом `.then(onFinally, onFinally)`, однако существует несколько различий:

* Использование `finally()` позволяет избежать двойного объявления одной и той же функции или создания переменной.
* `finally` не получает аргументов, так как не существует способа определить, будет ли промис выполнен успешно или с ошибкой. Данный метод необходимо использовать, если не важна причина ошибки или результат успешного выполнения и, следовательно, нет необходимости её/его передавать.
* В отличие от `Promise.resolve(2).then(() => {}, () => {})` (результатом которого будет resolved-промис, со значением `undefined`), результатом `Promise.resolve(2).finally(() => {})` будет resolved-промис со значением `2`.
* Аналогично, в отличии от `Promise.reject(3).then(() => {}, () => {})` (результатом которого будет resolved-промис, со значением `undefined`), результатом `Promise.reject(3).finally(() => {})` будет rejected-промис со значением `3`.

**Примечание:** A `throw` (or returning a rejected promise) in the `finally` callback will reject the new promise with the rejection reason specified when calling `throw()`.

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

```js
let isLoading = true;

fetch(myRequest)
  .then(function (response) {
    var contentType = response.headers.get("content-type");
    if (contentType && contentType.includes("application/json")) {
      return response.json();
    }
    throw new TypeError("Oops, we haven't got JSON!");
  })
  .then(function (json) {
    /\* process your JSON further \*/
  })
  .catch(function (error) {
    console.log(error);
  })
  .finally(function () {
    isLoading = false;
  });
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.prototype.finally |

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

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

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

* `Promise`
* `Promise.prototype.then()`
* `Promise.prototype.catch()`


Promise.resolve() - JavaScript

Promise.resolve()
=================

Метод **`Promise.resolve(value)`** возвращает `Promise` выполненный с переданным значением. Если переданное значение является thenable - объект (т.е. имеет метод `"then" method`), возвращаемый промис будет следовать thenable - объекту, принимая своё состояние; в ином случае возвращаемый промис будет выполнен с переданным значением.

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

Promise.resolve(value);
Promise.resolve(promise);
Promise.resolve(thenable);
```

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

value

Значение с которым будет выполнен промис. Может также быть промисом или объект подобный промису (thenable - объект имеющий метод then).

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

Выполненный с переданным значением `Promise`.

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

`Метод Promise.resolve` возвращает выполненное промис (`Promise`).

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

### Использование метода `Promise.resolve`

```js
Promise.resolve("Success").then(
  function (value) {
    console.log(value); // "Success"
  },
  function (value) {
    // не будет вызвана
  },
);
```

### Выполнение с массивом

```js
var p = Promise.resolve([1, 2, 3]);
p.then(function (v) {
  console.log(v[0]); // 1
});
```

### Выполнение с другим промисом ( `Promise`)

```js
var original = Promise.resolve(true);
var cast = Promise.resolve(original);
cast.then(function (v) {
  console.log(v); // true
});
```

### Выполнение с thenable объектом и выбрасывание исключений

```js
// Выполнение с thenable объектом
var p1 = Promise.resolve({
  then: function (onFulfill, onReject) {
    onFulfill("fulfilled!");
  },
});
console.log(p1 instanceof Promise); // true

p1.then(
  function (v) {
    console.log(v); // "fulfilled!"
  },
  function (e) {
    // не вызывается
  },
);

// Thenable объект выбрасывает исключение
// перед вызовом колбэка Promise resolves
var thenable = {
  then: function (resolve) {
    throw new TypeError("Throwing");
    resolve("Resolving");
  },
};

var p2 = Promise.resolve(thenable);
p2.then(
  function (v) {
    // не вызывается
  },
  function (e) {
    console.log(e); // TypeError: Throwing
  },
);

// Thenable объект выбрасывает исключение
// после вызова колбэка Promise resolves
var thenable = {
  then: function (resolve) {
    resolve("Resolving");
    throw new TypeError("Throwing");
  },
};

var p3 = Promise.resolve(thenable);
p3.then(
  function (v) {
    console.log(v); // "Resolving"
  },
  function (e) {
    // не вызывается
  },
);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.resolve |

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

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

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

* `Promise`