WeakMap.prototype.has() - JavaScript

WeakMap.prototype.has()
=======================

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

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

wm.has(key);
```

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

key

Обязателен. Ключ элемента, существование которого необходимо проверить в объекте WeakMap.

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

Boolean

Возвращает `true` если элемент с указанным ключом существует в объекте WeakMap, если нет — false.

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

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

```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.has(window); // возвращает true
wm.has("baz"); // возвращает false
```

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

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

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

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

Firefox-specific notes
----------------------

* Prior to SpiderMonkey 38, this method threw a `TypeError` when the `key` parameter was not an object. This has been fixed in version 38 and later to return `false` as per latest ES6 standard (Firefox bug 1127827).
See also
--------

* `WeakMap`
* `WeakMap.prototype.set()`
* `WeakMap.prototype.get()`


WeakMap.prototype.get() - JavaScript

WeakMap.prototype.get()
=======================

Метод **`get()`** возвращает элемент из объекта WeakMap,

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

wm.get(key);
```

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

key

Обязателен. Ключ элемента, который будет возвращён из объекта WeakMap.

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

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

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

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

```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.get(window); // Возвращает "foo".
wm.get("baz"); // Возвращает undefined.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.get |

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

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

Firefox-specific notes
----------------------

* Prior to SpiderMonkey 38, this method threw a `TypeError` when the key parameter was not an object. However, the latest ES6 standard specifies to return `undefined` instead. Furthermore, `WeakMap.prototype.get` accepted an optional second argument as a fallback value, which is not part of the standard. Both non-standard behaviors are removed in version 38 and higher (Firefox bug 1127827).
Смотрите также
--------------

* `WeakMap`
* `WeakMap.set()`
* `WeakMap.has()`


WeakMap.prototype.delete() - JavaScript

WeakMap.prototype.delete()
==========================

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

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

wm.delete(key);
```

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

key

Обязателен. Ключ элемента, который будет уделён из объекта WeakMap.

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

Возвращает true если элемент из объекта WeakMap удалён успешно.

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

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

```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.delete(window); // Возвращает true. Успешно удалён.

wm.has(window); // Возвращает false. Объекта window больше нет в WeakMap.
```

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

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

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

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

Firefox-specific notes
----------------------

* Prior to SpiderMonkey 38, this method threw a `TypeError` when the `key` parameter was not an object. This has been fixed in version 38 and later to return `false` as per latest ES6 standard (Firefox bug 1127827).
Смотрите также
--------------

* `WeakMap`


WeakMap.prototype.set() - JavaScript

WeakMap.prototype.set()
=======================

Метод **`set()`** добавляет новый элемент с указанными ключом и значением в объект WeakMap.

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

wm.set(key, value);
```

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

key

Обязателен. Ключ добавляемого в WeakMap объект элемента.

value

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

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

Объект `WeakMap.`

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

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

```js
var wm = new WeakMap();
var obj = {};

// Добавляет новый элемент в объект WeakMap
wm.set(obj, "foo").set(window, "bar"); // chainable

// Обновляет элемент в объекте WeakMap
wm.set(obj, "baz");
```

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

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

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

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

Firefox-specific notes
----------------------

* Prior to Firefox 33, `WeakMap.prototype.set` returned `undefined` and was not chainable. This has been fixed (Firefox bug 1031632). The behavior can be found in Chrome/v8 as well (issue).
Смотрите также
--------------

* `WeakMap`
* `WeakMap.prototype.get()`
* `WeakMap.prototype.has()`


BigInt.asIntN() - JavaScript

BigInt.asIntN()
===============

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

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

* Learn more
* See full compatibility
* Report feedback
**`BigInt.asIntN`** — это статический метод, который позволяет перенести BigInt-значение в целое число со знаком между -2ширина-1 and 2ширина-1-1.

{{EmbedInteractiveExample("pages/js/bigint-asintn.html")}}

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

BigInt.asIntN(width, bigint);
```

### Аргументы

`width`

Количество битов, доступных для целочисленного размера.

`bigint`

Целое число для зажима, чтобы соответствовать поставляемым битам.

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

Значение `bigint` по модулю 2`width` как целое число со знаком.

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

### Пребывание в 64-битных диапазонах

Метод `BigInt.asIntN()` может быть полезен, чтобы оставаться в диапазоне 64-битной арифметики.

```js
const max = 2n \*\* (64n - 1n) - 1n;

BigInt.asIntN(64, max);
// ↪ 9223372036854775807n

BigInt.asIntN(64, max + 1n);
// ↪ -9223372036854775807n
// отрицательное число из-за переполнения
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint.asintn |

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

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

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

* `BigInt`
* `BigInt.asUintN()` (en-US)


Array.prototype.indexOf() - JavaScript

Array.prototype.indexOf()
=========================

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

Метод **`indexOf()`** возвращает первый индекс, по которому данный элемент может быть найден в массиве или -1, если такого индекса нет.

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

arr.indexOf(searchElement[, fromIndex = 0])
```

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

`searchElement`

Искомый элемент в массиве.

`fromIndex`

Индекс, с которого начинать поиск. Если индекс больше или равен длине массива, возвращается -1, что означает, что массив даже не просматривается. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу. Если рассчитанный индекс оказывается меньше 0, поиск ведётся по всему массиву. Значение по умолчанию равно 0, что означает, что просматривается весь массив.

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

Метод `indexOf()` сравнивает искомый элемент `searchElement` с элементами в массиве, используя строгое сравнение (en-US) (тот же метод используется оператором `===`, тройное равно).

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

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

В следующем примере `indexOf()` используется для поиска значений в массиве.

```js
var array = [2, 5, 9];
array.indexOf(2); // 0
array.indexOf(7); // -1
array.indexOf(9, 2); // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0
```

### Пример: нахождение всех вхождений элемента

В следующем примере `indexOf()` используется для поиска всех индексов элемента в указанном массиве, которые с помощью `push()` добавляются в другой массив.

```js
var indices = [];
var array = ["a", "b", "a", "c", "a", "d"];
var element = "a";
var idx = array.indexOf(element);
while (idx != -1) {
  indices.push(idx);
  idx = array.indexOf(element, idx + 1);
}

console.log(indices);
// [0, 2, 4]
```

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

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

```js
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.14
// Ссылка (en): http://es5.github.io/#x15.4.4.14
// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.14
if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function (searchElement, fromIndex) {
    var k;

    // 1. Положим O равным результату вызова ToObject с передачей ему
    // значения this в качестве аргумента.
    if (this == null) {
      throw new TypeError('"this" is null or not defined');
    }

    var O = Object(this);

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

    // 4. Если len равен 0, вернём -1.
    if (len === 0) {
      return -1;
    }

    // 5. Если был передан аргумент fromIndex, положим n равным
    // ToInteger(fromIndex); иначе положим n равным 0.
    var n = +fromIndex || 0;

    if (Math.abs(n) === Infinity) {
      n = 0;
    }

    // 6. Если n >= len, вернём -1.
    if (n >= len) {
      return -1;
    }

    // 7. Если n >= 0, положим k равным n.
    // 8. Иначе, n<0, положим k равным len - abs(n).
    // Если k меньше нуля 0, положим k равным 0.
    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

    // 9. Пока k < len, будем повторять
    while (k < len) {
      // a. Положим Pk равным ToString(k).
      // Это неявное преобразование для левостороннего операнда в операторе in
      // b. Положим kPresent равным результату вызова внутреннего метода
      // HasProperty объекта O с аргументом Pk.
      // Этот шаг может быть объединён с шагом c
      // c. Если kPresent равен true, выполним
      // i. Положим elementK равным результату вызова внутреннего метода Get
      // объекта O с аргументом ToString(k).
      // ii. Положим same равным результату применения
      // Алгоритма строгого сравнения на равенство между
      // searchElement и elementK.
      // iii. Если same равен true, вернём k.
      if (k in O && O[k] === searchElement) {
        return k;
      }
      k++;
    }
    return -1;
  };
}
```

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

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

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

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

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

* `Array.prototype.lastIndexOf()`
* `TypedArray.prototype.indexOf()` (en-US)


Array.prototype.lastIndexOf() - JavaScript

Array.prototype.lastIndexOf()
=============================

Метод **`lastIndexOf()`** возвращает последний индекс, по которому данный элемент может быть найден в массиве или -1, если такого индекса нет. Массив просматривается от конца к началу, начиная с индекса `fromIndex`.

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

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

arr.lastIndexOf(searchElement[, fromIndex = arr.length])
```

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

`searchElement`

Искомый элемент в массиве.

`fromIndex`

Необязательный параметр. Индекс, с которого начинать поиск в обратном направлении. Если индекс больше или равен длине массива, просматривается весь массив. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от конца к началу. Если рассчитанный индекс оказывается меньше 0, массив даже не просматривается. Значение по умолчанию равно длине массива, что означает, что просматривается весь массив.

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

Метод `lastIndexOf()` сравнивает искомый элемент `searchElement` с элементами в массиве, используя строгое сравнение (en-US) (тот же метод используется оператором `===`, тройное равно).

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

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

В следующем примере метод `lastIndexOf()` используется для поиска значений в массиве.

```js
var array = [2, 5, 9, 2];
array.lastIndexOf(2); // 3
array.lastIndexOf(7); // -1
array.lastIndexOf(2, 3); // 3
array.lastIndexOf(2, 2); // 0
array.lastIndexOf(2, -2); // 0
array.lastIndexOf(2, -1); // 3
```

### Пример: нахождение всех вхождений элемента

В следующем примере метод `lastIndexOf()` используется для поиска всех индексов элемента в указанном массиве, которые с помощью метода `push()` добавляются в другой массив.

```js
var indices = [];
var array = ["a", "b", "a", "c", "a", "d"];
var element = "a";
var idx = array.lastIndexOf(element);
while (idx != -1) {
  indices.push(idx);
  idx = idx > 0 ? array.lastIndexOf(element, idx - 1) : -1;
}

console.log(indices);
// [4, 2, 0]
```

Обратите внимание, что мы обрабатываем случай `idx == 0` отдельно, поскольку элемент всегда будет найден, независимо от параметра `fromIndex`, если он является первым элементом в массиве. Этим он отличается от метода `indexOf()`.

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

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

```js
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.15
// Ссылка (en): http://es5.github.io/#x15.4.4.15
// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.15
if (!Array.prototype.lastIndexOf) {
  Array.prototype.lastIndexOf = function (searchElement /\*, fromIndex\*/) {
    "use strict";

    if (this === void 0 || this === null) {
      throw new TypeError();
    }

    var n,
      k,
      t = Object(this),
      len = t.length >>> 0;
    if (len === 0) {
      return -1;
    }

    n = len - 1;
    if (arguments.length > 1) {
      n = Number(arguments[1]);
      if (n != n) {
        n = 0;
      } else if (n != 0 && n != 1 / 0 && n != -(1 / 0)) {
        n = (n > 0 || -1) \* Math.floor(Math.abs(n));
      }
    }

    for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) {
      if (k in t && t[k] === searchElement) {
        return k;
      }
    }
    return -1;
  };
}
```

И снова обратите внимание, что данная реализация нацелена на абсолютную совместимость с методом `lastIndexOf()`, реализованным в Firefox и движке JavaScript SpiderMonkey, включая несколько случаев, которые являются спорными крайними случаями. Если вы используете этот код в реальных приложениях, вы можете вычислять параметр `from` менее сложным образом, игнорируя эти случаи.

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

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

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

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

Замечания по совместимости
--------------------------

* Начиная с Firefox 47, метод больше не будет возвращать `-0`. Например, `[0].lastIndexOf(0, -0)` теперь всегда будет возвращать `+0` (Firefox bug 1242043).
Смотрите также
--------------

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`


Array.prototype.forEach() - JavaScript

Array.prototype.forEach()
=========================

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

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

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

arr.forEach(function callback(currentValue, index, array) {
    //your iterator
}[, thisArg]);
```

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

`callback`

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

`currentValue`

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

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

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

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

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

`thisArg`

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

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

`undefined`.

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

Метод `forEach()` выполняет функцию `callback` один раз для каждого элемента, находящегося в массиве в порядке возрастания. Она не будет вызвана для удалённых или пропущенных элементов массива. Однако, она будет вызвана для элементов, которые присутствуют в массиве и имеют значение `undefined`.

Функция `callback` будет вызвана с **тремя аргументами**:

* значение элемента (**value**)
* индекс элемента (**index**)
* массив, по которому осуществляется проход (**array**)

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

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

**Примечание:** Не существует способа остановить или прервать цикл `forEach()` кроме как выбрасыванием исключения. Если вам необходимо такое поведение, метод `forEach()` неправильный выбор.

Досрочное прекращение может быть достигнуто с:

* Простой цикл `for`
* Циклы `for...of` / `for...in`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `Array.prototype.find()`
* `Array.prototype.findIndex()`

Если нужно протестировать элементы массива на условие и нужно вернуть булево значение, вы можете воспользоваться методами `every()`, `some()`, `find()` или `findIndex()`.

Метод `forEach()` выполняет функцию `callback` один раз для каждого элемента массива; в отличие от методов `every()` и `some()`, он всегда возвращает значение `undefined`.

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

### Нет операции для неинициализированных значений (разреженные массивы)

```js
const arraySparse = [1, 3, , 7];
let numCallbackRuns = 0;

arraySparse.forEach((element) => {
  console.log(element);
  numCallbackRuns++;
});

console.log("numCallbackRuns: ", numCallbackRuns);

// 1
// 3
// 7
// numCallbackRuns: 3
// комментарий: как вы видите пропущенное значение между 3 и 7 не вызывало функцию callback.
```

### Конвертируем цикл for в forEach

```js
const items = ["item1", "item2", "item3"];
const copy = [];

// до
for (let i = 0; i < items.length; i++) {
  copy.push(items[i]);
}

// после
items.forEach(function (item) {
  copy.push(item);
});
```

### Печать содержимого массива

**Примечание:** Для отображения содержимого массива в консоли вы можете использовать `console.table()`, который выводит отформатированную версию массива.

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

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

```js
function logArrayElements(element, index, array) {
  console.log("a[" + index + "] = " + element);
}

// Обратите внимание на пропуск по индексу 2, там нет элемента, поэтому он не посещается
[2, 5, , 9].forEach(logArrayElements);
// логи:
// a[0] = 2
// a[1] = 5
// a[3] = 9
```

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

Следующий (надуманный) пример обновляет свойства объекта, когда перебирает записи массива:

```js
function Counter() {
  this.sum = 0;
  this.count = 0;
}
Counter.prototype.add = function (array) {
  array.forEach((entry) => {
    this.sum += entry;
    ++this.count;
  }, this);
  // ^---- Note
};

const obj = new Counter();
obj.add([2, 5, 9]);
obj.count;
// 3
obj.sum;
// 16
```

Поскольку в `forEach()` передан параметр `thisArg` (`this`), он затем передаётся в `callback` при каждом вызове. И callback использует его в качестве собственного значения `this`.

**Примечание:** Если при передаче callback функции используется `выражение стрелочной функции`, параметр `thisArg` может быть опущен, так как все стрелочные функции лексически привязываются к значению`this`.

### Прерывание цикла

Следующий код использует `Array.prototype.every()` для логирования содержимого массива и останавливается при превышении значением заданного порогового значения `THRESHOLD`.

```js
var THRESHOLD = 12;
var v = [5, 2, 16, 4, 3, 18, 20];
var res;

res = v.every(function (element, index, array) {
  console.log("element:", element);
  if (element >= THRESHOLD) {
    return false;
  }

  return true;
});
console.log("res:", res);
// логи:
// element: 5
// element: 2
// element: 16
// res: false

res = v.some(function (element, index, array) {
  console.log("element:", element);
  if (element >= THRESHOLD) {
    return true;
  }

  return false;
});
console.log("res:", res);
// логи:
// element: 5
// element: 2
// element: 16
// res: true
```

### Функция копирования объекта

Следующий код создаёт копию переданного объекта. Существует несколько способов создания копии объекта, и это один из них. Он позволяет понять, каким образом работает `Array.prototype.forEach()`, используя функции мета-свойств `Object.*` из ECMAScript 5.

```js
function copy(o) {
  var copy = Object.create(Object.getPrototypeOf(o));
  var propNames = Object.getOwnPropertyNames(o);

  propNames.forEach(function (name) {
    var desc = Object.getOwnPropertyDescriptor(o, name);
    Object.defineProperty(copy, name, desc);
  });

  return copy;
}

var o1 = { a: 1, b: 2 };
var o2 = copy(o1); // теперь o2 выглядит также, как и o1
```

### Модификация массива во время итерации

В следующем примере в лог выводится `"one"`, `"two"`, `"four"`.

При достижении записи, содержащей значение `'two'`, первая запись всего массива удаляется, в результате чего все оставшиеся записи перемещаются на одну позицию вверх. Поскольку элемент `'four'` теперь находится на более ранней позиции в массиве, `'three'` будет пропущен.

`forEach()` не делает копию массива перед итерацией.

```js
let words = ["one", "two", "three", "four"];
words.forEach((word) => {
  console.log(word);
  if (word === "two") {
    words.shift();
  }
});
// one
// two
// four
```

### Выравнивание (уплощение) массива

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

```js
function flatten(arr) {
  const result = [];

  arr.forEach((i) => {
    if (Array.isArray(i)) {
      result.push(...flatten(i));
    } else {
      result.push(i);
    }
  });

  return result;
}

// Usage
const nested = [1, 2, 3, [4, 5, [6, 7], 8, 9]];

flatten(nested); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
```

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

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

```js
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.18
// Ссылка (en): http://es5.github.io/#x15.4.4.18
// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.18
if (!Array.prototype.forEach) {
  Array.prototype.forEach = function (callback, thisArg) {
    var T, k;

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

    // 1. Положим O равным результату вызова ToObject passing the |this| value as the argument.
    var O = Object(this);

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

    // 4. Если IsCallable(callback) равен false, выкинем исключение TypeError.
    // Смотрите: http://es5.github.com/#x9.11
    if (typeof callback !== "function") {
      throw new TypeError(callback + " is not a function");
    }

    // 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. Вызовем внутренний метод Call функции callback с объектом T в качестве значения this и
        // списком аргументов, содержащим kValue, k и O.
        callback.call(T, kValue, k, O);
      }
      // d. Увеличим k на 1.
      k++;
    }
    // 8. Вернём undefined.
  };
}
```

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

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

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

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

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

* `Array.prototype.find()`
* `Array.prototype.findIndex()`
* `Array.prototype.map()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `Map.prototype.forEach()` (en-US)
* `Set.prototype.forEach()`


Array.prototype.some() - JavaScript

Array.prototype.some()
======================

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

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

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

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

arr.some(callback(element[, index[, array]])[, thisArg])
```

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

`callback`

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

`element`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### Проверка значений элементов массива

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

```js
function isBiggerThan10(element, index, array) {
  return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
```

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

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

```js
[2, 5, 8, 1, 4].some((elem) => elem > 10); // false
[12, 5, 8, 1, 4].some((elem) => elem > 10); // true
```

### Проверка наличия элемента в массиве

Чтобы имитировать функцию метода `includes()`, эта пользовательская функция возвращает true, если элемент существует в массиве:

```js
const fruits = ["apple", "banana", "mango", "guava"];

function checkAvailability(arr, val) {
  return arr.some(function (arrVal) {
    return val === arrVal;
  });
}

checkAvailability(fruits, "kela"); // false
checkAvailability(fruits, "banana"); // true
```

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

```js
const fruits = ["apple", "banana", "mango", "guava"];

function checkAvailability(arr, val) {
  return arr.some((arrVal) => val === arrVal);
}

checkAvailability(fruits, "kela"); // false
checkAvailability(fruits, "banana"); // true
```

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

```js
const TRUTHY\_VALUES = [true, "true", 1];

function getBoolean(value) {
  "use strict";

  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY\_VALUES.some(function (t) {
    return t === value;
  });
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true
```

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

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

```js
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.17
// Ссылка (en): http://es5.github.io/#x15.4.4.17
// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.17
if (!Array.prototype.some) {
  Array.prototype.some = function (fun /\*, thisArg\*/) {
    "use strict";

    if (this == null) {
      throw new TypeError("Array.prototype.some called on null or undefined");
    }

    if (typeof fun !== "function") {
      throw new TypeError();
    }

    var t = Object(this);
    var len = t.length >>> 0;

    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for (var i = 0; i < len; i++) {
      if (i in t && fun.call(thisArg, t[i], i, t)) {
        return true;
      }
    }

    return false;
  };
}
```

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

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

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

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

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

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


Array.prototype.find() - JavaScript

Array.prototype.find()
======================

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

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

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

Если вам нужно найти позицию элемента или наличие элемента в массиве, используйте `Array.prototype.indexOf()` или `Array.prototype.includes()` соответственно.

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

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

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

`callback`

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

`element`

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

`index`

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

`array`

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

`thisArg`

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

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

Значение элемента из массива, если элемент прошёл проверку, иначе `undefined`.

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

Метод `find` вызывает переданную функцию `callback` один раз для каждого элемента, присутствующего в массиве, до тех пор, пока она не вернёт `true`. Если такой элемент найден, метод `find` немедленно вернёт значение этого элемента. В противном случае, метод `find` вернёт `undefined`. До Firefox 34 функция `callback` не вызывалась для «дырок» в массивах (bug 1058394).

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

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

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

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

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

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

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

```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].find(isPrime)); // undefined, не найдено
console.log([4, 5, 8, 12].find(isPrime)); // 5
```

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

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

// https://tc39.github.io/ecma262/#sec-array.prototype.find
if (!Array.prototype.find) {
  Object.defineProperty(Array.prototype, 'find', {
    value: function(predicate) {
     // 1. Let O be ? ToObject(this value).
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }

      var o = Object(this);

      // 2. Let len be ? ToLength(? Get(O, "length")).
      var len = o.length >>> 0;

      // 3. If IsCallable(predicate) is false, throw a TypeError exception.
      if (typeof predicate !== 'function') {
        throw new TypeError('predicate must be a function');
      }

      // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
      var thisArg = arguments[1];

      // 5. Let k be 0.
      var k = 0;

      // 6. Repeat, while k < len
      while (k < len) {
        // a. Let Pk be ! ToString(k).
        // b. Let kValue be ? Get(O, Pk).
        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
        // d. If testResult is true, return kValue.
        var kValue = o[k];
        if (predicate.call(thisArg, kValue, k, o)) {
          return kValue;
        }
        // e. Increase k by 1.
        k++;
      }

      // 7. Return undefined.
      return undefined;
    },
    configurable: true,
    writable: true
  });
}
```

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

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

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

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

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

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


Array.prototype.map() - JavaScript

Array.prototype.map()
=====================

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

Метод **`map()`** создаёт новый массив с результатом вызова указанной функции для каждого элемента массива.

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

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

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

`callback`

Функция, вызываемая для каждого элемента массива `arr`. Каждый раз, когда `callback` выполняется, возвращаемое значение добавляется в `new_array`.

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

`currentValue`

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

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

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

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

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

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

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

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

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

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

Метод `map` вызывает переданную функцию `callback` один раз для каждого элемента, в порядке их появления и конструирует новый массив из результатов её вызова. Функция `callback` вызывается только для индексов массива, имеющих присвоенные значения, включая `undefined`. Она не вызывается для пропущенных элементов массива (то есть для индексов, которые никогда не были заданы, которые были удалены или которым никогда не было присвоено значение.

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

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

Метод `map` не изменяет массив, для которого он был вызван (хотя функция `callback` может это делать).

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

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

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

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

```js
const numbers = [1, 4, 9];
const roots = numbers.map(Math.sqrt);
// теперь roots равен [1, 2, 3], а numbers всё ещё равен [1, 4, 9]
```

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

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

```js
const numbers = [1, 4, 9];
const doubles = numbers.map((num) => num \* 2);
// теперь doubles равен [2, 8, 18], а numbers всё ещё равен [1, 4, 9]
```

### Пример: обобщённое использование `map`

Этот пример показывает, как использовать `map` на объекте строки `String` для получения массива байт в кодировке ASCII, представляющего значения символов:

```js
const map = Array.prototype.map;
const charCodes = map.call("Hello World", (x) => x.charCodeAt(0));
// теперь charCodes равен [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
```

### Пример: обобщённое использование `map` вместе с `querySelectorAll`

Этот пример показывает, как пройтись по коллекции объектов, собранных с помощью `querySelectorAll`. В данном случае мы получаем все выбранные опции на экране и печатаем их в консоль:

```js
const elems = document.querySelectorAll("select option:checked");
const values = Array.prototype.map.call(elems, ({ value }) => value);
```

Более простым способом будет использование метода `Array.from()`.

### Пример: использование `map` для переворачивания строки

```js
const string = "12345";
const reversed = Array.prototype.map
  .call(string, (x) => x)
  .reverse()
  .join("");
// reversed равен '54321'
// Бонус: используйте '===' для проверки того, является ли строка палиндромом
```

Более простым способом будет использование метода `String.split()` (см. пример обращение строки при помощи метода split()).

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

(навеяно этой записью в блоге)

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

```js
// Рассмотрим пример:
["1", "2", "3"].map(parseInt);
// Хотя ожидаемый результат вызова равен [1, 2, 3],
// в действительности получаем [1, NaN, NaN]

// Функция parseInt часто используется с одним аргументом, но она принимает два.
// Первый аргумент является выражением, а второй - основанием системы счисления.
// В функцию callback Array.prototype.map передаёт 3 аргумента:
// элемент, его индекс и сам массив.
// Третий аргумент игнорируется parseInt, но не второй, следовательно,
// возможна путаница. Смотрите запись в блоге для дополнительной информации.

const returnInt = (element) => parseInt(element, 10);

["1", "2", "3"].map(returnInt);
// Результатом является массив чисел (как и ожидалось)

// Простейший способ добиться вышеозначенного поведения и избежать чувства "чё за!?":
["1", "2", "3"].map(Number); // [1, 2, 3]
```

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

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

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

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

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

* Polyfill of Array.prototype.map in core-js
* `Array.prototype.forEach()`
* объект `Map` (en-US)
* `Array.from()`


Array.prototype.toString() - JavaScript

Array.prototype.toString()
==========================

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

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

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

arr.toString()
```

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

Нет.

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

Объект `Array` переопределяет метод `toString` объекта `Object`. Для объектов класса `Array`, метод `toString` соединяет массив и возвращает одну строку, содержащую каждый элемент массива, разделённый запятыми. Например, следующий код создаёт массив и использует метод `toString` для преобразования массива в строку.

```js
var monthNames = ["Янв", "Фев", "Мар", "Апр"];
var myVar = monthNames.toString(); // присваивает 'Янв,Фев,Мар,Апр' переменной myVar.
```

JavaScript вызывает метод `toString` автоматически, когда массив представляется текстовым значением или когда массив находится в контексте конкатенации строк.

### Семантика ECMAScript 5

Начиная с JavaScript 1.8.5 (Firefox 4), и в соответствии с семантикой ECMAScript 5-го издания, метод `toString()` является обобщённым и может использоваться с любым объектом. В случае с массивами, если он имеет метод `join()`, он будет вызван и результат его работы будет возвращён. В противном случае будет вызван метод `Object.prototype.toString()`, и будет возвращён результат его работы.

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

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

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

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

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

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


Array.prototype.toLocaleString() - JavaScript

Array.prototype.toLocaleString()
================================

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

Метод **`toLocaleString()`** возвращает строковое представление элементов массива. Элементы преобразуются в строки с использованием своих собственных методов `toLocaleString` и эти строки разделяются локале-зависимой строкой (например, запятой «,»).

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

arr.toLocaleString();
```

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

Нет.

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

Элементы массива преобразуются в строки с использованием своих собственных методов `toLocaleString`:

* `Object`: `Object.prototype.toLocaleString()`
* `Number`: `Number.prototype.toLocaleString()`
* `Date`: `Date.prototype.toLocaleString()`
Примеры
-------

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

```js
var number = 1337;
var date = new Date();
var myArr = [number, date, "foo"];

var str = myArr.toLocaleString();

console.log(str);
// напечатает '1337,6.12.2013 19:37:35,foo',
// если работает под германской локалью (de-DE) с временной зоной Европа/Берлин
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.tolocalestring |
| ECMAScript Internationalization API Specification # sup-array.prototype.tolocalestring |

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

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

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

* `Array.prototype.toString()`


Array.prototype.keys() - JavaScript

Array.prototype.keys()
======================

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

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

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

arr.keys()
```

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

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

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

console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

### Пример: итератор, возвращаемый методом `keys()`, не пропускает дырки в массиве

```js
var arr = ["a", , "c"];
var sparseKeys = Object.keys(arr);
var denseKeys = [...arr.keys()];
console.log(sparseKeys); // [0, 2]
console.log(denseKeys); // [0, 1, 2]
```

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

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

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

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

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

* `Array.prototype.values()`
* `Array.prototype.entries()`
* Iteration protocols


Array.prototype.slice() - JavaScript

Array.prototype.slice()
=======================

Метод **`slice()`** возвращает новый массив, содержащий копию части исходного массива.

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

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

arr.slice([begin[, end]])
```

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

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

Индекс (счёт начинается с нуля), по которому начинать извлечение.

Если индекс отрицательный, `begin` указывает смещение от конца последовательности. Вызов `slice(-2)` извлечёт два последних элемента последовательности.

Если `begin` не определён, `slice()` начинает работать с индекса `0`.

Если `begin` больше длины последовательности вернётся пустой массив.

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

Индекс (счёт начинается с нуля), по которому заканчивать извлечение. Метод `slice()` извлекает элементы с индексом меньше `end`.

Вызов `slice(1, 4)` извлечёт элементы со второго по четвёртый (элементы по индексам 1, 2 и 3).

Если индекс отрицательный, `end` указывает смещение от конца последовательности. Вызов `slice(2, -1)` извлечёт из последовательности элементы начиная с третьего элемента с начала и заканчивая вторым с конца.

Если `end >= array.length` или `end` опущен, `slice()` извлекает все элементы до конца последовательности (`arr.length`).

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

Новый массив, содержащий извлечённые элементы.

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

Метод `slice()` не изменяет исходный массив, а возвращает новую «одноуровневую» копию, содержащую копии элементов, вырезанных из исходного массива. Элементы исходного массива копируются в новый массив по следующим правилам:

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

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

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

### Пример: возврат части существующего массива

```js
// Пример: наши хорошие друзья цитрусовые среди фруктов
var fruits = ["Банан", "Апельсин", "Лимон", "Яблоко", "Манго"];
var citrus = fruits.slice(1, 3);

// citrus содержит ['Апельсин', 'Лимон']
```

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

В следующем примере метод `slice()` создаёт новый массив, `newCar`, из массива `myCar`. Оба содержат ссылку на объект `myHonda`. Когда цвет в объекте `myHonda` изменяется на багровый, оба массива замечают это изменение.

```js
// Используя slice, создаём newCar из myCar.
var myHonda = {
  color: "красный",
  wheels: 4,
  engine: { cylinders: 4, size: 2.2 },
};
var myCar = [myHonda, 2, "в хорошем состоянии", "приобретена в 1997"];
var newCar = myCar.slice(0, 2);

// Отображаем значения myCar, newCar и цвет myHonda
// по ссылкам из обоих массивов.
console.log("myCar = " + myCar.toSource());
console.log("newCar = " + newCar.toSource());
console.log("myCar[0].color = " + myCar[0].color);
console.log("newCar[0].color = " + newCar[0].color);

// Изменяем цвет myHonda.
myHonda.color = "багровый";
console.log("Новый цвет моей Honda - " + myHonda.color);

// Отображаем цвет myHonda по ссылкам из обоих массивов.
console.log("myCar[0].color = " + myCar[0].color);
console.log("newCar[0].color = " + newCar[0].color);
```

Этот скрипт выведет:

```js
myCar = [{color:'красный', wheels:4, engine:{cylinders:4, size:2.2}}, 2,
         'в хорошем состоянии', 'приобретена в 1997']
newCar = [{color:'красный', wheels:4, engine:{cylinders:4, size:2.2}}, 2]
myCar[0].color = красный
newCar[0].color = красный
Новый цвет моей Honda - багровый
myCar[0].color = багровый
newCar[0].color = багровый
```

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

Метод `slice()` также может использоваться для преобразования массивоподобных объектов / коллекций в новый массив `Array`. Вам просто нужно привязать метод к объекту. Псевдомассив `arguments` (en-US) внутри функции как раз является примером «массивоподобного объекта».

```js
function list() {
  return Array.prototype.slice.call(arguments, 0);
}

var list1 = list(1, 2, 3); // [1, 2, 3]
```

Привязка может быть осуществлена посредством функции `call()` из прототипа функции `Function.prototype` (en-US), также запись может быть сокращена до `[].slice.call(arguments)` вместо использования `Array.prototype.slice.call()`. В любом случае, она может быть упрощена посредством использования функции `bind()`.

```js
var unboundSlice = Array.prototype.slice;
var slice = Function.prototype.call.bind(unboundSlice);

function list() {
  return slice(arguments, 0);
}

var list1 = list(1, 2, 3); // [1, 2, 3]
```

Совершенствование кросс-браузерного поведения
---------------------------------------------

Хотя спецификация не требует от хост-объектов (например, объектов DOM) следовать поведению Mozilla при преобразовании с помощью `Array.prototype.slice()` и IE < 9 так не делает, версии IE, начиная с 9-й это умеют. «Прокладывание» позволяет добиться надёжного кросс-браузерного поведения. Пока другие современные браузеры будут поддерживать эту способность, что и делают в настоящее время IE, Mozilla, Chrome, Safari и Opera, разработчики, читая (поддерживающий DOM) код функции `slice()`, опирающийся на эту прокладку, не будут вводиться в заблуждение его семантикой; они могут смело полагаться на текущую семантику, являющуюся, видимо, *де-факто* стандартным поведением. (Прокладка также исправляет поведение IE, позволяя работать со вторым аргументом `slice()`, явно определённым как `null`/`undefined`, поскольку более ранние версии IE такое не позволяют, но все современные браузеры, в том числе IE >= 9, поддерживают данное поведение.)

```js
/\*\*
 \* Прокладка для "исправления" отсутствия поддержки в IE < 9 применения slice
 \* к хост-объектам вроде NamedNodeMap, NodeList и HTMLCollection
 \* (технически, поскольку хост-объекты зависят от реализации,
 \* по крайней мере, до ES2015, IE не обязан так работать).
 \* Также работает для строк, исправляет поведение IE < 9, позволяя явно указывать undefined
 \* вторым аргументом (как в Firefox), и предотвращает ошибки, возникающие при
 \* вызове на других объектах DOM.
 \*/
(function () {
  "use strict";
  var _slice = Array.prototype.slice;

  try {
    // Не может использоваться с элементами DOM в IE < 9
    \_slice.call(document.documentElement);
  } catch (e) {
    // В IE < 9 кидается исключение
    // Функция будет работать для истинных массивов, массивоподобных объектов,
    // NamedNodeMap (атрибуты, сущности, примечания),
    // NodeList (например, getElementsByTagName), HTMLCollection (например, childNodes)
    // и не будет падать на других объектах DOM (как это происходит на элементах DOM в IE < 9)
    Array.prototype.slice = function (begin, end) {
      // IE < 9 будет недоволен аргументом end, равным undefined
      end = typeof end !== "undefined" ? end : this.length;

      // Для родных объектов Array мы используем родную функцию slice
      if (Object.prototype.toString.call(this) === "[object Array]") {
        return \_slice.call(this, begin, end);
      }

      // Массивоподобные объекты мы обрабатываем самостоятельно
      var i,
        cloned = [],
        size,
        len = this.length;

      // Обрабатываем отрицательное значение begin
      var start = begin || 0;
      start = start >= 0 ? start : len + start;

      // Обрабатываем отрицательное значение end
      var upTo = end ? end : len;
      if (end < 0) {
        upTo = len + end;
      }

      // Фактически ожидаемый размер среза
      size = upTo - start;

      if (size > 0) {
        cloned = new Array(size);
        if (this.charAt) {
          for (i = 0; i < size; i++) {
            cloned[i] = this.charAt(start + i);
          }
        } else {
          for (i = 0; i < size; i++) {
            cloned[i] = this[start + i];
          }
        }
      }

      return cloned;
    };
  }
})();
```

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

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

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

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

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

* `Array.prototype.splice()`
* `Function.prototype.call()`
* `Function.prototype.bind()`


Array.prototype.unshift() - JavaScript

Array.prototype.unshift()
=========================

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

Метод **`unshift()`** добавляет один или более элементов в начало массива и возвращает новую длину массива.

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

arr.unshift(element1[, ...[, elementN]])
```

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

`element1, ..., elementN`

Элементы, добавляемые в начало массива.

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

Новое свойство `length` объекта, над которым был вызван метод `unshift`.

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

Метод `unshift` вставляет переданные значения в начало массивоподобного объекта.

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

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

```js
var arr = [1, 2];

arr.unshift(0); // результат вызова равен 3, новой длине массива
// arr равен [0, 1, 2]

arr.unshift(-2, -1); // = 5
// arr равен [-2, -1, 0, 1, 2]

arr.unshift([-3]);
// arr равен[[-3], -2, -1, 0, 1, 2]
```

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

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

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

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

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

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


Array.prototype.push() - JavaScript

Array.prototype.push()
======================

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

Метод **`push()`** добавляет один или более элементов в конец массива и возвращает новую длину массива.

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

arr.push(element1, ..., elementN)
```

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

`elementN`

Элементы, добавляемые в конец массива.

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

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

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

Метод `push` присоединяет значения к массиву.

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

Единственными родными массивоподобными объектами являются строки, хотя к ним он не может быть применён, поскольку строки являются неизменяемыми.

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

### Пример: добавление элементов в массив

Следующий код создаёт массив `sports`, содержащий два элемента, а затем добавляет к нему ещё два элемента. Переменная `total` будет содержать новую длину массива.

```js
var sports = ["футбол", "бейсбол"];
var total = sports.push("американский футбол", "плавание");

console.log(sports); // ['футбол', 'бейсбол', 'американский футбол', 'плавание']
console.log(total); // 4
```

### Пример: слияние двух массивов

В этом примере используется функция `apply()` для помещения всех элементов из второго массива в первый.

```js
var vegetables = ["пастернак", "картошка"];
var moreVegs = ["сельдерей", "свёкла"];

// Сливает второй массив с первым
// Эквивалентно вызову vegetables.push('сельдерей', 'свёкла');
Array.prototype.push.apply(vegetables, moreVegs);

console.log(vegetables); // ['пастернак', 'картошка', 'сельдерей', 'свёкла']
```

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

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

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

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

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

* `Array.prototype.pop()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`


Array.prototype.includes() - JavaScript

Array.prototype.includes()
==========================

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

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

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

arr.includes(searchElement[fromIndex = 0])
```

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

`searchElement`

Искомый элемент.

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

Позиция в массиве, с которой начинать поиск элемента `searchElement`. При отрицательных значениях поиск производится начиная с индекса `array.length + fromIndex` по возрастанию. Значение по умолчанию равно 0.

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

`Boolean`.

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

```js
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
```

### `fromIndex` больше или равен длине массива

Если `fromIndex` больше или равен длине массива, то возвращается `false`. При этом поиск не производится.

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

arr.includes("c", 3); // false
arr.includes("c", 100); // false
```

### Вычисленный индекс меньше нуля 0

Если `fromIndex` отрицательный, то вычисляется индекс, начиная с которого будет производиться поиск элемента `searchElement`. Если вычисленный индекс меньше нуля, то поиск будет производиться во всём массиве.

```js
// длина массива равна 3
// fromIndex равен -100
// вычисленный индекс равен 3 + (-100) = -97

var arr = ["a", "b", "c"];

arr.includes("a", -100); // true
arr.includes("b", -100); // true
arr.includes("c", -100); // true
```

### Использование `includes()` в качестве общих метода

`includes()` специально сделан общим. Он не требует, чтобы `this` являлся массивом, так что он может быть применён к другим типам объектов (например, к массивоподобным объектам). Пример ниже показывает использование метода `includes()` на объекте arguments.

```js
(function () {
  console.log([].includes.call(arguments, "a")); // true
  console.log([].includes.call(arguments, "d")); // false
})("a", "b", "c");
```

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

```js
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
  Object.defineProperty(Array.prototype, "includes", {
    value: function (searchElement, fromIndex) {
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }

      // 1. Let O be ? ToObject(this value).
      var o = Object(this);

      // 2. Let len be ? ToLength(? Get(O, "length")).
      var len = o.length >>> 0;

      // 3. If len is 0, return false.
      if (len === 0) {
        return false;
      }

      // 4. Let n be ? ToInteger(fromIndex).
      // (If fromIndex is undefined, this step produces the value 0.)
      var n = fromIndex | 0;

      // 5. If n ≥ 0, then
      // a. Let k be n.
      // 6. Else n < 0,
      // a. Let k be len + n.
      // b. If k < 0, let k be 0.
      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

      function sameValueZero(x, y) {
        return (
          x === y ||
          (typeof x === "number" &&
            typeof y === "number" &&
            isNaN(x) &&
            isNaN(y))
        );
      }

      // 7. Repeat, while k < len
      while (k < len) {
        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
        // b. If SameValueZero(searchElement, elementK) is true, return true.
        if (sameValueZero(o[k], searchElement)) {
          return true;
        }
        // c. Increase k by 1.
        k++;
      }

      // 8. Return false
      return false;
    },
  });
}
```

Если требуется поддержка устаревших движков JavaScript, которые не поддерживают `Object.defineProperty`, то наилучшим решением будет вообще не делать полифил для методов `Array.prototype`, так как не получится сделать их неперечисляемыми.

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

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

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

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

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

* `TypedArray.prototype.includes()` (en-US)
* `String.prototype.includes()`
* `Array.prototype.indexOf()`
* `Array.prototype.find()`
* `Array.prototype.findIndex()`


Array.prototype.at() - JavaScript

Array.prototype.at()
====================

Baseline 2022
-------------

Newly availableSince March 2022, this feature works across the latest devices and browser versions. This feature might not work in older devices or browsers.

* Learn more
* See full compatibility
* Report feedback
Метод **`at()`** принимает значение в виде целого числа и возвращает элемент массива с данным индексом. В качестве аргумента метод принимает положительные и отрицательные числа. При отрицательном значении отсчёт происходит с конца массива.

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

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

```js
at(index)
```

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

`index`

Индекс (позиция) элемента возвращаемого элемента массива. При передаче отрицательного индекса применяется относительная индексация с конца массива; например, при использовании отрицательного числа, возвращаемый элемент находится путём обратного отсчёта с конца массива.

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

Элемент массива, соответствующий переданному индексу. Если переданный индекс не может быть найден, возвращает `undefined`.

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

Метод `at()` является эквивиалентом получения элементов массива с помощью квадратных скобок с использованием неотрицательного индекса. Например, `array[0]` и `array.at(0)` оба вернут первый элемент. Однако, при вычислении значения с конца массива, нельзя использовать `array[-1]` как в Python или R, потому что все значения внутри квадратных скобок трактуются буквально как строковые свойства. Из-за этого попытка обращения к -1 элементу будет прочитана как `array["-1"]`, что является нормальным строковым значением, а не индексом массива.

Обычной практикой является получении числа элементов массива `length` и последующее вычисление значения индекса — например, `array[array.length - 1]`. Метод `at()` разрешает относительную индексацию, поэтому может быть сокращено до `array.at(-1)`.

Метод `at()` — это generic. Он ожидает только, что значение `this` будет иметь свойство `length` и свойства с числовыми ключом.

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

### Возврат последнего элемента массива

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

```js
// Массив со значениями
const cart = ["apple", "banana", "pear"];

// Функция, которая возвращает последний элемент переданного массива
function returnLast(arr) {
  return arr.at(-1);
}

// Получить последний элемент нашего массива 'cart'
const item1 = returnLast(cart);
console.log(item1); // Выведет: 'pear'

// Добавить элемент в наш массив 'cart'
cart.push("orange");
const item2 = returnLast(cart);
console.log(item2); // Выведет: 'orange'
```

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

В этом примере сравниваются разные способы выбора предпоследнего элемента `массива`. Хотя все приведённые ниже способы являются допустимыми, наиболее кратким и наглядным является использование метода `at()`.

```js
// Наш массив с элементами
const colors = ["red", "green", "blue"];

// Использование свойства 'length'
const lengthWay = colors[colors.length - 2];
console.log(lengthWay); // Выведет: 'green'

// Использование метода slice(). Обратите внимание, что возвращается массив
const sliceWay = colors.slice(-2, -1);
console.log(sliceWay[0]); // Выведет: 'green'

// Использование метода at()
const atWay = colors.at(-2);
console.log(atWay); // Выведет: 'green'
```

### Вызов at() в массивоподобных объектах

Метод `at()` считывает свойство `length` для значения `this` и вычисляет индекс для обращения.

```js
const arrayLike = {
  length: 2,
  0: "a",
  1: "b",
};
console.log(Array.prototype.at.call(arrayLike, -1)); // "b"
```

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

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

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

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

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

* Полифил `Array.prototype.at` в библиотеке `core-js`
* Полифил для метода at().
* `Array.prototype.find()` – возвращает значение на основании проверки.
* `Array.prototype.includes()` – проверяет наличие значения в массиве.
* `Array.prototype.indexOf()` – возвращает индекс переданного элемента.


Array.length - JavaScript

Array.length
============

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

Свойство **`length`** объекта, который является экземпляром типа `Array` , устанавливает или возвращает число элементов этого массива. Значение данного свойства 32-битное безнаковое целое число, которое всегда численно больше чем самый наибольший индекс в массиве.

```js
var items = ["shoes", "shirts", "socks", "sweaters"];
items.length;

// возвращает 4
```

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

arr.length
```

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

Свойство `length` является целым числом с положительным знаком и значением, меньшим чем 2 в степени 32 (232).

```js
var namelistA = new Array(4294967296); //2 в 32 степени = 4294967296
var namelistC = new Array(-100); //отрицательная величина

console.log(namelistA.length); //RangeError: Invalid array length
console.log(namelistC.length); //RangeError: Invalid array length

var namelistB = [];
namelistB.length = Math.pow(2, 32) - 1; //устанавливает длину массива меньше 2 в 32 степени
console.log(namelistB.length);

//4294967295
```

В любой момент вы можете установить свойство `length` для обрезки массива. Когда вы расширяете массив, изменяя его свойство `length`, реальное количество элементов в массиве увеличивается; например, если вы установите свойство `length` в 3, когда оно равно 2, массив будет из 3 элементов, где значение третьего элемента будет равно `undefined` .

```js
var arr = [1, 2, 3];
printEntries(arr);

arr.length = 5; // устанавливает длину массива 5.
printEntries(arr);

function printEntries(arr) {
  var goNext = true;
  var entries = arr.entries();
  while (goNext) {
    var result = entries.next();
    if (result.done !== true) {
      console.log(result.value[1]);
      goNext = true;
    } else goNext = false;
  }
  console.log("=== printed ===");
}

// 1
// 2
// 3
// === printed ===
// 1
// 2
// 3
// undefined
// undefined
// === printed ===
```

Таким образом, свойство `length` ничего не говорит о количестве определённых значений в массиве. Также смотрите раздел Взаимосвязь свойства `length` с числовыми свойствами.

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

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

### Пример: итерирование по массиву

В следующем примере массив `numbers` итерируется до значения свойства `length`, показывающего, сколько элементов содержит массив. Значение каждого элемента удваивается.

```js
var numbers = [1, 2, 3, 4, 5];

for (var i = 0; i < numbers.length; i++) {
  numbers[i] \*= 2;
}
// Массив numbers теперь равен [2, 4, 6, 8, 10];
```

### Пример: сокращение массива

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

```js
if (statesUS.length > 50) {
  statesUS.length = 50;
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-array-instances-length |

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

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

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

* `Array`


Array.prototype.fill() - JavaScript

Array.prototype.fill()
======================

Метод **`fill()`** заполняет все элементы массива от начального до конечного индексов одним значением.

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

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

arr.fill(value[, start = 0[, end = this.length]])
```

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

`value`

Значение, заполняющее массив.

`start`

Необязательный параметр. Начальный индекс.

`end`

Необязательный параметр. Конечный индекс.

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

Изменённый массив.

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

Элементы заполняются в полузакрытом интервале [`start`, `end`).

Метод **`fill`** принимает до трёх аргументов — `value`, `start` и `end`. Аргументы `start` и `end` являются необязательными со значениями по умолчанию, равными `0` и `length` объекта `this` соответственно.

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

Метод **`fill`** намеренно является *обобщённым*, он не требует, чтобы значение `this` внутри него было объектом `Array`.

Метод **`fill`** является *изменяющим методом*, он изменит объект `this` и вернёт его, а не просто вернёт копию.

Если аргумент value является объектом, то метод **`fill`** заполнит массив ссылками на этот объект.

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

[1, 2, 3].fill(4);               // [4, 4, 4]
[1, 2, 3].fill(4, 1);            // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
[1, 2, 3].fill(4, 3, 3);         // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
[1, 2, 3].fill(4, 3, 5);         // [1, 2, 3]
Array(3).fill(4);                // [4, 4, 4]
[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}

// Объекты заполняются по ссылке.
var arr = Array(3).fill({}) // [{}, {}, {}];
arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
```

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

if (!Array.prototype.fill) {
  Object.defineProperty(Array.prototype, 'fill', {
    value: function(value) {

      // Шаги 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-7.
      var start = arguments[1];
      var relativeStart = start >> 0;

      // Шаг 8.
      var k = relativeStart < 0 ?
        Math.max(len + relativeStart, 0) :
        Math.min(relativeStart, len);

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

      // Шаг 11.
      var final = relativeEnd < 0 ?
        Math.max(len + relativeEnd, 0) :
        Math.min(relativeEnd, len);

      // Шаг 12.
      while (k < final) {
        O[k] = value;
        k++;
      }

      // Шаг 13.
      return O;
    }
  });
}
```

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

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

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

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

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

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

* `Array`
* `TypedArray.prototype.fill()` (en-US)


Array.prototype.join() - JavaScript

Array.prototype.join()
======================

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

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

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

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

arr.join([separator])
```

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

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

Определяет строку, разделяющую элементы массива. В случае необходимости тип разделителя приводится к типу Строка. Если он не задан, элементы массива разделяются запятой '**,**'. Если разделитель - пустая строка, элементы массива ничем не разделяются в возвращаемой строке.

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

Строка, содержащая все элементы массива. Если *`arr.length`* == `0`, то будет возвращена пустая строка.

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

Преобразует все элементы массива в строки и объединяет их в одну большую строку. Элемент массива с типом `undefined` или `null` преобразуется в пустую строку.

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

### Соединение массива четырьмя различными способами

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

```js
var a = ["Ветер", "Дождь", "Огонь"];
var myVar1 = a.join(); // присвоит 'Ветер,Дождь,Огонь' переменной myVar1
var myVar2 = a.join(", "); // присвоит 'Ветер, Дождь, Огонь' переменной myVar2
var myVar3 = a.join(" + "); // присвоит 'Ветер + Дождь + Огонь' переменной myVar3
var myVar4 = a.join(""); // присвоит 'ВетерДождьОгонь' переменной myVar4
```

### Соединение элементов массивоподобного объекта

В следующем примере соединяется массивоподобный объект (в данном случае список аргументов функции) с использованием вызова `Function.prototype.call` `для Array.prototype.join`.

```js
function f(a, b, c) {
  var s = Array.prototype.join.call(arguments);
  console.log(s); // '1,a,true'
}
f(1, "a", true);
```

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

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

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

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

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

* `String.prototype.split()`
* `Array.prototype.toString()`
* `TypedArray.prototype.join()`


Array.prototype.values() - JavaScript

Array.prototype.values()
========================

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

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

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

arr.values()
```

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

### Пример: итерация через цикл `for...of`

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

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

```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr.values();
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.values |

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

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.filter() - JavaScript

Array.prototype.filter()
========================

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

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

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

```js
// Стрелочная функция
filter((element) => { ... } )
filter((element, index) => { ... } )
filter((element, index, array) => { ... } )

// Колбэк-функция
filter(callbackFn)
filter(callbackFn, thisArg)

// Встроенная колбэк-функция
filter(function callbackFn(element) { ... })
filter(function callbackFn(element, index) { ... })
filter(function callbackFn(element, index, array){ ... })
filter(function callbackFn(element, index, array) { ... }, thisArg)
```

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

`callbackFn`

Функция-предикат, которая будет вызвана для проверки каждого элемента массива. Если функция возвращает `true`, то элемент остаётся в массиве, если `false`, то удаляется.

Принимает три аргумента

`element`

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

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

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

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

Обрабатываемый массив, на котором был вызван метод `filter()`.

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

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

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

Вернётся новый массив с элементами, которые прошли проверку. Если ни один элемент не прошёл проверку, то будет возвращён пустой массив.

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

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

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

1. значение элемента;
2. индекс элемента;
3. массив, по которому осуществляется проход.

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

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

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

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

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

### Фильтрация всех маленьких значений

Следующий пример использует `filter()` для создания отфильтрованного массива, все элементы которого больше или равны 10, а все меньшие 10 удалены.

```js
function isBigEnough(value) {
  return value >= 10;
}

let filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// массив filtered теперь содержит [12, 130, 44]
```

### Найти все простые числа в массиве

Следующий пример возвращает все простые числа в массиве:

```js
const array = [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];

function isPrime(num) {
  for (let i = 2; num > i; i++) {
    if (num % i == 0) {
      return false;
    }
  }
  return num > 1;
}

console.log(array.filter(isPrime)); // [2, 3, 5, 7, 11, 13]
```

### Фильтрация неверных записей в JSON

В следующем примере метод `filter()` используется для создания отфильтрованного JSON-объекта, все элементы которого содержат ненулевое числовое поле `id`.

```js
let arr = [
  { id: 15 },
  { id: -1 },
  { id: 0 },
  { id: 3 },
  { id: 12.2 },
  {},
  { id: null },
  { id: NaN },
  { id: "undefined" },
];

let invalidEntries = 0;

function filterByID(item) {
  if (Number.isFinite(item.id) && item.id !== 0) {
    return true;
  }
  invalidEntries++;
  return false;
}

let arrByID = arr.filter(filterByID);

console.log("Отфильтрованный массив\n", arrByID);
// Отфильтрованный массив
// [{ id: 15 }, { id: -1 }, { id: 3 }, { id: 12.2 }]

console.log("Количество некорректных элементов = ", invalidEntries);
// Количество некорректных элементов = 5
```

### Поиск в массиве

В следующем примере `filter()` используется для фильтрации содержимого массива на основе входных данных.

```js
var fruits = ["apple", "banana", "grapes", "mango", "orange"];

/\*\*
 \* Элементы массива фильтруется на основе критериев поиска (query)
 \*/
function filterItems(query) {
  return fruits.filter(function (el) {
    return el.toLowerCase().indexOf(query.toLowerCase()) > -1;
  });
}

console.log(filterItems("ap")); // ['apple', 'grapes']
console.log(filterItems("an")); // ['banana', 'mango', 'orange']
```

#### Реализация с использованием ES2015

```js
const fruits = ["apple", "banana", "grapes", "mango", "orange"];

/\*\*
 \* Элементы массива фильтруется на основе критериев поиска (query)
 \*/
const filterItems = (arr, query) => {
  return arr.filter(
    (el) => el.toLowerCase().indexOf(query.toLowerCase()) !== -1,
  );
};

console.log(filterItems(fruits, "ap")); // ['apple', 'grapes']
console.log(filterItems(fruits, "an")); // ['banana', 'mango', 'orange']
```

### Модификация изначального массива (изменение, добавление и удаление)

В следующих примерах проверяется поведение метода `filter` при изменении массива.

```js
// Изменение всех элементов
let words = ["spray", "limit", "exuberant", "destruction", "elite", "present"];

const modifiedWords = words.filter((word, index, arr) => {
  arr[index + 1] += " extra";
  return word.length < 6;
});

console.log(modifiedWords);
// Обратите внимание, что есть три слова длиной менее 6, но так как они были изменены,
// возвращается одно слово ['spray']

// Добавление новых элементов
words = ["spray", "limit", "exuberant", "destruction", "elite", "present"];
const appendedWords = words.filter((word, index, arr) => {
  arr.push("new");
  return word.length < 6;
});

console.log(appendedWords);
// Только три слова удовлетворяют условию, хотя `words` теперь имеет куда больше слов,
// длинной меньше 6 символов: ['spray', 'limit', 'elite']

// Удаление элементов
words = ["spray", "limit", "exuberant", "destruction", "elite", "present"];
const deleteWords = words.filter((word, index, arr) => {
  arr.pop();
  return word.length < 6;
});

console.log(deleteWords);
// Заметьте, что 'elite' не получено, так как удалено из `words` до того,
// как filter смог получить его: ['spray', 'limit']
```

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

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

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

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

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

* Полифил `Array.prototype.filter` в библиотеке `core-js`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `Array.prototype.reduce()`
* `Array.prototype.find()`


Array.prototype.reverse() - JavaScript

Array.prototype.reverse()
=========================

Метод **`reverse()`** на месте обращает порядок следования элементов массива. Первый элемент массива становится последним, а последний — первым.

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

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

array.reverse()
```

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

Нет.

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

Перевёрнутый массив

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

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

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

### Пример: обращение порядка элементов в массиве

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

```js
var myArray = ["один", "два", "три"];
myArray.reverse();

console.log(myArray); // ['три', 'два', 'один']
```

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

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

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

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

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

* `Array.prototype.join()`
* `Array.prototype.sort()`
* `TypedArray.prototype.reverse()` (en-US)


Array.prototype.splice() - JavaScript

Array.prototype.splice()
========================

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

Метод **`splice()`** изменяет содержимое массива, удаляя существующие элементы и/или добавляя новые.

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

array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
```

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

`start`

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

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

Целое число, показывающее количество старых удаляемых из массива элементов. Если `deleteCount` равен 0, элементы не удаляются. В этом случае вы должны указать как минимум один новый элемент. Если `deleteCount` больше количества элементов, оставшихся в массиве, начиная с индекса `start`, то будут удалены все элементы до конца массива.

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

Необязательные параметры. Добавляемые к массиву элементы. Если вы не укажете никакого элемента, `splice()` просто удалит элементы из массива.

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

Массив, содержащий удалённые элементы. Если будет удалён только один элемент, вернётся массив из одного элемента. Если никакие элементы не будут удалены, вернётся пустой массив.

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

Если количество указанных вставляемых элементов будет отличным от количества удаляемых элементов, массив изменит длину после вызова.

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

### Удаляет 0 элементов по индексу 2 и вставляет "drum"

```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2, 0, "drum");

// myFish равен ["angel", "clown", "drum", "mandarin", "sturgeon"]
// removed равен [], ничего не удалено
```

### Удаляет 1 элемент по индексу 3

```js
var myFish = ["angel", "clown", "drum", "mandarin", "sturgeon"];
var removed = myFish.splice(3, 1);

// removed равен ["mandarin"]
// myFish равен ["angel", "clown", "drum", "sturgeon"]
```

### Удаляет 1 элемент по индексу 2 и вставляет "trumpet"

```js
var myFish = ["angel", "clown", "drum", "sturgeon"];
var removed = myFish.splice(2, 1, "trumpet");

// myFish равен ["angel", "clown", "trumpet", "sturgeon"]
// removed равен ["drum"]
```

### Удаляет 2 элемента начиная с индекса 0 и вставляет "parrot", "anemone" и "blue"

```js
var myFish = ["angel", "clown", "trumpet", "sturgeon"];
var removed = myFish.splice(0, 2, "parrot", "anemone", "blue");

// myFish равен ["parrot", "anemone", "blue", "trumpet", "sturgeon"]
// removed равен ["angel", "clown"]
```

### Удаляет 2 элемента начиная с индекса 2

```js
var myFish = ["parrot", "anemone", "blue", "trumpet", "sturgeon"];
var removed = myFish.splice(myFish.length - 3, 2);

// myFish равен ["parrot", "anemone", "sturgeon"]
// removed равен ["blue", "trumpet"]
```

### Удаляет 1 элемент по индексу -2

```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(-2, 1);

// myFish равен ["angel", "clown", "sturgeon"]
// removed равен s ["mandarin"]
```

### Удаляет все элементы после индекса 2 (включительно)

```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2);

// myFish равен ["angel", "clown"]
// removed равен ["mandarin", "sturgeon"]
```

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

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

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

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

### Обратная совместимость

В JavaScript 1.2 метод `splice()` возвращал удалённый элемент только если был удалён один элемент (параметр `deleteCount` равен 1); в противном случае метод возвращал массив с удалёнными элементами. Обратите внимание, что последним браузером, использующим JavaScript 1.2, был Netscape Navigator 4, так что вы можете считать, что `splice()` всегда возвращает массив.

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

* `push()` / `pop()` — добавление / удаление элементов с конца массива
* `unshift()` / `shift()` — добавление / удаление элементов с начала массива
* `concat()` — возвращает новый массив, состоящий из данного массива, соединённого с другими массивами и/или значениями


Array.prototype[@@unscopables] - JavaScript

Array.prototype[@@unscopables]
==============================

Свойства символа **`@@unscopable`** содержат свойства имён, которые не были включены в ECMAScript до версии ES2015. Эти свойства исключены из привязок оператора `with`.

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

arr[Symbol.unscopables]
```

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

Стандартные свойства массива, которые исключены из привязок `with`: copyWithin, entries, fill, find, findIndex, includes, keys, и values.

См. `Symbol.unscopables` о том, как установить `unscopables` для ваших собственных объектов.

| Атрибуты свойства `Array.prototype[@@unscopables]` |
| --- |
| Записываемое | нет |
| Перечисляемое | нет |
| Настраиваемое | да |

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

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

```js
var keys = [];

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

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

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

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

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

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

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

* `Symbol.unscopables`


Array.of() - JavaScript

Array.of()
==========

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

Разница между **`Array.of()`** и конструктором **`Array`** заключается в обработке целочисленных аргументов: **`Array.of(7)`** создаёт массив с одним элементом `7`, а **`Array(7)`** создаёт пустой массив со значением свойства `length` равным 7 (**Замечание:** подразумевается 7 пустых слотов, а не слоты со значением `undefined`).

```js
Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7); // массив с 7 пустыми слотами
Array(1, 2, 3); // [1, 2, 3]
```

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

Array.of(element0[, element1[, ...[, elementN]]])
```

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

`elementN`

Элементы, из которых создаётся массив.

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

Новый массив `Array`.

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

Эта функция является частью стандарта ECMAScript 6. Для дополнительной информации смотрите предложение по Array.of и Array.from и полифил для Array.of.

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

```js
Array.of(1); // [1]
Array.of(1, 2, 3); // [1, 2, 3]
Array.of(undefined); // [undefined]
```

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

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

```js
if (!Array.of) {
  Array.of = function() {
    return Array.prototype.slice.call(arguments);
    // Or
    let vals = []
    for(let prop in arguments){
        vals.push(arguments[prop])
    }
    return vals.slice()
}
```

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

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

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

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

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

* `Array`
* `Array.from()`
* `TypedArray.of()` (en-US)