JavaScript | Массивы (Array)

Простыми словами

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

Понимание необходимости создания массивов данных. Пример из жизни

Перед вами листок бумаги. Вы смотрите на него. Представьте, что в ваш мозг поступают данные с листка в таком виде:

• 4562
• 15790
• 1216
• 46
• 33562 и т.п..

Так «с ходу» вы не ответите что это за числа, потому что вы не знаете контекст о котором идёт речь (листок не подписан). Можно предполагать что угодно. Это может быть:

• высота над уровнем моря
• количество хвойных деревьев в парке
• температура воздуха на подводной лодке
• количество оборотов лопастей квадрокоптера в минуту
• количество калорий, съеденных человеком за последние 10 минут
• тактовая частота центрального процессора
• давление тормозной жидкости в автокране
• … и тому подобное

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

То есть теперь эти числа составляют «денежный массив«. Теперь все они привязаны к национальной валюте Российской Федерации — рублю (рубль). Также мы понимаем, что это реальные напечатанные бумажные деньги, а не виртуальный счёт в системе какого-то банка. Ещё мы можем связать эти деньги территориально (географически) т.к. все эти данные «денежного массива» перемещаются по одной географической площади (локации с адресом).

Зная контекст данных, мы уже смело можем утверждать, что человек с 46 рублями на кармане вряд ли сможет себе позволить какую-либо покупку. Единственное на что ему скорее всего хватит, так это только на пачку жвачки или маленькую шоколадку. Человек, у которого «на кармане» 33562 рубля сможет позволить себе больше, чем все остальные из толпы.

Контекст данных меняет наше с вами поведение. Зная, что это деньги потенциальных покупателей гипермаркета, можно лучше таргетировать рекламу и не тратить рекламные средства на «пустых» посетителей. От данных нужно одно — они должны быть логически структурированы и связаны. (только так с ними можно будет работать эффективно)

Итоговый вопрос, который должен задавать себе каждый разработчик — «В каких целях будут использоваться данные?» Знание цели поможет корректно сформулировать задачи, которые нужно будет решать.

Проблематика. Как разработчики языков программирования пришли к массивам?

Вернёмся в JavaScript и зададим себе вопрос. Если бы не было массивов, то каким образом мы создавали бы логически связанные наборы данных?

Единственное, чтобы мы использовали — это обычные переменные. Если бы у нас стояла задача создать набор из дней недели, то мы бы сделали 7 переменных и обозвали бы их как-то так:

var ruDay1 = 'Понедельник';
var ruDay2 = 'Вторник';
var ruDay3 = 'Среда';
var ruDay4 = 'Четверг';
var ruDay5 = 'Пятница';
var ruDay6 = 'Суббота';
var ruDay7 = 'Воскресенье';

А теперь представьте, что «нехороший» программист мог бы создать этот набор переменных иначе, например так:

var booGaga = 'Понедельник';
var xYyrhx = 'Вторник';
var sdfe = 'Среда';
var vvd55 = 'Четверг';
var vvv15 = 'Пятница';
var gg = 'Суббота';
var vbx12vfr = 'Воскресенье';

Стало сложнее воспринимать данные, не так ли? Теперь вообще непонятно, что это за переменная с таким именем.

А если они (переменные) будут объявлены в разных частях программы? Если они не будут объявляться друг за другом? А если они будут перезаписаны внутри программы где-то по коду? Жуть.

Разработчики языков пришли к необходимости создания такой синтаксической сущности языка, как «массив»

var ruWeekDays = ['Понедельник','Вторник','Среда','Четверг','Пятница','Суббота','Воскресенье'];

Теперь глядя на массив данных переменной «ruWeekDays» мы можем сразу понять, что речь идёт о строковых значениях дней недели на русском языке с заглавной буквы. К каждому из значений мы сможем обратиться по индексу (номеру положения нужного элемента в последовательности данных массива)

Наполненность массивов в JavaScript

Существует 4 варианта наполненности массивов:

• Пустой массив
• Полный массив
• Неполный массив
• Массив нулевой длины

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

var massiv = [,,,]

var massiv = new Array (44); // длина 44

var massiv = Array (58);  // длина 58

Полный массив содержит какое-либо значение в каждом элементе массива. Это как шкаф с ящиками, где в каждом ящике что-то лежит.

var massiv = [10, 20, 30, 40]

var massiv = ["День", "Ночь", "Утро", "Вечер"]

var massiv = Array.from("efim360.ru")    // Создаст полный массив. Разложит строку на отдельные символы и сделает элементами массива

var massiv = Array.of("efim", "360", ".", "ru")    // Создаст полный массив. 

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

var massiv = [10, , 30, , "День", , "Ночь"]

Массив нулевой длины не содержит элементов. Когда мы объявляем переменную, то мы можем определить для неё тип данных. В нашем случае массив является типом данных языка программирования JavaScript. Это значит, что с подобной переменной можно будет в дальнейшем взаимодействовать как с массивом. Например, её можно будет переписывать разными наборами элементов и применять методы, которые умеют работать только с массивами. Простыми словами, массивом нулевой длины можно заблокировать тип данных переменной — эту переменную, например, никто не сможет превратить в число или строку или булев тип. То есть мы сначала объявляем массив нулевой длины, а потом с ним взаимодействуем.

var massiv = []

var massiv = new Array ();

var massiv = new Array (0);

var massiv =  Array ();

var massiv =  Array (0);

var massiv =  Array.of ();

var massiv = [].concat()

Индексы массива в JavaScript

Мы уже понимаем, что массивы можно наполнять элементами. Но теперь возникает вопрос. Есть ли разница в последовательностях элементов? Если элементы поменять местами, то что изменится? Эти вопросы логичные и правильные. Разница есть.

Каждому элементу массива присваивается свой собственный уникальный числовой индекс. По этому индексу можно обращаться к элементу массива и получать его значение. Хитрость заключается в том, что номера индексов начинаются с нуля «0», а не с единицы «1».

Если мы хотим получить значение первого элемента массива, то нам нужно обратиться к индексу «0». Если мы хотим получить значение двадцать пятого элемента массива, то нам нужно обратиться к индексу «24». Принцип обращения к элементам массива заключается в уменьшении на 1.

Одна из версий почему это так. Возьмите алфавит целых цифр десятичной системы счисления. Это цифры: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Они расположены по возрастанию. Индекс 0 будет соответствовать значению 0, индекс 5 будет соответствовать значению 5. В примере ниже вы увидите изображение в котором сопоставляются индексы и значения этих 10 цифр.

Целочисленный индекс — это ключ свойства со значением String, который является канонической числовой String (см. 7.1.21) и числовое значение которого равно +0 или положительное целое число ≤ 2⁵³ — 1. Индекс массива — это целочисленный индекс, числовое значение которого i находится в диапазоне +0_𝔽  ≤ i < 𝔽(2³² — 1).

Ссылка на «array index» — https://tc39.es/ecma262/#array-index

Максимальное значение индекса массива всегда на единицу меньше длины массива.

Длина массива в JavaScript

У каждого массива есть длина. Интуитивно можно догадаться, что под длиной массива подразумевается количество элементов из которых состоит массив.

Длина массива всегда на единицу больше, чем максимальное значение индекса массива. Если длина массива 16, то максимальный индекс массива будет иметь значение 15. Это знание даёт нам возможность обращаться к последнему элементу массива.

Объект Array — это «экзотический объект», который обеспечивает особую обработку ключей свойства «индекс массива» (см. 6.1.7). Свойство, «имя свойства» которого является «индексом массива», также называется «элементом». Каждый объект Array имеет ненастраиваемое свойство «length» (длина), значение которого всегда является неотрицательным целым числом меньше 2³². Значение свойства «length» (длина) численно больше, чем имя каждого собственного свойства, имя которого является индексом массива; всякий раз, когда создается или изменяется собственное свойство объекта Array, другие свойства корректируются по мере необходимости для поддержания этого инварианта. В частности, всякий раз, когда добавляется собственное свойство, имя которого является «индексом массива», значение свойства «length» (длина) изменяется, если необходимо, чтобы быть на единицу больше, чем числовое значение этого «индекса массива»; и всякий раз, когда значение свойства «длина» изменяется, каждое собственное свойство, имя которого является «индексом массива», значение которого не меньше новой длины, удаляется. Это ограничение применяется только к собственным свойствам объекта Array и не зависит от свойств «длины» или «индекса массива», которые могут быть унаследованы от его прототипов.

Ссылка на «9.4.2 Array Exotic Objects» — https://tc39.es/ecma262/#sec-array-exotic-objects

var massiv = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Речь идёт ТОЛЬКО об элементах. Но мы уже знаем, что элементы могут не иметь содержимого. В результате мы можем получить пустой массив, длиной 3 в котором совершенно нет элементов со значениями.

var massiv = [,,,]

Внимание! Пустой массив, объявленный квадратными скобками имеет длину, равную количеству запятых. Хотя на первый взгляд можно предположить, что длина должна быть 4, но это неверно. Три запятые, значит длина 3. Десять запятых — значит длина 10.

Как узнать длину массива в JavaScript?

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

[1, 2, 3].length     // Набрать в консоли браузера

или

var massiv = [1, 2, 3]     // Набрать в JavaScript файле
console.log(massiv.length)

Длина массива всегда имеет числовой тип данных number.

Как узнать тип данных длины массива в JavaScript?

typeof [1, 2, 3].length     // Набрать в консоли браузера

или

var massiv = [1, 2, 3]     // Набрать в JavaScript файле
console.log(typeof massiv.length)

Объявление массива в JavaScript

Существует 3 способа объявления массивов в JavaScript:

• Через квадратные скобки []
• Через объект Array
• Через функцию-конструктор Array()

Прежде чем взаимодействовать с массивами данных их нужно уметь создавать или получать. Как правило, любая программа начинается с «ничего«. Вы открываете удобный редактор кода и перед вами чистый лист. Если вы сами пишете программу с нуля, то вы — создатель. Вы сами будете создавать переменные, массивы, функции и объекты.

В языках программирования ОБЪЯВЛЕНИЕ чего-либо приравнивается к СОЗДАНИЮ. Разница этих слов заключается лишь в том, что среда разработки не знает о существовании массива, который вы сформировали  своей голове. Поэтому для среды разработки нужно объявлять что-либо. У объявлений есть свои правила написания.

Объявление массива без элементов

var massiv = [];

var massiv = new Array ();

var massiv =  Array ();

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

Каждый массив в таблице присвоен к переменной massiv при помощи языковой конструкции var.

Объявление массива с элементами

var massiv = [1, 2, 3];

var massiv = new Array (1, 2, 3);

var massiv =  Array (1, 2, 3);

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

Каждый массив в таблице присвоен к переменной massiv при помощи языковой конструкции var.

Объявление массива через квадратные скобки []

Чтобы объявить массив нулевой длины через квадратные скобки, нужно последовательно напечатать два знака с клавиатуры:

Первый знак [ (символизирующий начало объявления массива) — это квадратная скобка с горизонтальными отрезками, направленными направо.
Второй знак ] (символизирующий окончание объявления массива) — это квадратная скобка с горизонтальными отрезками, направленными налево.

Оба знака квадратных скобок должны визуально стремиться «замкнуть» друг друга, как бы образуя квадрат/прямоугольник. Так в языке JavaScript определяется массив нулевой длины.

[]

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

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

В полном массиве количество запятых всегда меньше количества самих элементов на 1.

Запятые НЕ СТАВЯТСЯ перед первым элементом массива и после последнего элемента.

Запятые НЕ СТАВЯТСЯ после первой квадратной скобки и перед последней квадратной скобкой.

Элементы массива оформляются согласно стандарту оформления типов данных (числа и булевы значения без доп знаков, строки — в кавычках)

Объявление массива через объект Array

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

• var
• let
• const

После этого ставим пробел и пишем английскими буквами название переменной в которой будет лежать массив. Пробе. Ставим знак клавиатуры равно «=». Этот знак говорит о присваивании того что справа, тому что слева от знака. Пробел. Пишем слово «new». Пробел. Пишем слово «Array». Ставим открывающую круглую скобку «(«. В неё через запятую прописываем наши элементы массива. Ставим закрывающую круглую скобку «)«.

Элементы массива оформляются согласно стандарту оформления типов данных (числа и булевы значения без доп знаков, строки — в кавычках)

Объявление массива через функцию-конструктор Array()

Аналогично объекту Array. Только не нужно прописывать слово «new».

Различия в способах объявления массивов

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

Создавая массив через конструктор Array или функцию-конструктор, можно сразу указать его длину. Для этого нужно будет передать всего один аргумент — числовой (какое-то число).

Свойства конструктора Array

• Array.from
• Array.isArray
• Array.of
• Array.prototype
• get Array

Array.from

Смысл работы from в том, что на выходе мы должны получить массив. Мы можем подавать один, два или три параметра:

1. Если подаём один параметр, то он должен быть массиво-подобным или итерируемым объектом (например при выполнении операции keys() мы получаем итератор массива с ключами). Сюда можно также отнести HTMLCollection, которая создаётся методами, подобно getElementsByTagName().
2. Если подаём два параметра, то вторым должна быть функция, которая будет перерабатывать каждый элемент массива по алгоритму.
3. Если подаём три параметра, то третьим указываем значение, используемое в качестве this (в контексте кого будет вызван)

Метод from вызывается с аргументом «items» и необязательными аргументами «mapfn» и «thisArg«.

Синтаксис: Array.from ( items [ , mapfn [ , thisArg ] ] )

Функция from — это намеренно универсальный фабричный метод; она не требует, чтобы ее это значение было конструктором массива. Поэтому он может быть передан или унаследован любыми другими конструкторами, которые могут быть вызваны с одним числовым аргументом.

Ссылка «22.1.2.1 Array.from» — https://tc39.es/ecma262/#sec-array.from

Если подать одно число, то создастся массив нулевой длины.

var massiv = Array.from(14368538)    // Создаст массив нулевой длины

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

var massiv = Array.from('Аня и Маша')    // Создаст массив. Разложит строку на отдельные символы и сделает элементами массива

Если подать один массив, то мы получим копию подаваемого массива.

var massiv = Array.from(['Коля','Петя'])    // Создаст точно такой же массив

Если подать два числа

var massiv = Array.from(143, 685)    // Выдаст ошибку "Uncaught TypeError: 685 is not a function"

Если подать две строки

var massiv = Array.from('Слон', 'Жираф')    // Выдаст ошибку "Uncaught TypeError: Жираф is not a function"

Если подать два массива

var massiv = Array.from( ['Коля','Петя'] , ['Слон', 'Жираф'] )    // Выдаст ошибку "Uncaught TypeError: [object Array] is not a function"

Подавая два аргумента, метод всегда будет высматривать во втором аргументе функцию. Если подаётся не функция — сразу ошибка.

Array.isArray

isArray проверяет является ли подаваемый параметр массивом или нет. Возвращает истину (true) или ложь (false). Принимает только один параметр.

var massiv90 = [21,20,99]
console.log(Array.isArray(massiv90))   // true

Array.of

of создаёт новый массив из набора передаваемых параметров. Один параметр превратится в элемент массива с индексом «0». В этом и заключается отличие от создания массива через конструктор Array или Функцию-Конструктор Array()

var massiv80 = Array.of(6)      // один параметр
console.log(massiv80)           // [6]
var massiv81 = Array.of(27, 58, true, "жаба")   // четыре параметра
console.log(massiv81)          // [27, 58, true, "жаба"]

Свойства объекта прототипа Array

• concat
• constructor
• copyWithin
• entries
• every
• fill
• filter
• find
• findIndex
• flat
• flatMap
• forEach
• includes
• indexOf
• join
• keys
• lastIndexOf
• map
• pop
• push
• reduce
• reduceRight
• reverse
• shift
• slice
• some
• sort
• splice
• toLocaleString
• toString
• unshift
• values
• @@iterator
• @@unscopables

Array.prototype.concat ( …items )

Как следует из названия метода concat() (конкатенация) — это сложение массивов в один, с сохранением очерёдности массивов и их элементов. Сперва выбираем массив с которого будет стартовать выходной массив — массив, чьи элементы будут первыми в новом массиве. Потом через точку пишем concat() и внутрь круглых скобок через запятую помещаем массивы для сложения в один.

var massiv1000 = ["Меня", "хотят"]      // Стартовый массив. У него вызовем concat()
var massiv1001 = ["соединить", "с"]
var massiv1002 = ["другими", "массивами"]
var massiv1003 = massiv1000.concat()    // Пытаемся сложить без параметров
console.log(massiv1003)    // Получаем Стартовый массив ["Меня", "хотят"]

var massiv1004 = massiv1000.concat(massiv1001)     // Складываем со вторым массивом
console.log(massiv1004)    // результат ["Меня", "хотят", "соединить", "с"]

var massiv1005 = massiv1000.concat(massiv1001, massiv1002)  // Складываем со вторым и третьим массивами
console.log(massiv1005)    // результат ["Меня", "хотят", "соединить", "с", "другими", "массивами"]

Результат выполнения трёх выводов в консоль

На выходе мы получаем массив, сложенный из других массивов.

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

var massiv1020 = [ [5,1] , [6,2] , [7,3] ]
var massiv1021 = [ [8,4] , [9,5] ]
var massiv1022 = [ [0,6] ]
var massiv1023 = massiv1020.concat(massiv1021, massiv1022)
console.log(massiv1023)

Ниже результат в консоли браузера

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

Свойство «length» метода concat равно 1.

Явная установка свойства «length» на шаге 6 необходима для обеспечения правильности его значения в ситуациях, когда конечные элементы массива результатов отсутствуют.

Функция concat() намеренно является универсальной; она не требует, чтобы это значение было объектом массива. Поэтому его можно передать другим видам объектов для использования в качестве метода.

Смотри «22.1.3.1 Array.prototype.concat» — https://tc39.es/ecma262/#sec-array.prototype.concat

Array.prototype.constructor

Начальное значение Array.prototype.constructor — это %Array%.

Array.prototype.copyWithin ( target, start [ , end ] )

Синтаксис: Array.prototype.copyWithin ( target, start [ , end ] )

Метод copyWithin() принимает до трех аргументов: target, start и end.

Выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Пусть relativeTarget будет ? ToIntegerOrInfinity(target).
4. Если relativeTarget равно -∞, пусть to будет 0.
5. В противном случае, если relativeTarget < 0, пусть to будет максимальным max(len + relativeTarget, 0).
6. В противном случае, пусть to будет минимальным min(relativeTarget, len).
7. Пусть relativeStart будет ? ToIntegerOrInfinity(start).
8. Если relativeStart равно -∞, пусть from будет 0.
9. В противном случае, если relativeStart < 0, пусть from будет максимальным max(len + relativeStart, 0).
10. В противном случае, пусть from будет минимальным min(relativeStart, len).
11. Если end не определен - undefined, пусть relativeEnd будет len; иначе пусть relativeEnd будет ? ToIntegerOrInfinity(end).
12. Если relativeEnd равно -∞, пусть final будет 0.
13. В противном случае, если relativeEnd < 0, пусть final будет максимальным max(len + relativeEnd, 0).
14. В противном случае, пусть final будет минимальным min(relativeEnd, len).
15. Пусть count будет минимальным min(final - from, len - to).
16. Если от from < до to и до to < from + count, то
   a. Пусть direction будет -1.
   b. Установить "от" from на "от" from + "количество" count - 1
   c. Установите to на to + count - 1.
17. Иначе,
   a. Пусть направление direction равно 1.
18. Повторить, пока count > 0,
   a. Пусть fromKey будет ! ToString(𝔽(from)).
   b. Пусть toKey будет ! ToString(𝔽(to)).
   c. Пусть fromPresent будет ? HasProperty(O, fromKey).
   d. Если fromPresent истинно - true, то
      i. Пусть fromVal будет ? Get(O, fromKey).
      ii. Выполнить ? Set(O, toKey, fromVal, true).
   e. Иначе,
      i. Утверждение: fromPresent является ложным false.
      ii. Выполнить ? DeletePropertyOrThrow(O, toKey).
   f. Установите from на from + direction.
   g. Установите to на to + direction.
   h. Установить счетчик count на count - 1.
19. Вернуть O

Array.prototype.entries ( )

Выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Вернуть CreateArrayIterator(O, key+value).

Array.prototype.every ( callbackfn [ , thisArg ] )

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

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если IsCallable(callbackfn) имеет значение false, генерировать исключение TypeError
4. Пусть k равно 0.
5. Повторить, пока k < len,
   a. Пусть Pk будет! ToString(𝔽(k)).
   b. Пусть kPresent будет ? HasProperty(O, Pk).
   c. Если kPresent истинно true, то
      i. Пусть kValue будет ? Get(O, Pk).
      ii. Пусть testResult будет ! ToBoolean(? Call(callbackfn, thisArg, «kValue, 𝔽 (k), O»))
      iii. Если testResult имеет значение false, вернуть false.
   d. Установите k на k + 1.
6. Вернуть true

Array.prototype.fill ( value [ , start [ , end ] ] )

Метод fill нужен для заполнения массивов одинаковыми значениями, при этом длина массива не изменяется. Метод fill заменяет элементы массива, на котором он был вызван (не создаёт копию массива).

Если в функцию fill передать один аргумент, то все элементы массива будут перезаписаны на передаваемое значение. Перезапись стартует с индекса 0:

var massiv = [1, 2, 3, 4, 5, 6, 7]
massiv.fill(0)
--итог работы метода fill - вместо цифр нули
[0, 0, 0, 0, 0, 0, 0]

Мы передали число 0 (ноль) в качестве одного аргумента. Все значения элементов массива были заменены на 0.

Вывод в консоль браузера:

Если в функцию fill передать два аргумента, то первый по-прежнему будет являться заменяемым значением, а второй — начальным индексом элемента массива с которого будет начата замена.

var massiv = [1, 2, 3, 4, 5, 6, 7]
massiv.fill(0, 3)
--итог работы метода fill --
[1, 2, 3, 0, 0, 0, 0]

Первым параметром мы передали число 0. Вторым параметром мы передали индекс элемента, на котором произойдёт первое заполнение. Под индексом 3 у нас было число 4, теперь под индексом 3 у нас 0. Значения под индексами 0, 1, 2 остались без изменений т. к. метод fill стартовал с индекса 3 и до конца массива.

Если в функцию fill передать три аргумента, то первый по-прежнему будет являться заменяемым значением; второй — начальным индексом элемента массива с которого будет начата замена; третий — конечным индексом элемента массива которым закончится замена.

var massiv = [1, 2, 3, 4, 5, 6, 7]
massiv.fill(0, 2, 5)
--итог работы метода fill --
[1, 2, 0, 0, 0, 6, 7]

Первым параметром мы передали число 0. Вторым параметром мы передали индекс элемента, на котором произойдёт первое заполнение. Третьим параметром мы передали индекс элемента, на котором произойдёт окончание заполнения. Под индексом 2 у нас было число 3, теперь под индексом 2 у нас 0. Значения под индексами 0, 1 остались без изменений т. к. метод fill стартовал с индекса 2 и до конца массива.

Метод fill принимает до трех значений аргументов: value, start и end.

Выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Пусть relativeStart будет ? ToIntegerOrInfinity(start).
4. Если relativeStart равно -∞, пусть k равно 0.
5. В противном случае, если relativeStart < 0, пусть k будет максимальным max(len + relativeStart, 0).
6. В противном случае, пусть k будет минимальным min(relativeStart, len).
7. Если конец end не определен - undefined, пусть relativeEnd будет len; иначе пусть relativeEnd будет ? ToIntegerOrInfinity(end).
8. Если relativeEnd равно -∞, пусть final будет 0.
9. В противном случае, если relativeEnd < 0, пусть final будет максимальным max(len + relativeEnd, 0).
10. В противном случае, пусть final будет минимальным min(relativeEnd, len).
11. Повторить, пока k < final,
   a. Пусть Pk будет ! ToString(𝔽(k)).
   b. Выполнить ? установить Set(O, Pk, value, true).
   c. Установите k на k + 1.
12. Вернуть O

Array.prototype.filter ( callbackfn [ , thisArg ] )

Когда метод фильтра filter вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если IsCallable(callbackfn) имеет значение false, генерировать исключение TypeError
4. Пусть А будет ? ArraySpeciesCreate(O, 0).
5. Пусть k равно 0.
6. Пусть to будет 0.
7. Повторить, пока k < len,
   a. Пусть Pk будет ! ToString(𝔽(k)).
   b. Пусть kPresent будет ? HasProperty(O, Pk).
   c. Если kPresent истинно true, то
      i. Пусть kValue будет ? Get(O, Pk).
      ii. Пусть selected будет ! ToBoolean(? Call(callbackfn, thisArg, «kValue, 𝔽(k), O»)).
      iii. Если selected верно true, то
         1. Выполнить ? CreateDataPropertyOrThrow(A, ! ToString(𝔽(to)), kValue).
         2. Установить to на to +1
   d. Установите k на k + 1.
8. Вернуть А

Array.prototype.find ( predicate [ , thisArg ] )

Метод find вызывается с одним или двумя аргументами: predicate и thisArg.

Когда вызывается метод find, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если IsCallable(callbackfn) имеет значение false, генерировать исключение TypeError
4. Пусть k равно 0.
5. Повторить, пока k < len,
   a. Пусть Pk будет ! ToString(𝔽(k)).
   b. Пусть kValue будет ? Get(O, Pk).
   c. Пусть testResult будет ! ToBoolean(? Call(predicate, thisArg, «kValue, 𝔽(k), O»)).
   d. Если testResult истинен true, вернуть kValue.
   e. Установите k на k + 1.
6. Вернуть undefined

Array.prototype.findIndex ( predicate [ , thisArg ] )

Когда метод findIndex вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если IsCallable(callbackfn) имеет значение false, генерировать исключение TypeError
4. Пусть k равно 0.
5. Повторить, пока k < len,
   a. Пусть Pk будет ! ToString(𝔽(k)).
   b. Пусть kValue будет ? Get(O, Pk).
   c. Пусть testResult будет ! ToBoolean(? Call(predicate, thisArg, «kValue, 𝔽(k), O»)).
   d. Если testResult истинен true, вернуть kValue.
   e. Установите k на k + 1.
6. Вернуть -1

Array.prototype.flat ( [ depth ] )

Когда вызывается метод flat с нулевым или одним аргументом, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть sourceLen будет ? LengthOfArrayLike(O).
3. Пусть depthNum будет 1.
4. Если глубина depth не определена - undefined, тогда
   a. Установите depthNum равным ? ToIntegerOrInfinity(depth).
   b. Если depthNum < 0, установите depthNum равным 0.
5. Пусть А будет ? ArraySpeciesCreate(O, 0).
6. Выполнить ? FlattenIntoArray(A, O, sourceLen, 0, depthNum).
7. Вернуть A

FlattenIntoArray ( target, source, sourceLen, start, depth [ , mapperFunction, thisArg ] )

Абстрактная операция FlattenIntoArray принимает аргументы target, source, sourceLen (неотрицательное целое число), start (неотрицательное целое число) и depth (неотрицательное целое число или + ∞) и дополнительные аргументы mapperFunction и thisArg. При вызове он выполняет следующие шаги:

1. Утверждение: тип Type(target) - это объект.
2. Утверждение: тип Type(source) - это объект.
3. Утверждение: если присутствует mapperFunction, то ! IsCallable(mapperFunction) имеет значение true, thisArg присутствует, а глубина depth равна 1.
4. Пусть targetIndex будет start.
5. Пусть sourceIndex равен + 0𝔽.
6. Повторите, пока ℝ(sourceIndex) < sourceLen,
   a. Пусть P будет ! ToString(sourceIndex).
   b. Пусть exists будет ? HasProperty(source, P).
   c. Если exists верно true, то
      i. Пусть element будет ? Get(source, P).
      ii. Если присутствует mapperFunction, то
         1. Установить element на ? Call(mapperFunction, thisArg, «element, sourceIndex, source»).
      iii. Пусть shouldFlatten будет ложным false.
      iv. Если глубина depth > 0, то
         1. Установить shouldFlatten на? IsArray(element).
      v. Если shouldFlatten истинно true, то
         1. Если глубина depth равна +∞, пусть newDepth будет +∞.
         2. В противном случае, пусть newDepth будет глубиной depth - 1.
         3. Пусть elementLen будет ? LengthOfArrayLike(element).
         4. Установите targetIndex на ? FlattenIntoArray(target, element, elementLen, targetIndex, newDepth).
      vi. Иначе,
         1. Если targetIndex ≥ 253 - 1, выбросить исключение TypeError.
         2. Выполнить ? CreateDataPropertyOrThrow(target, ! ToString(𝔽(targetIndex)), element).
         3. Установите targetIndex в targetIndex + 1.
   d. Установите для sourceIndex значение sourceIndex + 1𝔽.
7. Вернуть targetIndex

Array.prototype.flatMap ( mapperFunction [ , thisArg ] )

Когда метод flatMap вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть sourceLen будет ? LengthOfArrayLike(O).
3. Если ! IsCallable(mapperFunction) имеет значение false, вызовите исключение TypeError.
4. Пусть А будет ? ArraySpeciesCreate(O, 0).
5. Выполнить ? FlattenIntoArray(A, O, sourceLen, 0, 1, mapperFunction, thisArg).
6. Вернуть A

Array.prototype.forEach ( callbackfn [ , thisArg ] )

Когда метод forEach вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O).
3. Если IsCallable(callbackfn) имеет значение false, генерировать исключение TypeError.
4. Пусть k равно 0.
5. Повторить, пока k < len,
   a. Пусть Pk будет ! ToString(𝔽(k)).
   b. Пусть kPresent будет ? HasProperty(O, Pk).
   c. Если kPresent истинно true, то
      i. Пусть kValue будет ? Get(O, Pk).
      ii. Выполнить ? Call(callbackfn, thisArg, «kValue, 𝔽(k), O»).
d. Установите k на k + 1.
6. Вернуть undefined

Array.prototype.includes ( searchElement [ , fromIndex ] )

Необязательный второй аргумент fromIndex по умолчанию равен +0_𝔽 (т.е. ищется весь массив). Если он больше или равен длине массива, возвращается false, то есть поиск в массиве выполняться не будет. Если он меньше +0_𝔽, он используется как смещение от конца массива для вычисления fromIndex. Если вычисленный индекс меньше +0_𝔽, будет выполнен поиск по всему массиву.

Когда вызывается метод includes, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O).
3. Если len равно 0, вернуть false.
4. Пусть n будет ? ToIntegerOrInfinity(fromIndex).
5. Утверждение: если fromIndex не определено - undefined, то n равно 0.
6. Если n равно +∞, вернуть false.
7. В противном случае, если n равно -∞, установите n равным 0.
8. Если n ≥ 0, то
   a. Пусть k будет n.
9. Иначе,
   a. Пусть k будет len + n.
   b. Если k < 0, установите k равным 0.
10. Повторить, пока k < len,
   a. Пусть elementK будет результатом? Get(O, ! ToString(𝔽(k))).
   b. Если SameValueZero(searchElement, elementK) имеет значение true, вернуть true.
   c. Установите k на k + 1.
11. Вернуть false

Array.prototype.indexOf ( searchElement [ , fromIndex ] )

Когда метод indexOf вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если len равно 0, вернуть -1𝔽.
4. Пусть n будет ? ToIntegerOrInfinity(fromIndex).
5. Утверждение: если fromIndex не определено - undefined, то n равно 0.
6. Если n равно +∞, вернуть -1𝔽.
7. В противном случае, если n равно -∞, установите n равным 0.
8. Если n ≥ 0, то
   a. Пусть k будет n.
9. Иначе,
   a. Пусть k будет len + n.
   b. Если k < 0, установите k равным 0.
10. Повторить, пока k < len,
   a. Пусть kPresent будет? HasProperty(O, ! ToString(𝔽(k))).
   b. Если kPresent истинно true, то
      i. Пусть elementK будет? Get(O, ! ToString(𝔽(k))).
      ii. Пусть same будет результатом выполнения строгого сравнения равенства searchElement === elementK.
      iii. Если same является истиной true, верните 𝔽(k).
   c. Установите k на k + 1.
11. Вернуть -1𝔽

Array.prototype.join ( separator )

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

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

Ссылка «22.1.3.15 Array.prototype.join«- https://tc39.es/ecma262/#sec-array.prototype.join

var massiv1500 = ["Буква", "Б", "Цифра", 1, "Булев", true, "Число", 45678, "Объект", {"a":"a"}]
console.log(massiv1500.join())    // Буква,Б,Цифра,1,Булев,true,Число,45678,Объект,[object Object]
// Без указания разделителя мы получаем запятые в итоговой строке

console.log(massiv1500.join(""))    // БукваБЦифра1БулевtrueЧисло45678Объект[object Object]
// Разделитель в виде пустой строки "" склеивает все элементы массива между собой

console.log(massiv1500.join("<{|}>"))    // Буква<{|}>Б<{|}>Цифра<{|}>1<{|}>Булев<{|}>true<{|}>Число<{|}>45678<{|}>Объект<{|}>[object Object]
// Разделитель в виде строки "<{|}>"

Метод join принимает один аргумент, separator, и выполняет следующие шаги:

1. Пусть O будет ? ToObject(значение this).
2. Пусть len будет ? LengthOfArrayLike(O).
3. Если separator не определен, пусть sep будет одно-элементной строкой ",".
4. Иначе, пусть sep будет ? ToString(separator).
5. Пусть R будет пустым объектом String.
6. Пусть k будет 0.
7. Повторить, пока k < len,
   a. Если k > 0, установите R на конкатенацию строк R и sep. 
   b. Пусть element будет ? Get(O, ! ToString(𝔽(k))). 
   c. Если element является undefined или null, пусть next будет пустой String; иначе пусть next будет ? ToString(element). 
   d. Установите R на конкатенацию строк R и next. 
   e. Установить k на k + 1. 
8. Вернуть R

Array.prototype.keys ( )

Смысл работы keys заключается в получении ключей массива. Как это работает?

Сначала мы определяем массив, из которого будем вытаскивать ключи. (На выходе мы будем желать получить что-то подобное: 0, 1, 2, 3, 4 …. и т.д.). В качестве примера возьмём массив из строковых элементов, чтобы отличать их от ключей (буквы от цифр). Всего их 6 штук.

var massiv1614 = [ "Светло", "Темно", "Тепло", "Холодно", "Белое", "Чёрное" ]

Вторым шагом мы получаем итератор, выбранного нами массива (Array Iterator). Его сохраняем в переменную «a»

var a = massiv1614.keys()

Вывод в консоль переменной «a«, которая содержит «итератор массива»

Array Iterator {}

Теперь мы можем получить ключи и записать их в другой массив. Для этого воспользуемся свойством from конструктора массива Array. Его сохраняем в переменную «b«. Мы запустим прохождение итератора единожды, поэтому результат вывода будет предсказуемым.

var b = Array.from(a)
console.log(b)

Ниже фото консоли браузера

keys использует функцию CreateArrayIterator ( array , kind ). Абстрактная операция CreateArrayIterator принимает «массив аргументов» (array) и «вид» (kind). Эта операция используется для создания «объектов-итераторов» для методов Array, возвращающих такие итераторы. В этой функции kind может быть в трёх вариантах: «key+value», «key» или «value».

Ссылка «» — https://tc39.es/ecma262/#sec-createarrayiterator

Итератор массива — это объект, который представляет собой конкретную итерацию над некоторым конкретным объектом экземпляра массива. Для объектов Array Iterator не существует именованного конструктора. Вместо этого объекты итератора массива создаются путем вызова определенных методов объектов экземпляра массива.

Ссылка «» — https://tc39.es/ecma262/#sec-array-iterator-objects

Теперь попробуем «нарушить» работу итератора массива. На этот раз мы будем передвигаться по итератору при помощи next() и где-то в середине вывода воспользуемся Array.from()

var massiv1613 = [ "Светло", "Темно", "Тепло", "Холодно", "Белое", "Чёрное" ]
var a = massiv1613.keys()
console.log( a.next() , a.next() , Array.from(a) , a.next() , a.next() )

Пять консольных выводов в браузер будут выглядеть так:

Мы видим как из «Итератора Массива» вычерпываются по одному ключи (индексы). Первые два процесса a.next() забирают ключи «0» и «1». Потом свойство from забирает все оставшиеся ключи 2, 3, 4 и 5. На этом элементы первичного массива заканчиваются. Последние два процесса a.next() не находят ключей и возвращают undefined

Похожее поведение встречается у объекта Object. Получение ключей объектов может иметь большую ценность, например, если мы говорим о JSON-файлах. Ссылка https://tc39.es/ecma262/#sec-object.keys

Выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this).
2. Вернуть CreateArrayIterator(O, key).

Array.prototype.lastIndexOf ( searchElement [ , fromIndex ] )

Когда метод lastIndexOf вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если len равно 0, вернуть -1𝔽.
4. Если fromIndex присутствует, пусть n будет? ToIntegerOrInfinity(fromIndex); иначе пусть n будет len - 1.
5. Если n равно -∞, вернуть -1𝔽.
6. Если n ≥ 0, то
   a. Пусть k будет min(n, len - 1).
7. Иначе,
   a. Пусть k будет len + n.
8. Повторять, пока k ≥ 0,
   a. Пусть kPresent будет ? HasProperty(O, ! ToString(𝔽(k))).
   b. Если kPresent истинно true, то
      i. Пусть elementK будет ? Get(O, ! ToString(𝔽(k))).
      ii. Пусть same будет результатом выполнения строгого сравнения равенства searchElement === elementK.
      iii. Если same равен true, верните 𝔽(k).
   c. Установите k на k - 1.
9. Вернуть -1𝔽

Array.prototype.map ( callbackfn [ , thisArg ] )

Когда метод map вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если IsCallable (callbackfn) имеет значение false, выбросить исключение TypeError
4. Пусть A будет ? ArraySpeciesCreate (O, len)
5. Пусть k равно 0
6. Повторить, пока k < len,
   a. Пусть Pk будет ! ToString (𝔽 (k))
   b. Пусть kPresent будет ? HasProperty (O, Pk)
   c. Если kPresent истинно true, то
      i. Пусть kValue будет ? Get(O, Pk)
      ii. Пусть mappedValue будет ? Call(callbackfn, thisArg, «kValue, 𝔽 (k), O»)
      iii. Выполнить ? CreateDataPropertyOrThrow(A, Pk, mappedValue)
   d. Установите k на k + 1
7. Вернуть A

Array.prototype.pop ( )

Когда вызывается метод pop, выполняются следующие шаги:

1. Пусть O будет ? ToObject (значение this).
2. Пусть len будет ? LengthOfArrayLike (O).
3. Если len = 0, тогда
   a. Выполнить ? установить Set(O, "length", +0𝔽, true).
   b. Вернуть undefined
4. В противном случае
   a. Утверждение: len > 0.
   b. Пусть newLen будет 𝔽(len - 1).
   c. Пусть index будет ! ToString(newLen).
   d. Пусть элемент element будет ? получением Get(O, index).
   e. Выполнить ? DeletePropertyOrThrow(O, index).
   f. Выполнить ? установить Set(O, "length", newLen, true).
   g. Вернуть element

Array.prototype.push ( …items)

Когда метод push вызывается с нулевым или большим количеством аргументов, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Пусть argCount будет количеством элементов в items
4. Если len + argCount > 253 - 1, выбросить исключение TypeError
5. Для каждого элемента E из пунктов items выполните:
   a. Выполнить ? установить Set(O, ! ToString(𝔽(len)), E, true)
   b. Установите для len значение len + 1
6. Выполнить ? установить Set(O, "length", 𝔽(len), true)
7. Вернуть 𝔽(len)

Свойство «length» метода push равно 1_𝔽.

Array.prototype.reduce ( callbackfn [ , initialValue ] )

Когда метод reduce вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если IsCallable(callbackfn) имеет значение false, генерировать исключение TypeError.
4. Если len = 0 и initialValue отсутствует, выбросить исключение TypeError.
5. Пусть k равно 0.
6. Пусть accumulator не определен - undefined.
7. Если присутствует initialValue, то
   a. Установите accumulator на initialValue.
8. Иначе,
   a. Пусть kPresent ложно false.
   b. Повторите, пока kPresent имеет значение false и k < len,
      i. Пусть Pk будет ! ToString(𝔽(k)).
      ii. Установите для kPresent значение ? HasProperty(O, Pk).
      iii. Если kPresent истинно true, то
         1. Установить accumulator на ? Get(O, Pk).
      iv. Установите k на k + 1.
   c. Если kPresent имеет значение false, выбросить исключение TypeError.
9. Повторить, пока k < len,
   a. Пусть Pk будет ! ToString(𝔽(k)).
   b. Пусть kPresent будет ? HasProperty(O, Pk).
   c. Если kPresent истинно true, то
      i. Пусть kValue будет ? Get(O, Pk).
      ii. Установить accumulator на ? Call(callbackfn, undefined, «accumulator, kValue, 𝔽(k), O»).
   d. Установите k на k + 1.
10. Вернуть accumulator

Array.prototype.reduceRight ( callbackfn [ , initialValue ] )

Когда метод reduceRight вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если IsCallable(callbackfn) имеет значение false, генерировать исключение TypeError.
4. Если len = 0 и initialValue отсутствует, выбросить исключение TypeError.
5. Пусть k равно len - 1.
6. Пусть accumulator не определен - undefined.
7. Если присутствует initialValue, то
   a. Установите accumulator на initialValue.
8. Иначе,
   a. Пусть kPresent ложно false.
   b. Повторите, пока kPresent имеет значение false и k ≥ 0,
      i. Пусть Pk будет ! ToString(𝔽(k)).
      ii. Установите для kPresent значение ? HasProperty(O, Pk).
      iii. Если kPresent истинно true, то
         1. Установить accumulator на ? Get(O, Pk).
      iv. Установите k на k - 1.
   c. Если kPresent имеет значение false, выбросить исключение TypeError.
9. Повторять, пока k ≥ 0,
   a. Пусть Pk будет ! ToString(𝔽(k)).
   b. Пусть kPresent будет ? HasProperty(O, Pk).
   c. Если kPresent истинно true, то
      i. Пусть kValue будет ? Get(O, Pk).
      ii. Установить accumulator на ? Call(callbackfn, undefined, «accumulator, kValue, 𝔽(k), O»).
   d. Установите k на k - 1.
10. Вернуть accumulator

Array.prototype.reverse ( )

При вызове метода reverse выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Пусть middle будет этажом(len / 2).
4. Пусть lower будет 0.
5. Повторить, пока нижняя lower ≠ средняя middle,
   a. Пусть верхний upper будет len - lower - 1.
   b. Пусть upperP будет ! ToString(𝔽(upper)).
   c. Пусть lowerP будет ! ToString(𝔽(lower)).
   d. Пусть lowerExists будет ? HasProperty(O, lowerP).
   e. Если lowerExists истинно true, то
   i. Пусть lowerValue будет? Get(O, lowerP).
   f. Пусть upperExists будет ? HasProperty(O, upperP).
   g. Если upperExists истинно true, то
   i. Пусть upperValue будет ? Get(O, upperP).
   h. Если lowerExists истинно true, и upperExists истинно true, то
      i. Выполнить ? Set(O, lowerP, upperValue, true).
      ii. Выполнить ? Set(O, upperP, upperValue, true).
   i. Иначе, если lowerExists имеет значение false, а upperExists истинно, тогда
      i. Выполнить ? Set(O, lowerP, upperValue, true).
      ii. Выполнить ? DeletePropertyOrThrow(O, upperP).
   j. Иначе, если lowerExists - истина true, а upperExists - ложь false, то
      i. Выполнить ? DeletePropertyOrThrow(O, lowerP).
      ii. Выполнить ? Set(O, upperP, lowerValue, true).
   k. Иначе,
      i. Утверждение: lowerExists и upperExists являются ложными false.
      ii. Никаких действий не требуется.
   l. Установите lower на lower + 1.
6. Вернуть O

Array.prototype.shift ( )

Когда вызывается метод сдвига shift, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если len = 0, то
   a. Выполнить ? Set(O, "length", +0𝔽, true).
   b. Вернуть undefined
4. Пусть first будет ? Get(O, «0»).
5. Пусть k равно 1.
6. Повторить, пока k < len,
   a. Пусть from быть ! ToString(𝔽(k)).
   b. Пусть to будет ! ToString(𝔽(k - 1)).
   c. Пусть fromPresent будет ? HasProperty(O, from).
   d. Если fromPresent истинно true, то
      i. Пусть fromVal будет ? Get(O, from).
      ii. Выполнить ? Set(O, to, fromVal, true).
   e. Иначе,
      i. Утверждение: fromPresent является ложным false.
      ii. Выполнить ? DeletePropertyOrThrow(O, to).
   f. Установите k на k + 1.
7. Выполнить ? DeletePropertyOrThrow(O, ! ToString(𝔽(len - 1))).
8. Выполнить ? Set(O, "length", 𝔽(len - 1), true).
9. Вернуть first

Array.prototype.slice ( start, end )

Выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Пусть relativeStart будет ? ToIntegerOrInfinity(start).
4. Если relativeStart равно -∞, пусть k равно 0.
5. В противном случае, если relativeStart < 0, пусть k будет max(len + relativeStart, 0).
6. В противном случае пусть k будет min(relativeStart, len).
7. Если конец end не определен - undefined, пусть relativeEnd будет len; иначе пусть relativeEnd будет ? ToIntegerOrInfinity(end).
8. Если relativeEnd равно -∞, пусть final будет 0.
9. В противном случае, если relativeEnd < 0, пусть final будет max(len + relativeEnd, 0).
10. В противном случае пусть final будет min(relativeEnd, len).
11. Пусть count будет max(final - k, 0).
12. Пусть А будет? ArraySpeciesCreate(O, count).
13. Пусть n равно 0.
14. Повторить, пока k < final,
   a. Пусть Pk будет ! ToString(𝔽(k)).
   b. Пусть kPresent будет ? HasProperty(O, Pk).
   c. Если kPresent истинно true, то
      i. Пусть kValue будет ? Get(O, Pk).
      ii. Выполнить ? CreateDataPropertyOrThrow(A, ! ToString(𝔽(n)), kValue).
   d. Установите k на k + 1.
   e. Установите n равным n + 1.
15. Выполнить ? Set(A, "length", 𝔽(n), true).
16. Вернуть A

Array.prototype.some ( callbackfn [ , thisArg ] )

Когда метод some вызывается с одним или двумя аргументами, выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Если IsCallable(callbackfn) имеет значение false, выбросить исключение TypeError.
4. Пусть k равно 0.
5. Повторить, пока k < len,
   a. Пусть Pk будет ! ToString(𝔽(k)).
   b. Пусть kPresent будет ? HasProperty(O, Pk).
   c. Если kPresent истинно true, то
      i. Пусть kValue будет ? Get(O, Pk).
      ii. Пусть testResult будет ! ToBoolean(? Call(callbackfn, thisArg, «kValue, 𝔽(k), O»)).
      iii. Если testResult - истина true, вернуть истину true.
   d. Установите k на k + 1.
6. Вернуть false

Array.prototype.sort ( comparefn )

Элементы этого массива отсортированы. Сортировка должна быть стабильной (то есть элементы, которые сравниваются равными, должны оставаться в исходном порядке). Если comparefn не определен — undefined, это должна быть функция, которая принимает два аргумента x и y и возвращает отрицательное значение, если x < y; ноль, если x = y; или положительное значение, если x > y.

После входа выполняются следующие шаги для инициализации оценки функции сортировки — sort:

1. Если comparefn не является undefined, а IsCallable(comparefn) имеет значение false, генерировать исключение TypeError.
2. Пусть obj будет ? ToObject(значение this).
3. Пусть len будет ? LengthOfArrayLike(obj).

В этой спецификации метода сортировки sort объект obj называется разреженным (sparse), если следующий алгоритм возвращает true:

1. Для каждого целого числа i в диапазоне 0 ≤ i < len выполните
   a. Пусть prop будет ! ToString(𝔽(i))
   b. Пусть elem будет obj.[[GetOwnProperty]](prop).
   c. Если elem не определен - undefined, вернуть true.
2. Вернуть false

«Порядок сортировки» (sort order) — это упорядочение после завершения этой функции значений свойств с целочисленным индексом объекта obj, чьи целочисленные индексы меньше len. Затем результат функции сортировки sort определяется следующим образом:

Если comparefn не undefined и не является последовательной функцией сравнения для элементов этого массива (см. Ниже), порядок сортировки определяется реализацией. Порядок сортировки также определяется реализацией, если comparefn — undefined, а SortCompare не действует как функция согласованного сравнения.

Пусть proto будет obj.[[GetPrototypeOf]](). Если proto не равно null и существует целое число j такое, что все перечисленные ниже условия выполняются, то порядок сортировки определяется реализацией:

• obj разреженный
• 0 ≤ j < len
• HasProperty(proto, ToString(𝔽(j))) верно true.

Порядок сортировки также определяется реализацией, если obj является разреженным и выполняется любое из следующих условий:

• IsExtensible(obj) является false.
• Любое свойство целочисленного индекса объекта obj, имя которого является неотрицательным целым числом меньше len, является свойством данных, атрибут [[Configurable]] которого имеет значение false.

Порядок сортировки также определяется реализацией, если выполняется любое из следующих условий:

• Если obj — экзотический объект (включая экзотические объекты Proxy), поведение которого для [[Get]], [[Set]], [[Delete]] и [[GetOwnProperty]] не является обычной объектной реализацией этих внутренних методов.
• Если любое свойство индекса объекта obj, имя которого является неотрицательным целым числом меньше len, является свойством средства доступа или свойством данных, атрибут [[Writable]] которого имеет значение false.
• Если comparefn не определен — undefined и применение ToString к любому значению, переданному в качестве аргумента в SortCompare, изменяет obj или любой объект в цепочке прототипов obj.
• Если comparefn не определен — undefined , и все приложения ToString для любого конкретного значения, переданного в качестве аргумента в SortCompare, не приводят к одинаковому результату.

Выполняются следующие шаги:

1. Выполните определенную реализацией последовательность вызовов абстрактных операций Get, Set, DeletePropertyOrThrow и HasOwnProperty с obj в качестве первого аргумента и SortCompare (описанного ниже), например:
   1. Аргумент ключа свойства для каждого вызова Get, Set, HasOwnProperty или DeletePropertyOrThrow является строковым представлением неотрицательного целого числа меньше len.
   2. Аргумент Throw для каждого вызова Set имеет значение true.
   3. Аргументы для вызовов SortCompare - это значения, возвращенные предыдущим вызовом абстрактной операции Get, если только свойства, к которым обращались эти предыдущие вызовы, не существовали согласно HasOwnProperty. Если оба предполагаемых аргумента SortCompare соответствуют несуществующим свойствам, используйте +0𝔽 вместо вызова SortCompare. Если не существует только первого предполагаемого аргумента, используйте 1𝔽. Если не существует только второго предполагаемого аргумента, используйте -1𝔽.
   4. Если obj не является разреженным, нельзя вызывать DeletePropertyOrThrow.
   5. Если от любой из этих операций возвращается внезапное завершение, оно немедленно возвращается как значение этой функции.
2. Вернуть obj

Если порядок сортировки не указан выше как определяемый реализацией, возвращаемый объект должен иметь следующие две характеристики:

• Должна существовать некоторая математическая перестановка π неотрицательных целых чисел меньше len, такая, что для каждого неотрицательного целого числа j меньше len, если свойство old[j] существовало, то new [π (j)] было точно таким же значение как old[j]. Но если свойство old[j]  не существует, то нового [π(j)] не существует.
• Затем для всех неотрицательных целых чисел j и k, каждое меньше len, если SortCompare(old[j], old[k]) < 0 (см. SortCompare ниже), то new[π(j)] < new[π (k)].

Здесь обозначение old[j] используется для обозначения гипотетического результата вызова Get(obj, j) до выполнения этой функции, а обозначение new[j] — для обозначения гипотетического результата вызова Get(obj, j) после того, как эта функция была выполнена.

Функция comparefn является последовательной функцией сравнения для набора значений S, если все перечисленные ниже требования выполняются для всех значений a, b и c (возможно, одного и того же значения) в наборе S: Обозначение a < _CF b означает comparefn(a, b) < 0; a = _CF b означает comparefn(a, b) = 0 (любого знака); и a > _CF b означает comparefn(a, b) > 0.

• Вызов comparefn(a, b) всегда возвращает одно и то же значение v, если задана конкретная пара значений a и b в качестве двух его аргументов. Кроме того, Type(v) — это Number, а v — не NaN. Обратите внимание, что это означает, что ровно одно из a < _CF b, a = _CF b и a > _CF b будет истинным для данной пары a и b.
• Вызов comparefn(a, b) не изменяет obj или какой-либо объект в цепочке прототипов obj.
• a = _CF a (рефлексивность)
• Если a = _CF b, то b = _CF a (симметрия)
• Если a = _CF b и b = _CF c, то a = _CF c (транзитивность = CF)
• Если a < _CF b и b < _CF c, то a < _CF c (транзитивность <CF)
• Если a > _CF b и b > _CF c, то a > _CF c (транзитивность> CF)

Примечание 1

Вышеупомянутые условия необходимы и достаточны для обеспечения того, чтобы comparefn делил множество S на классы эквивалентности и что эти классы эквивалентности полностью упорядочены.

Примечание 2

Функция сортировки sort намеренно универсальна; она не требует, чтобы это значение было объектом массива. Следовательно, его можно передать другим видам объектов для использования в качестве метода.

SortCompare ( x, y )

Абстрактная операция SortCompare принимает аргументы x и y. Она также имеет доступ к аргументу comparefn, переданному текущему вызову метода сортировки sort. При вызове она выполняет следующие шаги:

1. Если x и y оба не определены (undefined), верните +0𝔽.
2. Если x не определен (undefined), верните 1𝔽.
3. Если y не определено (undefined), вернуть -1𝔽.
4. Если comparefn не undefined, тогда
   a. Пусть v будет ? ToNumber(? Call(comparefn, undefined, «x, y»)).
   b. Если v равно NaN, вернуть +0𝔽.
   c. Вернуть v
5. Пусть xString будет? ToString(х).
6. Пусть yString будет? ToString(y).
7. Пусть xSmaller будет результатом выполнения абстрактного реляционного сравнения xString < yString.
8. Если xSmaller истинно true, вернуть -1𝔽.
9. Пусть ySmaller будет результатом выполнения абстрактного реляционного сравнения yString < xString.
10. Если ySmaller истинно true, верните 1𝔽.
11. Вернуть +0𝔽

Array.prototype.splice ( start, deleteCount, …items )

Выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть len будет ? LengthOfArrayLike(O)
3. Пусть relativeStart будет ? ToIntegerOrInfinity(start).
4. Если relativeStart равно -∞, пусть actualStart будет 0.
5. Иначе, если relativeStart < 0, пусть actualStart будет max(len + relativeStart, 0).
6. В противном случае пусть actualStart будет min(relativeStart, len).
7. Если start не представлен, то
   a. Пусть insertCount будет 0.
   b. Пусть actualDeleteCount будет 0.
8. Иначе, если deleteCount отсутствует, тогда
   a. Пусть insertCount будет 0.
   b. Пусть actualDeleteCount будет len - actualStart.
9. Иначе,
   a. Пусть insertCount будет количеством элементов в items.
   b. Пусть dc будет ? ToIntegerOrInfinity(deleteCount).
   c. Пусть actualDeleteCount будет результатом ограничения dc между 0 и len - actualStart.
10. Если len + insertCount - actualDeleteCount > 253 - 1, выбросить исключение TypeError.
11. Пусть А будет ? ArraySpeciesCreate(O, actualDeleteCount).
12. Пусть k равно 0.
13. Повторите, пока k < actualDeleteCount,
   a. Пусть from будет ! ToString(𝔽 (actualStart + k)).
   b. Пусть fromPresent будет ? HasProperty(O, from).
   c. Если fromPresent истинно true, то
      i. Пусть fromValue будет ? получением Get(O, from).
      ii. Выполнить ? CreateDataPropertyOrThrow(A, ! ToString(𝔽(k)), fromValue).
   d. Установите k на k + 1.
14. Выполнить ? установить Set(A, «length», 𝔽(actualDeleteCount), true).
15. Пусть itemCount будет количеством элементов в items.
16. Если itemCount < actualDeleteCount, то
   a. Установите k на actualStart.
   b. Повторите, пока k < (len - actualDeleteCount),
      i. Пусть from будет ! ToString(𝔽(k + actualDeleteCount)).
      ii. Пусть to будет! ToString(𝔽(k + itemCount)).
      iii. Пусть fromPresent будет ? HasProperty(O, from).
      iv. Если fromPresent истинно true, то
         1. Пусть fromValue будет ? Get(O, from).
         2. Выполнить ? Set(O, to, fromValue, true).
      v. Иначе,
         1. Утверждение: fromPresent является ложным false.
         2. Выполнить ? DeletePropertyOrThrow(O, to).
      vi. Установите k на k + 1.
   c. Установите k равным len.
   d. Повторите, пока k > (len - actualDeleteCount + itemCount),
      i. Выполнить ? DeletePropertyOrThrow(O, ! ToString(𝔽(k - 1))).
      ii. Установите k на k - 1.
17. Иначе, если itemCount > actualDeleteCount, тогда
   a. Установите k равным (len - actualDeleteCount)
   b. Повторите, пока k > actualStart,
      i. Пусть from будет ! ToString(𝔽(k + actualDeleteCount - 1)).
      ii. Пусть to будет ! ToString(𝔽(k + itemCount - 1)).
      iii. Пусть fromPresent будет ? HasProperty(O, from).
      iv. Если fromPresent истинно, то
         1. Пусть fromValue будет ? получить Get(O, from).
         2. Выполнить ? установить Set(O, to, fromValue, true).
      v. Иначе,
         1. Утверждение: fromPresent является ложным false.
         2. Выполнить ? DeletePropertyOrThrow(O, to).
      vi. Установите k на k - 1.
18. Установите k на actualStart.
19. Для каждого элемента E из пунктов items выполните
   a. Выполнить ? установить Set(O, ! ToString(𝔽(k)), E, true).
   b. Установите k на k + 1.
20. Выполнить ? установить Set(O, "length", 𝔽(len - actualDeleteCount + itemCount), true).
21. Вернуть A

Array.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )

Реализация ECMAScript, включающая API-интерфейс интернационализации ECMA-402, должна реализовывать метод Array.prototype.toLocaleString, как указано в спецификации ECMA-402. Если реализация ECMAScript не включает API ECMA-402, используется следующая спецификация метода toLocaleString.

Выполняются следующие шаги:

1. Пусть массив array будет ? ToObject(значение this).
2. Пусть длина len будет ? LengthOfArrayLike(array).
3. Пусть разделитель separator будет значением String для разделителем списка String, подходящим для текущей локали среды хоста (это получается способом, определяемым реализацией).
4. Пусть R будет пустой строкой.
5. Пусть k равно 0.
6. Повторить, пока k < len,
   a. Если k > 0, то
      i. Установите R на конкатенацию строк R и разделителя separator
   b. Пусть следующий элемент nextElement будет ? Get(array, ! ToString(𝔽(k))).
   c. Если nextElement не undefined или null, то
      i. Пусть S будем ? ToString(? Invoke(nextElement, "toLocaleString")).
      ii. Установите R на конкатенацию строк R и S.
   d. Установите k на k + 1.
7. Вернуть R

Array.prototype.toString ( )

Когда вызывается метод toString, выполняются следующие шаги:

1. Пусть array будет ? ToObject(значение this).
2. Пусть func будет ? получить Get(array, "join").
3. Если IsCallable(func) имеет значение false, установите для func внутреннюю функцию %Object.prototype.toString%.
4. Вернуть ? вызов Call(func, array).

Array.prototype.unshift ( …items )

Когда метод unshift вызывается с нулем или более аргументов item1, item2 и т. д., Выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Пусть длина len будет ? LengthOfArrayLike(array).
3. Пусть argCount будет количеством элементов в items.
4. Если argCount > 0, то
   a. Если len + argCount > 253 - 1, выбросить исключение TypeError.
   b. Пусть k будет len.
   c. Повторить, пока k > 0,
      i. Пусть from будет ! ToString(𝔽(k - 1)).
      ii. Пусть to будет ! ToString(𝔽(k + argCount - 1)).
      iii. Пусть fromPresent будет ? HasProperty(O, from).
      iv. Если fromPresent истинно true, то
         1. Пусть fromValue будет ? Get(O, from).
         2. Выполнить ? Set(O, to, fromValue, true).
      v. Иначе,
         1. Утверждение: fromPresent является ложным false.
         2. Выполнить ? DeletePropertyOrThrow(O, to).
      vi. Установите k на k - 1.
   d. Пусть j равно +0𝔽.
   e. Для каждого элемента E из items выполните
      i. Выполнить ? Set(O, ! ToString(j), E, true).
      ii. Установите j на j + 1𝔽.
5. Выполнить ? Set(O, "length", 𝔽(len + argCount), true).
6. Возврат 𝔽(len + argCount).

Свойство «length» (длина) метода unshift (без сдвига) равно 1_𝔽.

Array.prototype.values ( )

Выполняются следующие шаги:

1. Пусть O будет ? ToObject(значение this)
2. Вернуть CreateArrayIterator(O, value).

Array.prototype [ @@iterator ] ( )

Начальным значением свойства @@iterator является тот же объект функции, что и начальное значение свойства Array.prototype.values.

Array.prototype [ @@unscopables ]

Начальным значением свойства данных @@unscopables является объект, созданный с помощью следующих шагов:

1. Пусть unscopableList будет ! OrdinaryObjectCreate(null)
2. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "copyWithin", true)
3. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "entries", true)
4. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "fill", true)
5. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "find", true)
6. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "findIndex", true)
7. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "flat", true)
8. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "flatMap", true)
9. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "includes", true)
10. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "keys", true)
11. Выполнить ! CreateDataPropertyOrThrow(unscopableList, "values", true)
12. Вернуть unscopableList

Это свойство имеет атрибуты { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

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

Экземпляры массивов — это экзотические объекты массива, для которых заданы внутренние методы. Экземпляры массива наследуют свойства от объекта-прототипа массива.

Экземпляры массивов имеют свойство «длина — length» и набор перечислимых свойств с именами индексов массива.

• length

length

Свойство «длина — length» экземпляра массива — это свойство данных, значение которого всегда численно больше, чем имя каждого настраиваемого собственного свойства, имя которого является индексом массива.

Свойство «length» изначально имеет атрибуты { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

Объекты итератора массива

«Итератор массива» (Array Iterator) — это объект, который представляет собой конкретную итерацию над некоторым конкретным объектом экземпляра массива. Для объектов Array Iterator не существует именованного конструктора. Вместо этого объекты итератора массива создаются путем вызова определенных методов объектов экземпляра массива.

CreateArrayIterator ( array, kind )

Абстрактная операция CreateArrayIterator принимает аргументы: массив array и вид kind. Эта операция используется для создания объектов-итераторов для методов Array, возвращающих такие итераторы. При вызове он выполняет следующие шаги:

1. Утверждение: тип Type(array) - это Объект.
2. Утверждение: kind - это key+value, key, or value (ключ + значение, ключ или значение).
3. Пусть iterator будет ! OrdinaryObjectCreate(%ArrayIteratorPrototype%, «[[IteratedArrayLike]], [[ArrayLikeNextIndex]], [[ArrayLikeIterationKind]]»).
4. Установите iterator.[[IteratedArrayLike]] в array.
5. Установите iterator.[[ArrayLikeNextIndex]] равным 0.
6. Установите для iterator.[[ArrayLikeIterationKind]] в kind.
7. Вернуть iterator

Объект %ArrayIteratorPrototype%

Объект %ArrayIterator Prototype%:

• имеет свойства, которые наследуются всеми объектами Array Iterator.
• это обычный объект.
• имеет внутренний слот [[Prototype]], значение которого %IteratorPrototype%.
• обладает следующими свойствами:

%ArrayIteratorPrototype%.next ( )

1. Пусть O будет значением this.
2. Если тип Type(O) не является объектом, вызовите исключение TypeError.
3. Если O не имеет всех внутренних слотов экземпляра итератора массива (22.1.5.3), выбросить исключение TypeError.
4. Пусть a будет O.[[IteratedArrayLike]].
5. Если a не определено, вернуть CreateIterResultObject(undefined, true).
6. Пусть index будет O.[[ArrayLikeNextIndex]].
7. Пусть itemKind будет O.[[ArrayLikeIterationKind]].
8. Если у a есть внутренний слот [[TypedArrayName]], то
   a. Если IsDetachedBuffer(a.[[ViewedArrayBuffer]]) истинно true, генерирует исключение TypeError.
   b. Пусть len будет a.[[ArrayLength]].
9. Иначе,
   a. Пусть len будет ? LengthOfArrayLike(а).
10. Если index ≥ len, то
   a. Установите для O.[[IteratedArrayLike]] значение undefined.
   b. Вернуть CreateIterResultObject(undefined, true).
11. Установите для O.[[ArrayLikeNextIndex]] значение index + 1.
12. Если itemKind является key, верните CreateIterResultObject(𝔽(index), false).
13. Пусть elementKey будет ! ToString(𝔽(index)).
14. Пусть elementValue будет ? Get(a, elementKey).
15. Если itemKind является value, пусть результатом result будет elementValue.
16. Иначе,
   a. Утверждение: itemKind - это key+value  (ключ + значение).
   b. Пусть result будет ! CreateArrayFromList(«𝔽(index), elementValue»).
17. Вернуть CreateIterResultObject(result, false).

%ArrayIteratorPrototype% [ @@toStringTag ]

Начальным значением свойства @@toStringTag является строковое значение «Array Iterator — Итератор массива».

Это свойство имеет атрибуты { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

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

Экземпляры Array Iterator — это обычные объекты, наследующие свойства от внутреннего объекта %ArrayIteratorPrototype%. Экземпляры Array Iterator изначально создаются с внутренними слотами, перечисленными в Таблице 61.

Полезные ссылки

Раздел «22.1 Array Objects» — https://tc39.es/ecma262/#sec-array-objects

Официальная страница стандарта ECMAScript — https://tc39.es/ecma262/

Официальная страница стандарта ECMAScript — https://www.ecma-international.org/publications/standards/Ecma-262.htm

Свойства конструктора Array

Свойства объекта прототипа Array