Array.prototype.findIndex() - JavaScript

Array.prototype.findIndex()
===========================

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

Метод **`findIndex()`** возвращает **индекс** в массиве, если элемент удовлетворяет условию проверяющей функции. В противном случае возвращается -1.

Также смотрите метод `find()`, который возвращает **значение** найденного в массиве элемента вместо его индекса.

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

arr.findIndex(callback[, thisArg])
```

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

`callback`

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

`element`

Текущий обрабатываемый элемент в массиве.

`index`

Индекс текущего обрабатываемого элемента в массиве.

`array`

Массив, по которому осуществляется проход.

`thisArg`

Необязательный параметр. Значение, используемое в качестве `this` при выполнении функции `callback`.

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

Метод `findIndex` вызывает переданную функцию `callback` один раз для каждого элемента, присутствующего в массиве, до тех пор, пока она не вернёт `true`. Если такой элемент найден, метод `findIndex` немедленно вернёт индекс этого элемента. В противном случае, метод `findIndex` вернёт -1. Функция `callback` вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались.

Функция `callback` вызывается с тремя аргументами: значением элемента, индексом элемента и массивом, по которому осуществляется проход.

Если в метод `findIndex` был передан параметр `thisArg`, при вызове `callback` он будет использоваться в качестве значения `this`. В противном случае в качестве значения `this` будет использоваться значение `undefined`.

Метод `findIndex` не изменяет массив, для которого он был вызван.

Диапазон элементов, обрабатываемых методом `findIndex`, устанавливается до первого вызова функции `callback`. Элементы, добавленные в массив после начала выполнения метода `findIndex`, не будут посещены функцией `callback`. Если существующие, непосещение элементы массива изменяются функцией `callback`, их значения, переданные в функцию, будут значениями на тот момент времени, когда метод `findIndex` посетит их; удалённые элементы посещены не будут.

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

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

Следующий пример находит в массиве индекс элемента, являющийся простым числом (либо возвращает -1, если в массиве нет простых чисел).

```js
function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, не найдено
console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
```

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

Этот метод был добавлен в спецификации ECMAScript 6 и пока может быть недоступен во всех реализациях JavaScript. Однако, вы можете использовать следующий кусочек кода в качестве полифила:

```js
if (!Array.prototype.findIndex) {
  Array.prototype.findIndex = function (predicate) {
    if (this == null) {
      throw new TypeError(
        "Array.prototype.findIndex called on null or undefined",
      );
    }
    if (typeof predicate !== "function") {
      throw new TypeError("predicate must be a function");
    }
    var list = Object(this);
    var length = list.length >>> 0;
    var thisArg = arguments[1];
    var value;

    for (var i = 0; i < length; i++) {
      value = list[i];
      if (predicate.call(thisArg, value, i, list)) {
        return i;
      }
    }
    return -1;
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.findindex |

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

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

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

* `Array.prototype.find()`
Экспериментальная возможность
* `Array.prototype.indexOf()`


Array.prototype.flat() - JavaScript

Array.prototype.flat()
======================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since January 2020.

* Learn more
* See full compatibility
* Report feedback
Метод **`flat()`** возвращает новый массив, в котором все элементы вложенных подмассивов были рекурсивно "подняты" на указанный уровень depth.

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

var newArray = arr.flat(depth);
```

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

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

На сколько уровней вложенности уменьшается мерность исходного массива. По умолчанию 1.

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

Новый массив с объединёнными в него подмассивами.

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

### Упрощение вложенных массивов

```js
var arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]

var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]

var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

### Упрощение и "дырки" в массивах

Метод flat удаляет пустые слоты из массива:

```js
var arr4 = [1, 2, , 4, 5];
arr4.flat();
// [1, 2, 4, 5]
```

Альтернативы
------------

### `reduce` и `concat`

```js
var arr1 = [1, 2, [3, 4]];
arr1.flat();

// В одномерный массив
arr1.reduce((acc, val) => acc.concat(val), []); // [1, 2, 3, 4]

//или
const flatSingle = (arr) => [].concat(...arr);
```

```js
// Для развёртывания многомерных массивов используем рекурсию, reduce и concat
const arr = [1, 2, [3, 4, [5, 6]]];

function flatDeep(arr, d = 1) {
  return d > 0
    ? arr.reduce(
        (acc, val) =>
          acc.concat(Array.isArray(val) ? flatDeep(val, d - 1) : val),
        [],
      )
    : arr.slice();
}

flatDeep(arr, Infinity);
// [1, 2, 3, 4, 5, 6]
```

```js
//не рекурсивное упрощение с использованием стэка
var arr1 = [1, 2, 3, [1, 2, 3, 4, [2, 3, 4]]];
function flatten(input) {
  const stack = [...input];
  const res = [];
  while (stack.length) {
    // забираем последнее значение
    const next = stack.pop();
    if (Array.isArray(next)) {
      // добавляем к массиву элементы не модифицируя исходное значение
      stack.push(...next);
    } else {
      res.push(next);
    }
  }
  //разворачиваем массив, чтобы восстановить порядок элементов
  return res.reverse();
}
flatten(arr1); // [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
```

```js
//рекурсивно упрощаем массив
function flatten(array) {
  var flattend = [];
  (function flat(array) {
    array.forEach(function (el) {
      if (Array.isArray(el)) flat(el);
      else flattend.push(el);
    });
  })(array);
  return flattend;
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.flat |

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

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

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

* `Array.prototype.flatMap()`
* `Array.prototype.map()`
* `Array.prototype.reduce()`
* `Array.prototype.concat()`


Array.from() - JavaScript

Array.from()
============

Метод **`Array.from()`** создаёт новый экземпляр `Array` из массивоподобного или итерируемого объекта.

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

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

Array.from(arrayLike[, mapFn[, thisArg]])
```

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

`arrayLike`

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

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

Отображающая функция, вызываемая для каждого элемента массива.

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

Значение, используемое в качестве `this` при выполнении функции `mapFn`.

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

Новый экземпляр `Array`

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

`Array.from()` позволяет вам создавать массивы из:

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

`Array.from()` имеет необязательный параметр `mapFn`, который позволяет вам выполнять функцию `map` для каждого элемента создаваемого массива (или его подкласса). Проще говоря, вызов `Array.from(obj, mapFn, thisArg)` эквивалентен цепочке `Array.from(obj).map(mapFn, thisArg)`, за исключением того, что он не создаёт промежуточного массива. Это особенно важно для некоторых подклассов массива, вроде типизированных массивов, поскольку промежуточный массив неизбежно приведёт к усечению значений, чтобы они подпали под подходящий тип.

Свойство `length` метода `from()` равно 1.

В ES2015 классовый синтаксис позволяет создавать подклассы как встроенных классов, так и классов, определённых пользователем; в результате статические методы класса, вроде `Array.from` «наследуются» подклассами `Array` и создают новые экземпляры подкласса, а не класса `Array`.

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

### Массив из строки `String`

```js
Array.from("foo");
// ['f', 'o', 'o']
```

### Массив из `Set`

```js
var s = new Set(["foo", window]);
Array.from(s);
// ['foo', window]
```

### Массив из `Map`

```js
var m = new Map([
  [1, 2],
  [2, 4],
  [4, 8],
]);
Array.from(m);
// [[1, 2], [2, 4], [4, 8]]
```

### Массив из массивоподобного объекта (arguments)

```js
function f() {
  return Array.from(arguments);
}

f(1, 2, 3);
// [1, 2, 3]
```

### Использование стрелочной функции и `Array.from()`

```js
// Использование стрелочной функции в качестве функции отображения для

// манипулирования элементами
Array.from([1, 2, 3], (x) => x + x);
// [2, 4, 6]

// Генерирования последовательности чисел
Array.from({ length: 5 }, (v, k) => k);
// [0, 1, 2, 3, 4]
```

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

Метод `Array.from` был добавлен к стандарту ECMA-262 в 6-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать `Array.from` в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 6-го издания; он предполагает, что `Object` и `TypeError` имеют свои первоначальные значения и что `callback.call` вычисляется в оригинальное значение `Function.prototype.call`. Кроме того, поскольку истинные итерируемые объекты не могут быть заменены полифилом, эта реализация не поддерживает общие итерируемые объекты, как они определены в 6-м издании ECMA-262.

```js
// Шаги алгоритма ECMA-262, 6-е издание, 22.1.2.1
// Ссылка: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from
if (!Array.from) {
  Array.from = (function () {
    var toStr = Object.prototype.toString;
    var isCallable = function (fn) {
      return typeof fn === "function" || toStr.call(fn) === "[object Function]";
    };
    var toInteger = function (value) {
      var number = Number(value);
      if (isNaN(number)) {
        return 0;
      }
      if (number === 0 || !isFinite(number)) {
        return number;
      }
      return (number > 0 ? 1 : -1) \* Math.floor(Math.abs(number));
    };
    var maxSafeInteger = Math.pow(2, 53) - 1;
    var toLength = function (value) {
      var len = toInteger(value);
      return Math.min(Math.max(len, 0), maxSafeInteger);
    };

    // Свойство length метода from равно 1.
    return function from(arrayLike /\*, mapFn, thisArg \*/) {
      // 1. Положим C равным значению this.
      var C = this;

      // 2. Положим items равным ToObject(arrayLike).
      var items = Object(arrayLike);

      // 3. ReturnIfAbrupt(items).
      if (arrayLike == null) {
        throw new TypeError(
          "Array.from requires an array-like object - not null or undefined",
        );
      }

      // 4. Если mapfn равен undefined, положим mapping равным false.
      var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
      var T;
      if (typeof mapFn !== "undefined") {
        // 5. иначе
        // 5. a. Если вызов IsCallable(mapfn) равен false, выкидываем исключение TypeError.
        if (!isCallable(mapFn)) {
          throw new TypeError(
            "Array.from: when provided, the second argument must be a function",
          );
        }

        // 5. b. Если thisArg присутствует, положим T равным thisArg; иначе положим T равным undefined.
        if (arguments.length > 2) {
          T = arguments[2];
        }
      }

      // 10. Положим lenValue равным Get(items, "length").
      // 11. Положим len равным ToLength(lenValue).
      var len = toLength(items.length);

      // 13. Если IsConstructor(C) равен true, то
      // 13. a. Положим A равным результату вызова внутреннего метода [[Construct]]
      // объекта C со списком аргументов, содержащим единственный элемент len.
      // 14. a. Иначе, положим A равным ArrayCreate(len).
      var A = isCallable(C) ? Object(new C(len)) : new Array(len);

      // 16. Положим k равным 0.
      var k = 0;
      // 17. Пока k < len, будем повторять... (шаги с a по h)
      var kValue;
      while (k < len) {
        kValue = items[k];
        if (mapFn) {
          A[k] =
            typeof T === "undefined"
              ? mapFn(kValue, k)
              : mapFn.call(T, kValue, k);
        } else {
          A[k] = kValue;
        }
        k += 1;
      }
      // 18. Положим putStatus равным Put(A, "length", len, true).
      A.length = len;
      // 20. Вернём A.
      return A;
    };
  })();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.from |

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

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

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

* `Array`
* `Array.prototype.map()`
* `TypedArray.from()` (en-US)


Array.prototype.shift() - JavaScript

Array.prototype.shift()
=======================

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

Метод **`shift()`** удаляет **первый** элемент из массива и возвращает его значение. Этот метод изменяет длину массива.

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

arr.shift()
```

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

Метод `shift` удаляет элемент по нулевому индексу, сдвигает значения по последовательным индексам вниз, а затем возвращает удалённое значение. Если свойство `length` массива равно 0, вернётся значение `undefined`.

Метод `shift` не является привязанным к типу; этот метод может быть вызван или применён к объектам, напоминающим массив. Объекты, не содержащие свойство `length`, отражающее последний элемент в серии последовательных числовых, начинающихся с нуля, свойств, могут повести себя неправильным образом.

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

### Пример: удаление элемента из массива

Следующий код показывает массив `myFish` до и после удаления его первого элемента. Также он показывает удалённый элемент:

```js
var myFish = ["ангел", "клоун", "мандарин", "хирург"];

console.log("myFish до: " + myFish);
//myFish до: ангел,клоун,мандарин,хирург

var shifted = myFish.shift();

console.log("myFish после: " + myFish);
//myFish после: клоун,мандарин,хирург

console.log("Удалён этот элемент: " + shifted);
//Удалён этот элемент: ангел
```

Вывод этого примера будет следующим:

```js
myFish до: ангел,клоун,мандарин,хирург
myFish после: клоун,мандарин,хирург
Удалён этот элемент: ангел
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.shift |

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

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

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

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.unshift()`


Array.prototype[@@iterator]() - JavaScript

Array.prototype[@@iterator]()
=============================

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

Начальное значение свойства **`@@iterator`** является тем же самым функциональным объектом, что и начальное значение, возвращаемое методом `values()`.

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

arr[Symbol.iterator]()
```

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

### Пример: итерация посредством цикла `for...of`

```js
var arr = ["w", "y", "k", "o", "p"];
// ваш браузер должен поддерживать цикл for..of
// и переменные с областью видимости let в циклах for
for (let letter of arr) {
  console.log(letter);
}
```

### Пример: альтернативный способ итерации

```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr[Symbol.iterator]();
console.log(eArr.next().value); // w
console.log(eArr.next().value); // y
console.log(eArr.next().value); // k
console.log(eArr.next().value); // o
console.log(eArr.next().value); // p
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype-@@iterator |

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

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

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

* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `Array.prototype.values()`


Array.prototype.concat() - JavaScript

Array.prototype.concat()
========================

Метод **`concat()`** возвращает новый массив, состоящий из массива, на котором он был вызван, соединённого с другими массивами и/или значениями, переданными в качестве аргументов.

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

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

var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
```

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

`valueN`

Массивы и/или значения, соединяемые в новый массив. Смотрите описание ниже.

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

Новый экземпляр `Array`.

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

Метод `concat` создаёт новый массив, состоящий из элементов в объекте, на котором он был вызван, за которыми по порядку следуют, для каждого аргумента, все его элементы (если аргумент является массивом), либо сам аргумент (если он массивом не является).

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

* Ссылки на объекты (но не фактические объекты): метод `concat` копирует ссылки на объекты в новый массив. И оригинал, и новый массив ссылаются на один и тот же объект. То есть, если объект по ссылке будет изменён, изменения будут видны и в новом, и в исходном массивах.
* Строки, числа и булевы значения (но не объекты `String`, `Number` или `Boolean`): метод `concat` копирует значения строк и чисел в новый массив.

**Примечание:** Соединение массивов и/или значений в новый массив оставит соединяемые массивы/значения неизменными. Кроме того, любая операция над новым массивом (если только элемент не является ссылкой) не будет затрагивать исходные массивы и наоборот.

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

### Соединение двух массивов

Следующий код соединяет два массива:

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

var alphaNumeric = alpha.concat(numeric);

console.log(alphaNumeric); // Результат: ['a', 'b', 'c', 1, 2, 3]
```

### Соединение трёх массивов

Следующий код соединяет три массива:

```js
var num1 = [1, 2, 3],
  num2 = [4, 5, 6],
  num3 = [7, 8, 9];

var nums = num1.concat(num2, num3);

console.log(nums); // Результат: [1, 2, 3, 4, 5, 6, 7, 8, 9]
```

### Соединение значений в массив

Следующий код соединяет три значения в массив:

```js
var alpha = ["a", "b", "c"];

var alphaNumeric = alpha.concat(1, [2, 3]);

console.log(alphaNumeric); // Результат: ['a', 'b', 'c', 1, 2, 3]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.concat |

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

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

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

* `push` / `pop` — добавление / удаление элементов с конца массива
* `unshift` / `shift` — добавление / удаление элементов с начала массива
* `splice` — добавление / удаление элементов в указанной позиции массива
* `String.prototype.concat()`
* `Symbol.isConcatSpreadable` — управление уменьшением размерности массива


Array.prototype.copyWithin() - JavaScript

Array.prototype.copyWithin()
============================

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

Метод **`copyWithin()`** копирует последовательность элементов массива внутри него в позицию, начинающуюся по индексу `target`. Копия берётся по индексам, задаваемым вторым и третьим аргументами `start` и `end`. Аргумент `end` является необязательным и по умолчанию равен длине массива.

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

arr.copyWithin(target, start[, end = this.length])
```

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

`target`

Начальный индекс позиции цели, куда копировать элементы.

`start`

Начальный индекс позиции источника, откуда начинать копировать элементы.

`end`

Необязательный параметр. Конечный индекс позиции источника, где заканчивать копировать элементы, не включая элемент на позиции `end`.

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

Аргументы `target`, `start` и `end` приводятся к `Number` и обрезаются до целых значений.

Если аргумент `start` является отрицательным, он трактуется как `length+start` где `length` — это длина массива. Если аргумент `end` является отрицательным, он трактуется как `length+end`.

Функция `copyWithin` намеренно является *обобщённой*, она не требует, чтобы значение `this` внутри неё было объектом `Array`, и кроме того, функция `copyWithin` является *изменяющим методом*, она изменит объект `this` и вернёт его, а не просто вернёт копию.

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

```js
[1, 2, 3, 4, 5].copyWithin(0, 3);
// [4, 5, 3, 4, 5]

[1, 2, 3, 4, 5].copyWithin(0, 3, 4);
// [4, 2, 3, 4, 5]

[1, 2, 3, 4, 5].copyWithin(0, -2, -1);
// [4, 2, 3, 4, 5]

[].copyWithin.call({ length: 5, 3: 1 }, 0, 3);
// {0: 1, 3: 1, length: 5}

// Типизированные массивы ES6 являются подклассами Array
var i32a = new Int32Array([1, 2, 3, 4, 5]);

i32a.copyWithin(0, 2);
// Int32Array [3, 4, 5, 4, 5]

// На платформах, которые ещё не совместимы с ES6:
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
// Int32Array [4, 2, 3, 4, 5]
```

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

```js
if (!Array.prototype.copyWithin) {
  Array.prototype.copyWithin = function (target, start /\*, end\*/) {
    // Шаги 1-2.
    if (this == null) {
      throw new TypeError("this is null or not defined");
    }

    var O = Object(this);

    // Шаги 3-5.
    var len = O.length >>> 0;

    // Шаги 6-8.
    var relativeTarget = target >> 0;

    var to =
      relativeTarget < 0
        ? Math.max(len + relativeTarget, 0)
        : Math.min(relativeTarget, len);

    // Шаги 9-11.
    var relativeStart = start >> 0;

    var from =
      relativeStart < 0
        ? Math.max(len + relativeStart, 0)
        : Math.min(relativeStart, len);

    // Шаги 12-14.
    var end = arguments[2];
    var relativeEnd = end === undefined ? len : end >> 0;

    var final =
      relativeEnd < 0
        ? Math.max(len + relativeEnd, 0)
        : Math.min(relativeEnd, len);

    // Шаг 15.
    var count = Math.min(final - from, len - to);

    // Шаги 16-17.
    var direction = 1;

    if (from < to && to < from + count) {
      direction = -1;
      from += count - 1;
      to += count - 1;
    }

    // Шаг 18
    while (count > 0) {
      if (from in O) {
        O[to] = O[from];
      } else {
        delete O[to];
      }

      from += direction;
      to += direction;
      count--;
    }

    // Шаг 19.
    return O;
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.copywithin |

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

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

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

* `Array`


Array.prototype.sort() - JavaScript

Array.prototype.sort()
======================

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

Метод **`sort()`** *на месте* сортирует элементы массива и возвращает отсортированный массив. Сортировка не обязательно устойчива (англ.). Порядок сортировки по умолчанию соответствует порядку кодовых точек Unicode.

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

arr.sort([compareFunction])
```

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

`compareFunction`

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

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

Отсортированный массив. Важно, что копия массива не создаётся - массив сортируется *на месте*.

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

Если функция сравнения `compareFunction` не предоставляется, элементы сортируются путём преобразования их в строки и сравнения строк в порядке следования кодовых точек Unicode. Например, слово "Вишня" идёт перед словом "бананы". При числовой сортировке, 9 идёт перед 80, но поскольку числа преобразуются в строки, то "80" идёт перед "9" в соответствии с порядком в Unicode.

```js
var fruit = ["арбузы", "бананы", "Вишня"];
fruit.sort(); // ['Вишня', 'арбузы', 'бананы']

var scores = [1, 2, 10, 21];
scores.sort(); // [1, 10, 2, 21]

var things = ["слово", "Слово", "1 Слово", "2 Слова"];
things.sort(); // ['1 Слово', '2 Слова', 'Слово', 'слово']
// В Unicode, числа находятся перед буквами в верхнем регистре,
// а те, в свою очередь, перед буквами в нижнем регистре.
```

Если функция сравнения `compareFunction` предоставлена, элементы массива сортируются в соответствии с её возвращаемым значением. Если сравниваются два элемента `a` и `b`, то:

* Если `compareFunction(a, b)` меньше 0, сортировка поставит `a` по меньшему индексу, чем `b`, то есть, `a` идёт первым.
* Если `compareFunction(a, b)` вернёт 0, сортировка оставит `a` и `b` неизменными по отношению друг к другу, но отсортирует их по отношению ко всем другим элементам. Обратите внимание: стандарт ECMAscript не гарантирует данное поведение, и ему следуют не все браузеры (например, версии Mozilla по крайней мере, до 2003 года).
* Если `compareFunction(a, b)` больше 0, сортировка поставит `b` по меньшему индексу, чем `a`.
* Функция `compareFunction(a, b)` должна всегда возвращать одинаковое значение для определённой пары элементов `a` и `b`. Если будут возвращаться непоследовательные результаты, порядок сортировки будет не определён.

Итак, функция сравнения имеет следующую форму:

```js
function compare(a, b) {
  if (a меньше b по некоторому критерию сортировки) {
    return -1;
  }
  if (a больше b по некоторому критерию сортировки) {
    return 1;
  }
  // a должно быть равным b
  return 0;
}
```

Для числового сравнения, вместо строкового, функция сравнения может просто вычитать `b` из `a`. Следующая функция будет сортировать массив по возрастанию:

```js
function compareNumbers(a, b) {
  return a - b;
}
```

Метод `sort` можно удобно использовать с функциональными выражениями (и замыканиями):

```js
var numbers = [4, 2, 5, 1, 3];
numbers.sort(function (a, b) {
  return a - b;
});
console.log(numbers); // [1, 2, 3, 4, 5]
```

Объекты могут быть отсортированы по значению одного из своих свойств.

```js
var items = [
  { name: "Edward", value: 21 },
  { name: "Sharpe", value: 37 },
  { name: "And", value: 45 },
  { name: "The", value: -12 },
  { name: "Magnetic" },
  { name: "Zeros", value: 37 },
];
items.sort(function (a, b) {
  if (a.name > b.name) {
    return 1;
  }
  if (a.name < b.name) {
    return -1;
  }
  // a должно быть равным b
  return 0;
});
```

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

### Пример: создание, отображение и сортировка массива

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

```js
var stringArray = ["Голубая", "Горбатая", "Белуга"];
var numericStringArray = ["80", "9", "700"];
var numberArray = [40, 1, 5, 200];
var mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];

function compareNumbers(a, b) {
  return a - b;
}

// снова предполагаем, что функция печати определена
console.log("stringArray:", stringArray.join());
console.log("Сортировка:", stringArray.sort());

console.log("numberArray:", numberArray.join());
console.log("Сортировка без функции сравнения:", numberArray.sort());
console.log(
  "Сортировка с функцией compareNumbers:",
  numberArray.sort(compareNumbers),
);

console.log("numericStringArray:", numericStringArray.join());
console.log("Сортировка без функции сравнения:", numericStringArray.sort());
console.log(
  "Сортировка с функцией compareNumbers:",
  numericStringArray.sort(compareNumbers),
);

console.log("mixedNumericArray:", mixedNumericArray.join());
console.log("Сортировка без функции сравнения:", mixedNumericArray.sort());
console.log(
  "Сортировка с функцией compareNumbers:",
  mixedNumericArray.sort(compareNumbers),
);
```

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

stringArray: Голубая,Горбатая,Белуга
Сортировка: Белуга,Голубая,Горбатая

numberArray: 40,1,5,200
Сортировка без функции сравнения: 1,200,40,5
Сортировка с функцией compareNumbers: 1,5,40,200

numericStringArray: 80,9,700
Сортировка без функции сравнения: 700,80,9
Сортировка с функцией compareNumbers: 9,80,700

mixedNumericArray: 80,9,700,40,1,5,200
Сортировка без функции сравнения: 1,200,40,5,700,80,9
Сортировка с функцией compareNumbers: 1,5,9,40,80,200,700
```

### Пример: сортировка не-ASCII символов

Для сортировки строк с не-ASCII символами, то есть строк с символами акцента (e, é, è, a, ä и т.д.), строк, с языками, отличными от английского: используйте `String.localeCompare`. Эта функция может сравнивать эти символы, чтобы они становились в правильном порядке.

```js
var items = ["réservé", "premier", "cliché", "communiqué", "café", "adieu"];
items.sort(function (a, b) {
  return a.localeCompare(b);
});

// items равен ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']
```

### Пример: сортировка c помощью map

Функция сравнения `(compareFunction)` может вызываться несколько раз для каждого элемента в массиве. В зависимости от природы функции сравнения, это может привести к высоким расходам ресурсов. Чем более сложна функция сравнения и чем больше элементов требуется отсортировать, тем разумнее использовать map для сортировки. Идея состоит в том, чтобы обойти массив один раз, чтобы извлечь фактические значения, используемые для сортировки, во временный массив, отсортировать временный массив, а затем обойти временный массив для получения правильного порядка.

```js
// массив для сортировки
var list = ["Дельта", "альфа", "ЧАРЛИ", "браво"];

// временный массив содержит объекты с позицией и значением сортировки
var mapped = list.map(function (el, i) {
  return { index: i, value: el.toLowerCase() };
});

// сортируем массив, содержащий уменьшенные значения
mapped.sort(function (a, b) {
  if (a.value > b.value) {
    return 1;
  }
  if (a.value < b.value) {
    return -1;
  }
  return 0;
});

// контейнер для результа
var result = mapped.map(function (el) {
  return list[el.index];
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.sort |

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

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

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

* `Array.prototype.reverse()`
* `String.prototype.localeCompare()`


Array.prototype.reduce() - JavaScript

Array.prototype.reduce()
========================

Метод **`reduce()`** применяет функцию **reducer** к каждому элементу массива (слева-направо), возвращая одно результирующее значение.

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

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

array.reduce(callback[, initialValue])
```

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

`callback`

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

`accumulator`

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

`currentValue`

Текущий обрабатываемый элемент массива.

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

Индекс текущего обрабатываемого элемента массива.

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

Массив, для которого была вызвана функция `reduce`.

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

Необязательный параметр. Объект, используемый в качестве первого аргумента при первом вызове функции `callback`.

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

Метод `reduce()` выполняет функцию `callback` один раз для каждого элемента, присутствующего в массиве, за исключением пустот, принимая четыре аргумента: начальное значение (или значение от предыдущего вызова `callback`), значение текущего элемента, текущий индекс и массив, по которому происходит итерация.

При первом вызове функции, параметры `accumulator` и `currentValue` могут принимать одно из двух значений. Если при вызове `reduce()` передан аргумент `initialValue`, то значение `accumulator` будет равным значению `initialValue`, а значение `currentValue` будет равным первому значению в массиве. Если аргумент `initialValue` не задан, то значение `accumulator` будет равным первому значению в массиве, а значение `currentValue` будет равным второму значению в массиве.

Если массив пустой и аргумент `initialValue` не указан, будет брошено исключение `TypeError`. Если массив состоит только из одного элемента (независимо от его положения в массиве) и аргумент `initialValue` не указан, или если аргумент `initialValue` указан, но массив пустой, то будет возвращено одно это значение, без вызова функции `callback`.

Предположим, что `reduce()` используется следующим образом:

```js
[0, 1, 2, 3, 4].reduce(function (previousValue, currentValue, index, array) {
  return previousValue + currentValue;
});
```

Колбэк-функция будет вызвана четыре раза, аргументы и возвращаемое значение при каждом вызове будут следующими:

|  | `previousValue` | `currentValue` | `index` | `array` | возвращаемое значение |
| --- | --- | --- | --- | --- | --- |
| первый вызов | `0` | `1` | `1` | `[0, 1, 2, 3, 4]` | `1` |
| второй вызов | `1` | `2` | `2` | `[0, 1, 2, 3, 4]` | `3` |
| третий вызов | `3` | `3` | `3` | `[0, 1, 2, 3, 4]` | `6` |
| четвёртый вызов | `6` | `4` | `4` | `[0, 1, 2, 3, 4]` | `10` |

Значение, возвращённое методом `reduce()` будет равным последнему результату выполнения колбэк-функции — `10`.

Если же вы зададите начальное значение `initialValue`, результат будет выглядеть так:

```js
[0, 1, 2, 3, 4].reduce(function (accumulator, currentValue, index, array) {
  return accumulator + currentValue;
}, 10);
```

|  | `accumulator` | `currentValue` | `index` | `array` | возвращаемое значение |
| --- | --- | --- | --- | --- | --- |
| первый вызов | `10` | `0` | `0` | `[0, 1, 2, 3, 4]` | `10` |
| второй вызов | `10` | `1` | `1` | `[0, 1, 2, 3, 4]` | `11` |
| третий вызов | `11` | `2` | `2` | `[0, 1, 2, 3, 4]` | `13` |
| четвёртый вызов | `13` | `3` | `3` | `[0, 1, 2, 3, 4]` | `16` |
| пятый вызов | `16` | `4` | `4` | `[0, 1, 2, 3, 4]` | `20` |

Значение, возвращённое методом `reduce()` на этот раз, конечно же, будет равным `20`.

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

### Суммирование всех значений в массиве

```js
var total = [0, 1, 2, 3].reduce(function (a, b) {
  return a + b;
});
// total == 6
```

### Суммирование значений в массиве объектов

Чтобы суммировать значения, содержащиеся в массиве объектов, вы **должны** указать `initialValue`, чтобы каждый элемент смог пройти через `callback`.

```js
var initialValue = 0;
var sum = [{ x: 1 }, { x: 2 }, { x: 3 }].reduce(function (
  accumulator,
 currentValue,
) {
  return accumulator + currentValue.x;
}, initialValue);
// sum == 6
```

Тоже самое, но со стрелочной функцией:

```js
var initialValue = 0;
var sum = [{ x: 1 }, { x: 2 }, { x: 3 }].reduce(
  (accumulator, currentValue) => accumulator + currentValue.x,
  initialValue,
);
// sum == 6
```

### Разворачивание массива массивов

```js
var flattened = [
  [0, 1],
  [2, 3],
  [4, 5],
].reduce(function (a, b) {
  return a.concat(b);
});
// flattened равен [0, 1, 2, 3, 4, 5]
```

### Пример: склеивание массивов, содержащихся в объектах массива, с использованием оператора расширения и initialValue

```js
// friends - список из объектов(друзей)
// где поле "books" - список любимых книг друга
var friends = [
  { name: "Anna", books: ["Bible", "Harry Potter"], age: 21 },
  { name: "Bob", books: ["War and peace", "Romeo and Juliet"], age: 26 },
  { name: "Alice", books: ["The Lord of the Rings", "The Shining"], age: 18 },
];

// allbooks - список, который будет содержать все книги друзей +
// дополнительный список указанный в initialValue
var allbooks = friends.reduce(
  function (prev, curr) {
    return [...prev, ...curr.books];
  },
  ["Alphabet"],
);

// allbooks = ["Alphabet", "Bible", "Harry Potter", "War and peace",
// "Romeo and Juliet", "The Lord of the Rings", "The Shining"]
```

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

Метод `Array.prototype.reduce()` был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать `reduce()` в реализациях, которые не поддерживают этот метод.

```js
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.21
// Ссылка (en): http://es5.github.io/#x15.4.4.21
// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.21
if (!Array.prototype.reduce) {
  Array.prototype.reduce = function (callback /\*, initialValue\*/) {
    "use strict";
    if (this == null) {
      throw new TypeError("Array.prototype.reduce called on null or undefined");
    }
    if (typeof callback !== "function") {
      throw new TypeError(callback + " is not a function");
    }
    var t = Object(this),
      len = t.length >>> 0,
      k = 0,
      value;
    if (arguments.length >= 2) {
      value = arguments[1];
    } else {
      while (k < len && !(k in t)) {
        k++;
      }
      if (k >= len) {
        throw new TypeError("Reduce of empty array with no initial value");
      }
      value = t[k++];
    }
    for (; k < len; k++) {
      if (k in t) {
        value = callback(value, t[k], k, t);
      }
    }
    return value;
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.reduce |

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

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

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

* `Array.prototype.reduceRight()`


Array.prototype.every() - JavaScript

Array.prototype.every()
=======================

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

Метод **`every()`** проверяет, удовлетворяют ли все элементы массива условию, заданному в передаваемой функции.

**Примечание:** метод возвращает `true` при любом условии для пустого массива.

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

arr.every(callback(currentValue[, index[, array]])[, thisArg])
```

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

`callback`

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

`currentValue`

Текущий обрабатываемый элемент массива.

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

Индекс текущего обрабатываемого элемента массива.

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

Массив, по которому осуществляется проход.

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

Необязательный параметр. Значение, используемое в качестве `this` при выполнении функции `callback`.

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

**`true`** если функция проверки возвращает truthy значение для каждого элемента массива. Иначе, **`false`**.

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

Метод `every()` вызывает переданную функцию `callback` один раз для каждого элемента, присутствующего в массиве до тех пор, пока не найдёт такой, для которого `callback` вернёт *ложное* значение (значение, становящееся равным `false` при приведении его к типу `Boolean`). Если такой элемент найден, метод `every()` немедленно вернёт `false`. В противном случае, если `callback` вернёт `true` для всех элементов массива, метод `every()` вернёт `true`. Функция `callback` вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались.

Функция `callback` вызывается с тремя аргументами: значением элемента, индексом элемента и массивом, по которому осуществляется проход.

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

Метод `every()` не изменяет массив, для которого он был вызван.

Диапазон элементов, обрабатываемых методом `every()`, устанавливается до первого вызова функции `callback`. Элементы, добавленные в массив после начала выполнения метода `every()`, не будут посещены функцией `callback`. Если существующие элементы массива изменятся, значения, переданные в функцию `callback`, будут значениями на тот момент времени, когда метод `every()` посетит их; удалённые элементы посещены не будут.

Метод `every()` действует подобно квантору всеобщности в математике. В частности, он вернёт `true` для пустого массива. Это так называемая бессодержательная истина (vacuously true) — все элементы пустого множества (англ.) удовлетворяют любому заданному условию.

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

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

Следующий пример проверяет, являются ли все элементы массива числами, большими 10.

```js
function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough); // false
[12, 54, 18, 130, 44].every(isBigEnough); // true
```

### Пример: использование стрелочных функций

Стрелочные функции предоставляют более краткий синтаксис для подобных проверок.

```js
[12, 5, 8, 130, 44].every((elem) => elem >= 10); // false
[12, 54, 18, 130, 44].every((elem) => elem >= 10); // true
```

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

Метод `every()` был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может не присутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать `every()` в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; и предполагает что `Object` и `TypeError` имеют свои первоначальные значения и что `callback.call` вычисляется в оригинальное значение `Function.prototype.call()`.

```js
if (!Array.prototype.every) {
  Array.prototype.every = function (callbackfn, thisArg) {
    "use strict";
    var T, k;

    if (this == null) {
      throw new TypeError("this is null or not defined");
    }

    // 1. Положим O равным результату вызова ToObject над значением
    // this, переданным в качестве аргумента.
    var O = Object(this);

    // 2. Положим lenValue равным результату вызова внутреннего метода Get
    // объекта O с аргументом "length".
    // 3. Положим len равным ToUint32(lenValue).
    var len = O.length >>> 0;

    // 4. Если IsCallable(callbackfn) равен false, выкинем исключение TypeError.
    if (typeof callbackfn !== "function") {
      throw new TypeError();
    }

    // 5. Если thisArg присутствует, положим T равным thisArg; иначе положим T равным undefined.
    if (arguments.length > 1) {
      T = thisArg;
    }

    // 6. Положим k равным 0.
    k = 0;

    // 7. Пока k < len, будем повторять
    while (k < len) {
      var kValue;

      // a. Положим Pk равным ToString(k).
      // Это неявное преобразование для левостороннего операнда в операторе in
      // b. Положим kPresent равным результату вызова внутреннего метода
      // HasProperty объекта O с аргументом Pk.
      // Этот шаг может быть объединён с шагом c
      // c. Если kPresent равен true, то
      if (k in O) {
        // i. Положим kValue равным результату вызова внутреннего метода Get
        // объекта O с аргументом Pk.
        kValue = O[k];

        // ii. Положим testResult равным результату вызова внутреннего метода Call
        // функции callbackfn со значением T в качестве this и списком аргументов,
        // содержащим kValue, k и O.
        var testResult = callbackfn.call(T, kValue, k, O);

        // iii. Если ToBoolean(testResult) равен false, вернём false.
        if (!testResult) {
          return false;
        }
      }
      k++;
    }
    return true;
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.every |

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

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

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

* `Array.prototype.forEach()`
* `Array.prototype.some()`
* `Array.prototype.find()`
* `TypedArray.prototype.every()` (en-US)


get Array[@@species] - JavaScript

get Array[@@species]
====================

Метод **`Array[@@species]`** возвращает конструктор `Array` .

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

Array[Symbol.species]
```

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

Конструктор `Array`.

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

Метод `species` возвращает стандартный конструктор объектов `Array` . Дочерние элементы могут переопределить метод для смены назначения конструктора.

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

 Метод `species` возвращает стандартное значение функции конструктора, то есть
 `Array` конструктор для `Array` объектов:

```js
Array[Symbol.species]; // функция Array()
```

В полученном объекте (на примере обычного массива `MyArray`), `MyArray` является конструктором `MyArray`. В случае, если вы захотите вернуть родительские объекты `Array` в полученных классовых методах, вы можете переопределить метод:

```js
class MyArray extends Array {
  // Переписывает тип MyArray в родительский конструктор Array
  static get [Symbol.species]() {
    return Array;
  }
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-array-@@species |

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

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

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

* `Array`
* `Symbol.species`


Array.prototype.flatMap() - JavaScript

Array.prototype.flatMap()
=========================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since January 2020.

* Learn more
* See full compatibility
* Report feedback
Метод **`flatMap()`** сначала применяет функцию к каждому элементу, а затем преобразует полученный результат в плоскую структуру и помещает в новый массив. Это идентично map функции, с последующим применением функции flat с параметром depth ( глубина ) равным 1, но `flatMap` часто бывает полезным, так как работает немного более эффективно.

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

var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
    // возвращает элемент для new_array
}[, thisArg])
```

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

`callback`

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

`currentValue`

Текущий обрабатываемый элемент массива.

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

Индекс обрабатываемого элемента в массиве.

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

Массив по которому осуществляется обход.

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

Значение используемое в качестве `this` при вызове функции `callback`.

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

Новый массив, каждый элемент которого является результатом выполнения функции callback и "поднят" на уровень 1.

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

Смотрите `Array.prototype.map()` для детального описания callback функции. Метод `flatMap` идентичен методу `map` с последующим вызовом `flat` с параметром depth 1.

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

### `map` и `flatMap`

```js
let arr1 = [1, 2, 3, 4];

arr1.map((x) => [x \* 2]);
// [[2], [4], [6], [8]]

arr1.flatMap((x) => [x \* 2]);
// [2, 4, 6, 8]

// выравнивается только один уровень
arr1.flatMap((x) => [[x \* 2]]);
// [[2], [4], [6], [8]]
```

Хотя результат полученный в примере выше можно было получить используя просто map, ниже мы рассмотрим пример где `flatMap` является более эффективным.

Давайте сгенерируем список слов из списка предложений.

```js
let arr1 = ["it's Sunny in", "", "California"];

arr1.map((x) => x.split(" "));
// [["it's","Sunny","in"],[""],["California"]]

arr1.flatMap((x) => x.split(" "));
// ["it's","Sunny","in", "", "California"]
```

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

//=> [1, 2, 3, 4, 5, 6, 7, 8, 9]

Альтернативное решение
----------------------

### `reduce` and `concat`

```js
var arr1 = [1, 2, 3, 4];
arr1.flatMap((x) => [x \* 2]);
// is equivalent to
arr1.reduce((acc, x) => acc.concat([x \* 2]), []);
// [2, 4, 6, 8]
```

//=> [1, 2, 3, 4, 5, 6, 7, 8, 9]

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.flatmap |

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

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

См так же
---------

* `Array.prototype.flat()`
* `Array.prototype.map()`
* `Array.prototype.reduce()`
* `Array.prototype.concat()`


Array.prototype.reduceRight() - JavaScript

Array.prototype.reduceRight()
=============================

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

Метод **`reduceRight()`** применяет функцию к аккумулятору и каждому значению массива (справа-налево), сводя его к одному значению.

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

arr.reduceRight(callback[, initialValue])
```

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

`callback`

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

`previousValue`

Значение, возвращённое предыдущим выполнением функции `callback`, либо значение `initialValue`, если оно предоставлено (смотрите пояснения ниже).

`currentValue`

Текущий обрабатываемый элемент массива.

`index`

Индекс текущего обрабатываемого элемента массива.

`array`

Массив, для которого была вызвана функция `reduceRight`.

`initialValue`

Необязательный параметр. Объект, используемый в качестве первого аргумента при первом вызове функции `callback`.

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

Метод `reduceRight()` выполняет функцию `callback` один раз для каждого элемента, присутствующего в массиве, за исключением пустот, принимая четыре аргумента: начальное значение (или значение от предыдущего вызова `callback`), значение текущего элемента, текущий индекс и массив, по которому происходит итерация.

Вызов колбэк-функции `callback` будет выглядеть так:

```js
array.reduceRight(function (previousValue, currentValue, index, array) {
  // ...
});
```

При первом вызове функции, параметры `previousValue` и `currentValue` могут принимать одно из двух значений. Если при вызове `reduceRight()` передан аргумент `initialValue`, то значение `previousValue` будет равным значению `initialValue`, а значение `currentValue` будет равным последнему значению в массиве. Если аргумент `initialValue` не задан, то значение `previousValue` будет равным последнему значению в массиве, а значение `currentValue` будет равным второму с конца значению в массиве.

Если массив пустой и аргумент `initialValue` не указан, будет брошено исключение `TypeError`. Если массив состоит только из одного элемента (независимо от его положения в массиве) и аргумент `initialValue` не указан, или если аргумент `initialValue` указан, но массив пустой, то будет возвращено одно это значение, без вызова функции `callback`.

Вот так будут выглядеть некоторый примеры прогона функции:

```js
[0, 1, 2, 3, 4].reduceRight(
  function (previousValue, currentValue, index, array) {
    return previousValue + currentValue;
  },
);
```

Колбэк-функция будет вызвана четыре раза, аргументы и возвращаемое значение при каждом вызове будут следующими:

|  | `previousValue` | `currentValue` | `index` | `array` | возвращаемое значение |
| --- | --- | --- | --- | --- | --- |
| первый вызов | `4` | `3` | `3` | `[0, 1, 2, 3, 4]` | `7` |
| второй вызов | `7` | `2` | `2` | `[0, 1, 2, 3, 4]` | `9` |
| третий вызов | `9` | `1` | `1` | `[0, 1, 2, 3, 4]` | `10` |
| четвёртый вызов | `10` | `0` | `0` | `[0, 1, 2, 3, 4]` | `10` |

Значение, возвращённое методом `reduceRight()` будет равным последнему результату выполнения колбэк-функции — `10`.

Если же вы зададите начальное значение `initialValue`, результат будет выглядеть так:

```js
[0, 1, 2, 3, 4].reduceRight(function (
  previousValue,
 currentValue,
 index,
 array,
) {
  return previousValue + currentValue;
}, 10);
```

|  | `previousValue` | `currentValue` | `index` | `array` | возвращаемое значение |
| --- | --- | --- | --- | --- | --- |
| первый вызов | `10` | `4` | `4` | `[0, 1, 2, 3, 4]` | `14` |
| второй вызов | `14` | `3` | `3` | `[0, 1, 2, 3, 4]` | `17` |
| третий вызов | `17` | `2` | `2` | `[0, 1, 2, 3, 4]` | `19` |
| четвёртый вызов | `19` | `1` | `1` | `[0, 1, 2, 3, 4]` | `20` |
| пятый вызов | `20` | `0` | `0` | `[0, 1, 2, 3, 4]` | `20` |

Значение, возвращённое методом `reduceRight()` на этот раз, конечно же, будет равным `20`.

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

### Пример: суммирование всех значений в массиве

```js
var total = [0, 1, 2, 3].reduceRight(function (a, b) {
  return a + b;
});
// total == 6
```

### Пример: разворачивание массива массивов

```js
var flattened = [
  [0, 1],
  [2, 3],
  [4, 5],
].reduceRight(function (a, b) {
  return a.concat(b);
}, []);
// flattened равен [4, 5, 2, 3, 0, 1]
```

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

Метод `Array.prototype.reduceRight()` был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать `reduceRight()` в реализациях, которые не поддерживают этот метод.

```js
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.22
// Ссылка (en): http://es5.github.io/#x15.4.4.22
// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.22
if ("function" !== typeof Array.prototype.reduceRight) {
  Array.prototype.reduceRight = function (callback /\*, initialValue\*/) {
    "use strict";
    if (null === this || "undefined" === typeof this) {
      throw new TypeError("Array.prototype.reduce called on null or undefined");
    }
    if ("function" !== typeof callback) {
      throw new TypeError(callback + " is not a function");
    }
    var t = Object(this),
      len = t.length >>> 0,
      k = len - 1,
      value;
    if (arguments.length >= 2) {
      value = arguments[1];
    } else {
      while (k >= 0 && (!k) in t) {
        k--;
      }
      if (k < 0) {
        throw new TypeError("Reduce of empty array with no initial value");
      }
      value = t[k--];
    }
    for (; k >= 0; k--) {
      if (k in t) {
        value = callback(value, t[k], k, t);
      }
    }
    return value;
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.reduceright |

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

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

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

* `Array.prototype.reduce()`


Array.isArray() - JavaScript

Array.isArray()
===============

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

Метод **`Array.isArray()`** возвращает `true`, если объект является массивом и `false`, если он массивом не является.

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

Array.isArray(obj)
```

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

`obj`

Объект для проверки.

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

`true` если объект является `Array`; иначе, `false`.

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

За подробностям обращайтесь к статье «Абсолютно точное определение того, является ли JavaScript-объект массивом или нет».

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

```js
// Все следующие вызовы вернут true
Array.isArray([]);
Array.isArray([1]);
Array.isArray(new Array());
// Малоизвестный факт: Array.prototype сам является массивом:
Array.isArray(Array.prototype);

// Все следующие вызовы вернут false
Array.isArray();
Array.isArray({});
Array.isArray(null);
Array.isArray(undefined);
Array.isArray(17);
Array.isArray("Array");
Array.isArray(true);
Array.isArray(false);
Array.isArray({ \_\_proto\_\_: Array.prototype });
```

### `instanceof` vs `isArray`

Когда проверяем экземпляр `Array`, `Array.isArray` предпочтительней, чем `instanceof`, потому что он работает и с `iframes`.

```js
var iframe = document.createElement("iframe");
document.body.appendChild(iframe);
xArray = window.frames[window.frames.length - 1].Array;
var arr = new xArray(1, 2, 3); // [1,2,3]

// Correctly checking for Array
Array.isArray(arr); // true
// Considered harmful, because doesn't work through iframes
arr instanceof Array; // false
```

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

Выполнение следующего кода перед любым другим кодом создаст метод `Array.isArray()`, если он ещё не реализован в браузере.

```js
if (!Array.isArray) {
  Array.isArray = function (arg) {
    return Object.prototype.toString.call(arg) === "[object Array]";
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.isarray |

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

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

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

* `Array`


Array.prototype.entries() - JavaScript

Array.prototype.entries()
=========================

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

Метод **`entries()`** возвращает новый объект итератора массива **`Array Iterator`**, содержащий пары ключ / значение для каждого индекса в массиве.

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

arr.entries()
```

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

```js
var arr = ["a", "b", "c"];
var eArr = arr.entries();

console.log(eArr.next().value); // [0, 'a']
console.log(eArr.next().value); // [1, 'b']
console.log(eArr.next().value); // [2, 'c']
```

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

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

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

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

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

* `Array.prototype.keys()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`


Array.prototype.pop() - JavaScript

Array.prototype.pop()
=====================

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

Метод **`pop()`** удаляет **последний** элемент из массива и возвращает его значение.

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

arr.pop()
```

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

Последний элемент массива или `undefined`, если массив пуст.

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

Метод `pop` удаляет последний элемент из массива и возвращает удалённое значение.

Метод `pop` не является привязанным к типу; этот метод может быть вызван или применён к массивоподобным объектам. Объекты, не содержащие свойство `length`, отражающее последний элемент в серии последовательных числовых, начинающихся с нуля, свойств, могут повести себя неправильным образом.

Если вы вызовете `pop()` на пустом массиве, он вернёт значение `undefined`.

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

### Удаление последнего элемента массива

Следующий код создаёт массив `myFish`, содержащий четыре элемента, а затем удаляет последний элемент.

```js
var myFish = ["ангел", "клоун", "мандарин", "хирург"];

console.log(myFish); // ['ангел', 'клоун', 'мандарин', 'хирург']

var popped = myFish.pop();

console.log(myFish); // ['ангел', 'клоун', 'мандарин']

console.log(popped); // 'хирург'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.pop |

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

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

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

* `Array.prototype.push()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.splice()`


Atomics.sub() - JavaScript

Atomics.sub()
=============

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

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

Atomics.sub(typedArray, index, value)
```

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

`typedArray`

Разделённый массив целых чисел. `Int8Array`, `Uint8Array` (en-US), `Int16Array` (en-US), `Uint16Array` (en-US), `Int32Array` или `Uint32Array` (en-US).

`index`

Позиция в `typedArray` для добавления `value`.

`value`

Число для вычитания.

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

Предыдущее значение в указанной позиции (`typedArray[index]`).

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

* Выбрасывает `TypeError`, если тип `typedArray` не является одним из допустимых целочисленных типов.
* Выбрасывает `TypeError`, если тип `typedArray` не общего типа.
* Выбрасывает `RangeError`, если `index` вне `typedArray`.
Примеры
-------

```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);
ta[0] = 48;

Atomics.sub(ta, 0, 12); // возвращает 48, предыдущее значение
Atomics.load(ta, 0); // 36
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.sub |

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

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

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

* `Atomics`
* `Atomics.add()`


Atomics.add() - JavaScript

Atomics.add()
=============

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

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

Atomics.add(typedArray, index, value)
```

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

`typedArray`

Разделённый массив целых чисел. `Int8Array`, `Uint8Array` (en-US), `Int16Array` (en-US), `Uint16Array` (en-US), `Int32Array` или `Uint32Array` (en-US).

`index`

Позиция в `typedArray` для добавления `value`.

`value`

Число для добавления.

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

Предыдущее значение в указанной позиции (`typedArray[index]`).

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

* Выбрасывает `TypeError`, если тип `typedArray` не является одним из допустимых целочисленных типов.
* Выбрасывает `TypeError`, если тип `typedArray` не общего типа.
* Выбрасывает `RangeError`, если `index` вне `typedArray`.
Примеры
-------

```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);

Atomics.add(ta, 0, 12); // возвращает 0, предыдущее значение
Atomics.load(ta, 0); // 12
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.add |

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

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

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

* `Atomics`
* `Atomics.sub()`


TypedArray.prototype.join() - JavaScript

TypedArray.prototype.join()
===========================

Метод **`join()`** объединяет все элементы массива в строку. Метод работает по тому же алгоритму, что и `Array.prototype.join()`. *TypedArray* это один из типизированных массивов: типы массивов.

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

typedarray.join([separator = ',']);
```

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

`разделитель`

Необязательный параметр. Определяет строку, разделяющую элементы массива. Разделитель приводится к строке в случае необходимости. Если он опущен, элементы массива разделяются запятой (",").

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

Строка, соединяющая все элементы массива.

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

```js
var uint8 = new Uint8Array([1, 2, 3]);
uint8.join(); // '1,2,3'
uint8.join(" / "); // '1 / 2 / 3'
uint8.join(""); // '123'
```

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

Поскольку теперь нет глобального объекта с именем *TypedArray*, то полифилинг должен быть выполнен "по требованию".

```js
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.join
if (!Uint8Array.prototype.join) {
  Object.defineProperty(Uint8Array.prototype, "join", {
    value: Array.prototype.join,
  });
}
```

Если вам нужна поддержка устаревшего JavaScript-движка, который не поддерживает свойство `Object.defineProperty`, то лучше не создавать полифилы новых методов `Array.prototype`, так как вы не сможете сделать их неперечислимыми.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.join |

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

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

See also
--------

* `TypedArray`
* `Array.prototype.join()`


get TypedArray[@@species] - JavaScript

get TypedArray[@@species]
=========================

**`TypedArray[@@species]`** - это способ доступа, с помощью которого можно получить конструктор типизированного массива.

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

TypedArray[Symbol.species]

где TypedArray это один из:

Int8Array
Uint8Array
Uint8ClampedArray
Int16Array
Uint16Array
Int32Array
Uint32Array
Float32Array
Float64Array
```

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

Свойство **`species`** возвращает конструктор "по умолчанию" для объектов типизированного массива. Конструкторы подкласса могут его переопределить.

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

Свойство **`species`** возвращает функцию-конструктор "по умолчанию", которая является одним из конструкторов данного типизированного массива:

```js
Int8Array[Symbol.species]; // function Int8Array()
Uint8Array[Symbol.species]; // function Uint8Array()
Float32Array[Symbol.species]; // function Float32Array()
```

В производном объекте-массиве (например, вы разработали свой массив `MyTypedArray`), `MyTypedArray` определяет свой конструктор. Однако, вы можете захотеть его переопределить, например, возвращать родительский объект из вашего производного класса:

```js
class MyTypedArray extends Uint8Array {
  //Переопределение вида MyTypedArray на родительский Uint8Array
  static get [Symbol.species]() {
    return Uint8Array;
  }
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%-@@species |

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

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

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

* `TypedArray`
* `Symbol.species`


TypedArray.BYTES_PER_ELEMENT - JavaScript

TypedArray.BYTES\_PER\_ELEMENT
==============================

Свойство **`TypedArray.BYTES_PER_ELEMENT`** содержит размер в байтах каждого элемента типизированного массива.

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

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

TypedArray.BYTES_PER_ELEMENT;
```

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

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

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

```js
Int8Array.BYTES\_PER\_ELEMENT; // 1
Uint8Array.BYTES\_PER\_ELEMENT; // 1
Uint8ClampedArray.BYTES\_PER\_ELEMENT; // 1
Int16Array.BYTES\_PER\_ELEMENT; // 2
Uint16Array.BYTES\_PER\_ELEMENT; // 2
Int32Array.BYTES\_PER\_ELEMENT; // 4
Uint32Array.BYTES\_PER\_ELEMENT; // 4
Float32Array.BYTES\_PER\_ELEMENT; // 4
Float64Array.BYTES\_PER\_ELEMENT; // 8
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray.bytes\_per\_element |

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

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

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

* JavaScript typed arrays
* `TypedArray`


TypedArray.prototype.set() - JavaScript

TypedArray.prototype.set()
==========================

Метод **`set()`** сохраняет значения в типизированном массиве, читая значения из предоставленного массива.

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

typedarr.set(array [,offset])
typedarr.set(typedarray [,offset])
```

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

array

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

typedarray

Если исходный массив является типизированным массивом, то оба массива могут ссылаться на один и тот же `ArrayBuffer`, т.е. быть разными представлениями (view) одного и того же ArrayBuffer; браузер **скопирует** исходный диапазон буфера в диапазон назначения даже в случае перекрытия диапазонов.

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

Сдвиг для текущего массива, с которого будет производиться запись исходного массива. Если значение опущено, то используется 0 (в таких ситуациях, исходный массив перезапишет значения в текущем массиве начиная с индекса 0).

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

`undefined`.

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

`RangeError`

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

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

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

```js
var buffer = new ArrayBuffer(8);
var uint8 = new Uint8Array(buffer);

uint8.set([1, 2, 3], 3);

console.log(uint8); // Uint8Array [ 0, 0, 0, 1, 2, 3, 0, 0 ]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.set |

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

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

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

* JavaScript typed arrays
* `TypedArray`
* `ArrayBuffer`


Error.prototype.stack - JavaScript

Error.prototype.stack
=====================

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

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

Нестандартное свойство **`stack`** объекта `Error` возвращает трассировку стека вызываемых функций в порядке их выполнения, вместе с номерами строк, именами файлов и аргументами. Строка со стеком заполняется от самых недавних вызовов до вызова из глобальной области видимости.

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

Каждый шаг находится на отдельной строке; первая часть строки содержит имя функции (если это не вызов из глобальной области видимости), затем знак собаки (`@`), местоположение файла (кроме случая, когда функция является конструктором ошибки, которую она выбрасывает), двоеточие и, если есть местоположение файла, номер строки. Обратите внимание, что объект `Error` также обладает свойствами `fileName`, `lineNumber` и `columnNumber`, позволяющими извлечь имя файла, номер строки и столбца из выброшенной ошибки (но только самой ошибки, а не всего стека вызовов).

Обратите внимание, что такой формат используется в Firefox. Нет никакого «стандартного формата». Однако, Safari 6+ и Opera 12- используют очень похожий формат. С другой стороны, браузеры, использующие движок JavaScript V8 (например, Chrome, Opera 15+, Браузер Android) и IE10+, используют другой формат (смотрите эту статью по `error.stack` в MSDN).

**Значения аргументов в стеке**: до Firefox 14 (Firefox bug 744842) за именем функции и прямо перед знаком собаки (`@`) в круглых скобках следовали значения аргументов, преобразованные в строки. Хотя объекты (или массивы и прочее) преобразовывались в форму `"[object Object]"`, и, таким образом, невозможно было узнать их содержимое, скалярные значения могли быть извлечены (это всё ещё можно использовать в Firefox 14 — однако проще для получения аргументов использовать `arguments.callee.caller.arguments`, а для получения имени функции — `arguments.callee.caller.name`). Значение `"undefined"` показывалось как `"(void 0)"`. Обратите внимание, что если строковые аргументы содержали значения, включающие символы `"@"`, `"("`, `")"` (или если они включали имена файлов), вам не так то просто было разбить строку на составные части. Таким образом, в Firefox 14 и более поздних версиях это перестало быть проблемой.

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

Следующая разметка HTML демонстрирует использование свойства `stack`.

```html
<!doctype html>
<meta charset="UTF-8" />
<title>Пример трассировки стека</title>
<body>
  <script>
 function trace() {
 try {
 throw new Error("Моя ошибка");
 } catch (e) {
 alert(e.stack);
 }
 }
 function b() {
 trace();
 }
 function a() {
 b(3, 4, "\n\n", undefined, {});
 }
 a("первый вызов, первый аргумент");
 </script>
</body>
```

Предполагается, что разметка выше сохранена как `C:\example.html` в файловой системе Windows. Она выводит следующий текст в диалоговом окне:

Начиная с Firefox 30 и более поздних версий, вывод содержит номер колонки (Firefox bug 762556):
```

trace@file:///C:/example.html:9:17
b@file:///C:/example.html:16:13
a@file:///C:/example.html:19:13
@file:///C:/example.html:21:9
```

с Firefox 14 по Firefox 29:
```

trace@file:///C:/example.html:9
b@file:///C:/example.html:16
a@file:///C:/example.html:19
@file:///C:/example.html:21
```

Firefox 13 и более ранние версии выводят следующий текст:
```

Error("Моя ошибка")@:0
trace()@file:///C:/example.html:9
b(3,4,"\n\n",(void 0),[object Object])@file:///C:/example.html:16
a("первый вызов, первый аргумент")@file:///C:/example.html:19
@file:///C:/example.html:21
```

### Стек кода в функции `eval()`

Начиная с Firefox 30, стек вызовов кода в вызовах `Function()` и `eval()` даёт более подробную информацию о номере строки и колонки внутри этих вызовов. Вызовы `Function` обозначаются `"> Function"`, а вызовы `eval()` обозначаются `"> eval"`. Смотрите Firefox bug 332176.

```js
try {
  new Function("throw new Error()")();
} catch (e) {
  console.log(e.stack);
}

// anonymous@file:///C:/example.html line 7 > Function:1:1
// @file:///C:/example.html:7:6

try {
  eval("eval('FAIL')");
} catch (x) {
  console.log(x.stack);
}

// @file:///C:/example.html line 7 > eval line 1 > eval:1:1
// @file:///C:/example.html line 7 > eval:1:1
// @file:///C:/example.html:7:6
```

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

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

Не является частью какой-либо спецификации. Не стандартно.

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

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

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

* Components.stack
* Внешние проекты: TraceKit и javascript-stacktrace
* MSDN: документация по error.stack
* Обзор API трассировки стека в движке JavaScript V8


Error.prototype.fileName - JavaScript

Error.prototype.fileName
========================

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

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

Свойство **`fileName`** содержит путь к файлу, в котором возникла эта ошибка.

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

Это нестандартное свойство содержит путь к файлу, в котором возникла эта ошибка. Если доступ к нему получен в контексте отладчика, например, Инструментов разработчика Firefox, вернётся строка «debugger eval code».

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

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

```js
var e = new Error("Невозможно разобрать входные данные");
throw e;
// e.fileName может выглядеть так "file:///C:/example.html"
```

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

Не является частью какой-либо спецификации. Не стандартно.

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

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

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

* `Error.prototype.stack`
Non-standard
* `Error.prototype.columnNumber`
Non-standard
* `Error.prototype.lineNumber`
Non-standard


Error.prototype.toString() - JavaScript

Error.prototype.toString()
==========================

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

Метод **`toString()`** возвращает строку, представляющую указанный объект `Error`.

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

e.toString()
```

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

Объект `Error` переопределяет метод `Object.prototype.toString()`, унаследованный всеми объектами. Его семантика следующая (предполагается, что объекты `Object` и `String` имеют свои изначальные значения):

```js
Error.prototype.toString = function () {
  "use strict";

  var obj = Object(this);
  if (obj !== this) {
    throw new TypeError();
  }

  var name = this.name;
  name = name === undefined ? "Error" : String(name);

  var msg = this.message;
  msg = msg === undefined ? "" : String(msg);

  if (name === "") {
    return msg;
  }
  if (msg === "") {
    return name;
  }

  return name + ": " + msg;
};
```

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

```js
var e = new Error("непоправимая ошибка");
print(e.toString()); // 'Error: непоправимая ошибка'

e.name = undefined;
print(e.toString()); // 'Error: непоправимая ошибка'

e.name = "";
print(e.toString()); // 'непоправимая ошибка'

e.message = undefined;
print(e.toString()); // 'Error'

e.name = "привет";
print(e.toString()); // 'привет'
```

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

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

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

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

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

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


Error.prototype.name - JavaScript

Error.prototype.name
====================

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

Свойство **`name`** представляет имя типа ошибки. Начальное значение равно строке `"Error"`.

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

По умолчанию, экземпляры `Error` имеют имя `"Error"`. Свойство `name`, вместе со свойством `message`, используется методом `Error.prototype.toString()` для создания строкового представления ошибки.

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

### Пример: выбрасывание собственной ошибки

```js
var e = new Error("Неверные входные данные"); // e.name равно 'Error'

e.name = "ParseError";
throw e;
// e.toString() вернёт 'ParseError: Неверные входные данные'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-error.prototype.name |

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

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

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

* `Error.prototype.message`
* `Error.prototype.toString()`


Error.prototype.lineNumber - JavaScript

Error.prototype.lineNumber
==========================

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

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

Свойство **`lineNumber`** содержит номер строки в файле, в котором возникла эта ошибка.

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

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

```js
var e = new Error("Невозможно разобрать входные данные");
throw e;
console.log(e.lineNumber); // 2
```

### Пример: альтернативный пример с использованием события `error`

```js
window.addEventListener("error", function (e) {
  console.log(e.lineno); // 5
});
var e = new Error("Невозможно разобрать входные данные");
throw e;
```

Это стандарт и он поддерживается в Chrome, Firefox и, вероятно, много где ещё.

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

Не является частью какой-либо спецификации. Не стандартно.

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

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

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

* `Error.prototype.stack`
Non-standard
* `Error.prototype.columnNumber`
Non-standard
* `Error.prototype.fileName`
Non-standard


Error.prototype.message - JavaScript

Error.prototype.message
=======================

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

Свойство **`message`** представляет человеко-читаемое описание ошибки.

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

Это свойство содержит краткое описание ошибки, если оно доступно или было установлено. SpiderMonkey широко использует свойство `message` для исключений. Свойство `message` в сочетании со свойством `name` используется методом `Error.prototype.toString()` для создания строкового представления ошибки.

По умолчанию, свойство `message` является пустой строкой, но это поведение может быть переопределено для экземпляра путём указания сообщения первым аргументом в конструкторе объекта `Error`.

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

### Пример: выбрасывание собственной ошибки

```js
var e = new Error("Невозможно разобрать входные данные");
// e.message равно 'Невозможно разобрать входные данные'
throw e;
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-error.prototype.message |

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

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

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

* `Error.prototype.name`
* `Error.prototype.toString()`


Error.prototype.columnNumber - JavaScript

Error.prototype.columnNumber
============================

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

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

Свойство **`columnNumber`** содержит номер колонки в строке файла, в котором возникла эта ошибка.

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

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

```js
var e = new Error("Невозможно разобрать входные данные");
throw e;
console.log(e.columnNumber); // 0
```

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

Не является частью какой-либо спецификации. Не стандартно.

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

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

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

* `Error.prototype.stack`
Non-standard
* `Error.prototype.lineNumber`
Non-standard
* `Error.prototype.fileName`
Non-standard


Math.ceil() - JavaScript

Math.ceil()
===========

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

Метод **`Math.ceil()`** - округление вверх. Округляет аргумент до ближайшего большего целого.

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

Math.ceil(x)
```

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

`x`

Число.

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

Поскольку метод `ceil()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.ceil()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

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

### Пример: использование метода `Math.ceil()`

Следующий пример показывает использование метода `Math.ceil()`.
```

Math.ceil(.95);    // 1
Math.ceil(4);      // 4
Math.ceil(7.004);  // 8
Math.ceil(-0.95);  // -0
Math.ceil(-4);     // -4
Math.ceil(-7.004); // -7
```

### Decimal adjustment

### Пример: корректировка округления десятичных дробей

```js
// Замыкание
(function () {
  /\*\*
 \* Корректировка округления десятичных дробей.
 \*
 \* @param {String} type Тип корректировки.
 \* @param {Number} value Число.
 \* @param {Integer} exp Показатель степени (десятичный логарифм основания корректировки).
 \* @returns {Number} Скорректированное значение.
 \*/
  function decimalAdjust(type, value, exp) {
    // Если степень не определена, либо равна нулю...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // Если значение не является числом, либо степень не является целым числом...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Сдвиг разрядов
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Обратный сдвиг
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Десятичное округление к ближайшему
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Десятичное округление вниз
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Десятичное округление вверх
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Округление к ближайшему
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Округление вниз
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Округление вверх
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ceil |

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

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

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

* `Math.abs()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
Экспериментальная возможность
* `Math.trunc()`
Экспериментальная возможность


Math.trunc() - JavaScript

Math.trunc()
============

Функция **`Math.trunc()`** возвращает целую часть числа путём удаления всех дробных знаков.

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

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

Math.trunc(x)
```

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

`x`

Число.

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

`x`

Целая часть данного числа.

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

В отличие от других трёх методов объекта `Math` — `Math.floor()`, `Math.ceil()` и `Math.round()` — метод `Math.trunc()` работает очень просто. Отбрасывается запятая и все цифры после неё, не обращая внимания на знак аргумента.

Аргумент, переданный в этот метод, будет неявно преобразован в число.

Поскольку `trunc()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.trunc()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` ( `Math` не является конструктором).

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

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

```js
Math.trunc(13.37); // 13
Math.trunc(42.84); // 42
Math.trunc(0.123); // 0
Math.trunc(-0.123); // -0
Math.trunc("-1.123"); // -1
Math.trunc(NaN); // NaN
Math.trunc("foo"); // NaN
Math.trunc(); // NaN
```

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

```js
if (!Math.trunc) {
  Math.trunc = function (v) {
    v = +v;
    if (!isFinite(v)) return v;

    return v - (v % 1) || (v < 0 ? -0 : v === 0 ? v : 0);

    // returns:
    // 0 -> 0
    // -0 -> -0
    // 0.2 -> 0
    // -0.2 -> -0
    // 0.7 -> 0
    // -0.7 -> -0
    // Infinity -> Infinity
    // -Infinity -> -Infinity
    // NaN -> NaN
    // null -> 0
  };
}
```

Либо:

```js
if (!Math.trunc) {
  Math.trunc = function (v) {
    v = +v;
    return v - (v % 1) || (!isFinite(v) || v === 0 ? v : v < 0 ? -0 : 0);
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.trunc |

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

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

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

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`


Math.tanh() - JavaScript

Math.tanh()
===========

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

Метод **`Math.tanh()`** возвращает гиперболический тангенс числа, то есть

tanh
x
=

sinh
x

cosh
x

=

e
x

-

e

-
x

e
x

+

e

-
x

=

e

2
x

-
1

e

2
x

+
1

\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}

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

Math.tanh(x)
```

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

`x`

Число.

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

Поскольку метод `tanh()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.tanh()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

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

### Пример: использование метода `Math.tanh()`

```js
Math.tanh(0); // 0
Math.tanh(Infinity); // 1
Math.tanh(1); // 0.7615941559557649
```

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

Этот метод может эмулироваться при помощи двух вызовов метода `Math.exp()`:

```js
Math.tanh =
  Math.tanh ||
  function (x) {
    if (x === Infinity) {
      return 1;
    } else if (x === -Infinity) {
      return -1;
    } else {
      return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x));
    }
  };
```

либо при помощи только одного вызова метода `Math.exp()`:

```js
Math.tanh =
  Math.tanh ||
  function (x) {
    if (x === Infinity) {
      return 1;
    } else if (x === -Infinity) {
      return -1;
    } else {
      var y = Math.exp(2 \* x);
      return (y - 1) / (y + 1);
    }
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.tanh |

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

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

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

* `Math.acosh()`
Экспериментальная возможность
* `Math.asinh()`
Экспериментальная возможность
* `Math.atanh()`
Экспериментальная возможность
* `Math.cosh()`
Экспериментальная возможность
* `Math.sinh()`
Экспериментальная возможность


Math.cos() - JavaScript

Math.cos()
==========

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

Метод **`Math.cos()`** возвращает косинус числа.

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

Math.cos(x)
```

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

`x`

Число радиан.

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

Метод `Math.cos()` возвращает числовое значение от -1 до 1, которое представляет косинус угла.

Поскольку метод `cos()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.cos()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

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

### Пример: использование метода `Math.cos()`

```js
Math.cos(0); // 1
Math.cos(1); // 0.5403023058681398

Math.cos(Math.PI); // -1
Math.cos(2 \* Math.PI); // 1
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cos |

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

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

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

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.sin()`
* `Math.tan()`


Math.clz32() - JavaScript

Math.clz32()
============

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

Метод **`Math.clz32()`** возвращает количество ведущих нулевых битов в 32-битном двоичном представлении числа.

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

Math.clz32(x)
```

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

`x`

Число.

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

Название `clz32` является сокращением для более длинного `CountLeadingZeroes32` (`ПосчтитатьВедущиеНули32`).

Если значение `x` не является числом, оно будет сначала преобразовано в число, а потом в 32-битное беззнаковое целое число.

Если преобразованное 32-битное беззнаковое целое число равно `0`, метод вернёт `32`, поскольку все биты в числе равны `0`.

Этот метод особенно полезен для систем, которые компилируются в JS, например, для Emscripten.

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

### Пример: использование метода `Math.clz32()`

```js
Math.clz32(1); // 31
Math.clz32(1000); // 22
Math.clz32(); // 32

[NaN, Infinity, -Infinity, 0, -0, null, undefined, "foo", {}, []].filter(
  function (n) {
    return Math.clz32(n) !== 32;
  },
); // []

Math.clz32(true); // 31
Math.clz32(3.5); // 30
```

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

```js
Math.clz32 =
  Math.clz32 ||
  function (value) {
    value = Number(value) >>> 0;
    return value !== 0
      ? 31 - Math.floor(Math.log(value + 0.5) / Math.log(2))
      : 32;
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.clz32 |

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

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

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

* `Math`


Math.atan2() - JavaScript

Math.atan2()
============

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

Метод **`Math.atan2()`** возвращает арктангенс от частного своих аргументов.

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

Math.atan2(y, x)
```

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

`y`

Первое число.

`x`

Второе число.

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

Метод `Math.atan2()` возвращает числовое значение от -π до π, представляющее угол тета точки `(x, y)`. Это выраженный в радианах угол, отсчитываемый против часовой стрелки от положительного направления оси X до точки `(x, y)`. Обратите внимание, что первым в метод передаётся координата y, а только вторым — координата x.

В метод `Math.atan2()` аргументы `x` и `y` передаются по отдельности, в то время, как в метод `Math.atan()` передаётся отношение этих двух аргументов.

Поскольку метод `atan2()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.atan2()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

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

### Пример: использование метода `Math.atan2()`

```js
Math.atan2(90, 15); // 1.4056476493802699
Math.atan2(15, 90); // 0.16514867741462683

Math.atan2(±0, -0);               // ±PI.
Math.atan2(±0, +0);               // ±0.
Math.atan2(±0, -x);               // ±PI для x > 0.
Math.atan2(±0, x);                // ±0 для x > 0.
Math.atan2(-y, ±0);               // -PI/2 для y > 0.
Math.atan2(y, ±0);                // PI/2 для y > 0.
Math.atan2(±y, -Infinity);        // ±PI для конечного y > 0.
Math.atan2(±y, +Infinity);        // ±0 для конечного y > 0.
Math.atan2(±Infinity, x);         // ±PI/2 для конечного x.
Math.atan2(±Infinity, -Infinity); // ±3\*PI/4.
Math.atan2(±Infinity, +Infinity); // ±PI/4.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atan2 |

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

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

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

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`


Math.abs() - JavaScript

Math.abs()
==========

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

Метод **`Math.abs()`** возвращает абсолютное значение числа. то есть

Math.abs
(
x
)

=

|
x
|

=

{

x

if

x
≥
0

-
x

if

x
<
0

{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{if} \quad x \geq 0 \ x & \text{if} \quad x < 0 \end{cases}

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

Math.abs(x)
```

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

`x`

Число.

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

Поскольку метод `abs()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.abs()`, а не пытаться вызывать метод на созданном объекте `Math` (поскольку объект `Math` не является конструктором).

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

### Пример: поведение метода `Math.abs()`

Метод вернёт `NaN`, если в него передать нечисловую строку или значение `undefined`/ничего не передавать. Метод вернёт 0, если в него передать значение `null`.

```js
Math.abs("-1"); // 1
Math.abs(-2); // 2
Math.abs(null); // 0
Math.abs(""); // 0
Math.abs([]); // 0
Math.abs([2]); // 2
Math.abs([1, 2]); // NaN
Math.abs({}); // NaN
Math.abs("string"); // NaN
Math.abs(); // NaN
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.abs |

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

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

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

* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`


Math.sinh() - JavaScript

Math.sinh()
===========

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

Метод **`Math.sinh()`** возвращает гиперболический синус числа, который может быть выражен через число e:

Math.sinh(x)

=

e
x

-

e

-
x

2

\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}

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

Math.sinh(x)
```

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

`x`

Число.

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

Поскольку метод `sinh()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.sinh()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

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

### Пример: использование метода `Math.sinh()`

```js
Math.sinh(0); // 0
Math.sinh(1); // 1.1752011936438014
```

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

Этот метод может эмулироваться при помощи двух вызовов метода `Math.exp()`:

```js
Math.sinh =
  Math.sinh ||
  function (x) {
    return (Math.exp(x) - Math.exp(-x)) / 2;
  };
```

либо при помощи только одного вызова метода `Math.exp()`:

```js
Math.sinh =
  Math.sinh ||
  function (x) {
    var y = Math.exp(x);
    return (y - 1 / y) / 2;
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sinh |

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

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

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

* `Math.acosh()`
Экспериментальная возможность
* `Math.asinh()`
Экспериментальная возможность
* `Math.atanh()`
Экспериментальная возможность
* `Math.cosh()`
Экспериментальная возможность
* `Math.tanh()`
Экспериментальная возможность


Math.min() - JavaScript

Math.min()
==========

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

Метод **`Math.min()`** возвращает наименьшее из нуля или более чисел.

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

Math.min([value1[, value2[, ...]]])
```

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

`value1, value2, ...`

Числа.

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

Поскольку метод `min()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.min()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

При вызове без аргументов результатом вызова будет значение `Infinity`.

Если хотя бы один из аргументов не может быть преобразован в число, результатом будет `NaN`.

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

### Пример: использование метода `Math.min()`

В этом примере ищется минимум из `x` и `y` и присваивается переменной `z`:

```js
var x = 10,
  y = -20;
var z = Math.min(x, y);
```

### Пример: обрезание значения при помощи метода `Math.min()`

Метод `Math.min()` часто используется для обрезания значения таким образом, чтобы оно всегда не превосходило некоторую границу. Например, такое условие

```js
var x = f(foo);

if (x > boundary) {
  x = boundary;
}
```

может быть переписано в виде

```js
var x = Math.min(f(foo), boundary);
```

Подобным образом может использоваться и метод `Math.max()` для обрезания значения по нижней границе.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.min |

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

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

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

* `Math.max()`