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

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

Array.prototype.concat

Как следует из названия метода 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.copyWithin

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

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

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

Array.prototype.entries

Array.prototype.every

Array.prototype.fill

Array.prototype.filter

Array.prototype.find

Array.prototype.findIndex

Array.prototype.flat

Array.prototype.flatMap

Array.prototype.forEach

Array.prototype.includes

Array.prototype.indexOf

Array.prototype.join

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

Функция соединения 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

Array.prototype.map

Array.prototype.pop

Array.prototype.push

Array.prototype.reduce

Array.prototype.reduceRight

Array.prototype.reverse

Array.prototype.shift

Array.prototype.slice

Array.prototype.some

Array.prototype.sort

Array.prototype.splice

Array.prototype.toLocaleString

Array.prototype.toString

Array.prototype.unshift

Array.prototype.values

 

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

  • length

 

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

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

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

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

 

 

 

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