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 massivArray (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 или положительное целое число ≤ 253 — 1. Индекс массива — это целочисленный индекс, числовое значение которого i находится в диапазоне +0𝔽  ≤ i < 𝔽(232 — 1).

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

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

 

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

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

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

Объект Array — это «экзотический объект», который обеспечивает особую обработку ключей свойства «индекс массива» (см. 6.1.7). Свойство, «имя свойства» которого является «индексом массива», также называется «элементом». Каждый объект Array имеет ненастраиваемое свойство «length» (длина), значение которого всегда является неотрицательным целым числом меньше 232. Значение свойства «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]
Полный массив JavaScript из 10 элементов. Длина массива 10
Полный массив JavaScript из 10 элементов. Длина массива 10

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

var massiv = [,,,]

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

Пустые массивы JavaScript длиной 1 и 3 элементов
Пустые массивы JavaScript длиной 1 и 3 элементов

Как узнать длину массива в 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()

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

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

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

Через квадратные скобки [] Через глобальный объект Array Через функцию-конструктор Array()
var massiv = [];
var massiv = new Array ();
var massiv =  Array ();

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

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

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

Через квадратные скобки [] Через глобальный объект Array Через функцию-конструктор Array()
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.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)    // Создаст массив нулевой длины
Массив нулевой длины JavaScript
Массив нулевой длины JavaScript

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

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

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

var massiv = Array.from(['Коля','Петя'])    // Создаст точно такой же массив
JavaScript Array.from из массива
JavaScript 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

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)    // результат ["Меня", "хотят", "соединить", "с", "другими", "массивами"]

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

Array.prototype.concat в JavaScript
Array.prototype.concat в JavaScript

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

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

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)

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

Массив из массивов в JavaScript
Массив из массивов в JavaScript

Когда метод 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

Аргумент «end» является необязательным, при этом по умолчанию используется длина значения this. Если «target» отрицательно, это обрабатывается как «length» + «target«, где «length» — длина массива. Если «start» отрицательно, оно рассматривается как «length» + «start«. Если «end» отрицательный, он обрабатывается как «length» + «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

Примечание 2

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

 

Array.prototype.entries ( )

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

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

 

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

Примечание 1

callbackfn должен быть функцией, которая принимает три аргумента и возвращает значение, которое может быть приведено к логическому значению true или false. every вызывает callbackfn один раз для каждого элемента, присутствующего в массиве, в порядке возрастания, пока не найдет тот, где callbackfn вернет false. Если такой элемент найден, every сразу возвращает false. В противном случае, если callbackfn вернул истину true для всех элементов, каждый вернет истину true. callbackfn вызывается только для реально существующих элементов массива; он не вызывается для отсутствующих элементов массива.

Если указан параметр thisArg, он будет использоваться как значение this для каждого вызова callbackfn. Если он не указан, вместо него используется undefined.

callbackfn вызывается с тремя аргументами: значением элемента, индексом элемента и просматриваемым (обходимым) объектом.

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

Диапазон элементов, обрабатываемых every, устанавливается перед первым вызовом callbackfn. Элементы, которые добавляются к массиву после вызова начала every, не будут посещены callbackfn. Если существующие элементы массива изменяются, их значение, переданное в callbackfn, будет значением на момент их посещения «every»; элементы, которые удаляются после начала вызова «every» и до посещения, не посещаются. every действует как квантор «для всех — for all» в математике. В частности, для пустого массива он возвращает true.

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

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

Примечание 2

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

 

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.

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

JavaScript - метод fill с одним аргументом
JavaScript — метод fill с одним аргументом

Если в функцию 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 и до конца массива.

JavaScript - метод fill с двумя аргументами
JavaScript — метод fill с двумя аргументами

Если в функцию 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 и до конца массива.

JavaScript - метод fill с тремя аргументами
JavaScript — метод fill с тремя аргументами

 

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

Примечание 1

Аргументы начала start и конца end не являются обязательными со значениями по умолчанию 0 и длиной значения this. Если начало start отрицательное, оно рассматривается как длина length + начало start, где длина length — это длина массива. Если конец end отрицательный, он рассматривается как длина length + конец 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

Примечание 2

Функция «заполнения — fill» намеренно универсальна; она не требует, чтобы значение this было объектом массива. Поэтому её можно передать другим видам объектов для использования в качестве метода.

 

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

Примечание 1

callbackfn должна быть функцией, которая принимает три аргумента и возвращает значение, которое может быть приведено к логическому значению true или false. filter вызывает callbackfn один раз для каждого элемента в массиве в порядке возрастания и создает новый массив всех значений, для которых callbackfn возвращает true. callbackfn вызывается только для реально существующих элементов массива; он не вызывается для отсутствующих элементов массива.

Если указан параметр thisArg, он будет использоваться как значение this для каждого вызова callbackfn. Если он не указан, вместо него используется undefined.

callbackfn вызывается с тремя аргументами: значением элемента, индексом элемента и просматриваемым (обходимым) объектом.

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

Диапазон элементов, обрабатываемых фильтром filter, устанавливается перед первым вызовом callbackfn. Элементы, которые добавляются к массиву после начала вызова filter, не будут посещаться callbackfn. Если существующие элементы массива изменены, их значение, переданное в callbackfn, будет значением на момент их посещения filter; элементы, которые удаляются после начала вызова фильтра filter и до посещения, не посещаются.

Когда метод фильтра 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. Вернуть А

Примечание 2

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

 

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

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

Примечание 1

predicate должен быть функцией, которая принимает три аргумента и возвращает значение, которое может быть приведено к логическому значению. find вызывает predicate один раз для каждого элемента массива в порядке возрастания, пока не найдет тот, где предикат вернет true. Если такой элемент найден, find немедленно возвращает значение этого элемента. В противном случае find возвращает значение undefined.

Если указан параметр thisArg, он будет использоваться как значение this для каждого вызова predicate. Если он не указан, вместо него используется undefined.

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

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

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

Когда вызывается метод 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

Примечание 2

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

 

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

Примечание 1

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

Если указан параметр thisArg, он будет использоваться как значение this для каждого вызова predicate. Если он не указан, вместо него используется undefined.

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

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

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

Когда метод 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

 

Примечание 2

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

 

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 ] )

Примечание 1

callbackfn должен быть функцией, которая принимает три аргумента. forEach вызывает callbackfn один раз для каждого элемента, присутствующего в массиве, в порядке возрастания. callbackfn вызывается только для реально существующих элементов массива; она не вызывается для отсутствующих элементов массива.

Если указан параметр thisArg, он будет использоваться как значение this для каждого вызова callbackfn. Если он не указан, вместо него используется undefined.

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

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

Диапазон элементов, обрабатываемых forEach, устанавливается перед первым вызовом callbackfn. Элементы, которые добавляются к массиву после начала вызова forEach, callbackfn не посещаются. Если существующие элементы массива изменены, их значение, переданное в callbackfn, будет значением на момент их посещения forEach; элементы, которые удаляются после начала вызова forEach и до посещения, не посещаются.

Когда метод 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

Примечание 2

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

 

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

Примечание 1

includes сравнивает searchElement с элементами массива в порядке возрастания, используя алгоритм SameValueZero, и, если он найден в любой позиции, возвращает true; в противном случае возвращается false.

Необязательный второй аргумент 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

Примечание 2

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

Примечание 3

Метод include намеренно отличается от аналогичного метода indexOf двумя способами. Во-первых, он использует алгоритм SameValueZero вместо строгого сравнения на равенство, что позволяет обнаруживать элементы массива NaN. Во-вторых, он не пропускает отсутствующие элементы массива, вместо этого обрабатывая их как неопределенные — undefined.

 

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

Примечание 1

indexOf сравнивает searchElement с элементами массива в возрастающем порядке, используя алгоритм строгого сравнения равенства, и, если он найден по одному или нескольким индексам, возвращает наименьший такой индекс; в противном случае возвращается -1𝔽.

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

Когда метод 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𝔽

Примечание 2

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

 

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]
// Разделитель в виде строки "<{|}>"

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)

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

Array.prototype.keys ( ) вывод массива с ключами
Array.prototype.keys ( ) вывод массива с ключами

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() )

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

5 консольных выводов
5 консольных выводов
5 консольных выводов - развёрнуты
5 консольных выводов — развёрнуты

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

 

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

 

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

Примечание 1

lastIndexOf сравнивает searchElement с элементами массива в порядке убывания, используя алгоритм «Строгое сравнение равенства» (Strict Equality Comparison), и, если он найден по одному или нескольким индексам, возвращает наибольший такой индекс; в противном случае возвращается -1𝔽.

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

Когда метод 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𝔽

Примечание 2

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

 

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

Примечание 1

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

Если указан параметр thisArg, он будет использоваться как значение this для каждого вызова callbackfn. Если он не указан, вместо него используется undefined.

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

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

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

Когда метод 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

Примечание 2

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

 

Array.prototype.pop ( )

Примечание 1

Последний элемент массива удаляется из массива и возвращается.

Когда вызывается метод 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

Примечание 2

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

 

Array.prototype.push ( …items)

Примечание 1

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

Когда метод 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𝔽.

Примечание 2

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

 

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

Примечание 1

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

callbackfn вызывается с четырьмя аргументами: previousValue (значение из предыдущего вызова callbackfn), currentValue (значение текущего элемента), currentIndex и просматриваемый объект, по которому совершается обход. При первом вызове этого обратного вызова previousValue и currentValue могут быть одним из двух значений. Если в вызове для уменьшения было указано initialValue, то previousValue будет равно initialValue, а currentValue будет равно первому значению в массиве. Если значение initialValue не было указано, то previousValue будет равно первому значению в массиве, а currentValue будет равно второму. Это ошибка TypeError, если массив не содержит элементов и не указано initialValue.

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

Диапазон элементов, обрабатываемых с помощью reduce, устанавливается перед первым вызовом callbackfn. Элементы, которые добавляются к массиву после начала вызова reduce, не будут посещаться callbackfn. Если существующие элементы массива изменены, их значение, переданное в callbackfn, будет значением на момент их посещения командой reduce; элементы, которые удаляются после начала вызова reduce и до посещения, не посещаются.

Когда метод 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

Примечание 2

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

 

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

Примечание 1

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

callbackfn вызывается с четырьмя аргументами: previousValue (значение из предыдущего вызова callbackfn), currentValue (значение текущего элемента), currentIndex и просматриваемый объект, по которому осуществляется обход. При первом вызове функции previousValue и currentValue могут быть одним из двух значений. Если при вызове метода reduceRight было указано initialValue, то previousValue будет равно initialValue, а currentValue будет равно последнему значению в массиве. Если значение initialValue не было предоставлено, то previousValue будет равно последнему значению в массиве, а currentValue будет равно предпоследнему значению. Это ошибка TypeError, если массив не содержит элементов и не указано initialValue.

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

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

Когда метод 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

Примечание 2

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

 

Array.prototype.reverse ( )

Примечание 1

Элементы массива переставляются в обратном порядке. Объект возвращается в результате вызова.

При вызове метода 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

Примечание 2

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

 

Array.prototype.shift ( )

Примечание 1

Первый элемент массива удаляется из массива и возвращается.

Когда вызывается метод сдвига 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

Примечание 2

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

 

Array.prototype.slice ( start, end )

Примечание 1

Метод slice принимает два аргумента, start и end, и возвращает массив, содержащий элементы массива от начала элемента start до конца элемента end, но не включая его (или до конца массива, если конец не определен). Если начало start отрицательное, оно рассматривается как длина length + начало start, где длина length — это длина массива. Если конец end отрицательный, он обрабатывается как длина length + конец end, где длина length — это длина массива.

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

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

Примечание 2

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

Примечание 3

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

 

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

Примечание 1

callbackfn должен быть функцией, которая принимает три аргумента и возвращает значение, которое может быть приведено к логическому значению true или false. some вызывает callbackfn один раз для каждого элемента, присутствующего в массиве, в порядке возрастания, пока не найдет тот, где callbackfn вернет true. Если такой элемент найден, some сразу возвращает true. В противном случае some возвращает false. callbackfn вызывается только для реально существующих элементов массива; он не вызывается для отсутствующих элементов массива.

Если указан параметр thisArg, он будет использоваться как значение this для каждого вызова callbackfn. Если он не указан, вместо него используется undefined.

callbackfn вызывается с тремя аргументами: значением элемента, индексом элемента и просматриваемым объектом.

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

Диапазон элементов, обрабатываемых some, устанавливается перед первым вызовом callbackfn. Элементы, которые добавляются к массиву после вызова some начала, не будут посещены callbackfn. Если существующие элементы массива изменены, их значение, переданное в callbackfn, будет значением на момент их посещения some; элементы, которые удаляются после начала вызова some и до посещения, не посещаются. some действует как квантор «существует — exists» в математике. В частности, для пустого массива он возвращает false.

Когда метод 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

Примечание 2

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

 

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 и не является последовательной функцией сравнения для элементов этого массива (см. Ниже), порядок сортировки определяется реализацией. Порядок сортировки также определяется реализацией, если comparefnundefined, а SortCompare не действует как функция согласованного сравнения.

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

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

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

  • Если 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𝔽

Примечание 1

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

Примечание 2

Вызов методов, выполняемых абстрактными операциями ToString на шагах 5 и 6, может привести к тому, что SortCompare не будет вести себя как функция согласованного сравнения.

 

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

Примечание 1

Когда метод splice вызывается с двумя или более аргументами start, deleteCount и нулем или более элементами items, элементы deleteCount массива, начинающиеся с начала start «целочисленного индекса«, заменяются элементами items. Возвращается объект массива Array, содержащий удаленные элементы (если есть).

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

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

Примечание 2

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

 

Примечание 3

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

 

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

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

Примечание 1

Первое издание ECMA-402 не включало замену спецификации для метода Array.prototype.toLocaleString.

Значения дополнительных параметров этого метода определены в спецификации ECMA-402; реализации, которые не включают поддержку ECMA-402, не должны использовать эти позиции параметров ни для чего другого.

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

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

Примечание 2

Элементы массива преобразуются в строки с использованием их методов toLocaleString, а затем эти строки объединяются, разделяясь вхождениями разделителя String, который был получен определенным в реализации локалью способом. Результат вызова этой функции должен быть аналогичен результату toString, за исключением того, что результат этой функции должен зависеть от локали.

Примечание 3

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

 

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).

Примечание!

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

 

Array.prototype.unshift ( …items )

Примечание 1

Аргументы добавляются в начало массива, так что их порядок в массиве совпадает с порядком, в котором они появляются в списке аргументов.

Когда метод 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𝔽.

Примечание 2

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

 

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.prototype до спецификации ECMAScript 2015. Эти имена игнорируются для целей привязки оператора with, чтобы сохранить поведение существующего кода, который может использовать одно из этих имен в качестве привязки во внешней области, которая затеняется оператором with, объект привязки которого является объектом Array.

 

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

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

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

  • length

length

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

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

Примечание

Уменьшение значения свойства «длинаlength» имеет побочный эффект удаления собственных элементов массива, индекс массива которых находится между старым и новым значениями длины. Однако не настраиваемые свойства удалить нельзя. Попытка установить для свойства «length» объекта Array значение, которое численно меньше или равно наибольшему числовому собственного свойства имени существующего ненастраиваемого свойства массива, индексированного массивом, приведет к установке длины на числовое значение, которое на единицу больше этого не настраиваемого числового собственного свойства имени. См. 9.4.2.1.

 

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

«Итератор массива» (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. Если indexlen, то
   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.

Внутренний слот Описание
[[IteratedArrayLike]] Итерируемый объект в виде массива.
[[ArrayLikeNextIndex]] Целочисленный индекс следующего элемента, который будет проверяться этим итератором.
[[ArrayLikeIterationKind]] Значение String, определяющее, что возвращается для каждого элемента итерации. Возможные значения: keyvaluekey+value.

Таблица 61: Внутренние слоты экземпляров итераторов массива

 

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

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

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

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

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

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

 

 

Поделись записью