recursal/MDN huggingface dataset:
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()
========================

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

Метод **`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.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[@@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()
==========

Метод **`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)
Array.prototype.flat()
======================

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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


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

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

### `reduce` и `concat`


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

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

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



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

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

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



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



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

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

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

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

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

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

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

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

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

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

arr.shift()
```

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

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

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

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

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

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


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

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

var shifted = myFish.shift();

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

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


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


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

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

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

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

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

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

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.unshift()`
Array.prototype[@@iterator]()
=============================

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

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

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

arr[Symbol.iterator]()
```

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

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


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

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


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

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

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

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

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

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

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

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

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

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

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

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

`valueN`

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

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

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

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

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

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

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

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

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

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

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


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

var alphaNumeric = alpha.concat(numeric);

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

Array[Symbol.species]
```

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

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

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

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

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

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


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


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


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

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

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

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

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

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

* `Array`
* `Symbol.species`
Array.prototype.flatMap()
=========================

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

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

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

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

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

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

`callback`

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

`currentValue`

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

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

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

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

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


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

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

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

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

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

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

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

### `map` и `flatMap`


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

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

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

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


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

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


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

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

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


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

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

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

### `reduce` and `concat`


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


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

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

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

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

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

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

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

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

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

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

Array.isArray(obj)
```

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

`obj`

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

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

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

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

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

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


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

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

### `instanceof` vs `isArray`

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


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

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

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

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


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

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

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

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

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

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

* `Array`