Что такое массивы?

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

              
let arr = [];

Массивы хранят элементы в пронумерованных «ячейках». Нумерация начинается с нуля. Первый элемент массива будет иметь номер 0, второй — 1 и так далее. Номера называют индексами.

Количество доступных ячеек — это длина массива. В JavaScript длина массива обычно совпадает с количеством элементов в нем. Массивы хранят свой размер в свойстве .length:

                  
let arr = [1, 2, 3, 4, 5];

alert(arr.length);
// выведет 5

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

                  
let arr = [1, 2, 3, 4, 5];

const arrFirst = arr[0];
alert(arrFirst);
// выведет 1

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

                
let arr = [1, 2, 3, 4, 5];
arr[5] = 6;
// добавляем элемент под индексом 5

alert(arr);
// выведет 1, 2, 3, 4, 5, 6

arr[8] = 9;
// добавляем элемент под индексом 8, игнорируя пропущенные индексы 6 и 7

alert(arr);
// выведет 1, 2, 3, 4, 5, 6, , , 9
// получился массив с "дыркой"

alert(arr[7]);
// undefined, так как элемент под индексом 7 отсутствует

Методы массивов

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

В нашем справочнике методы массивов разделены на две большие группы, которые различаются возможностью принимать функцию обратного вызова (callback function). Методы, которые не могут принимать колбэк, объединены в первую группу, а методы, принимающие колбэк — во вторую.

Методы, не принимающие callback function

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

Добавление и удаление элементов

pop

Удаляет последний элемент из массива и возвращает его значение.

Если метод применяется к пустому массиву, то возвращаемое значение метода будет undefined.

                        
array.pop();
// не принимает аргументов

Пример:

                              
let fruits = ["Вишня", "Абрикос", "Черника"];

alert(fruits.pop()); // удаляем "Черника" и выводим это значение
                                                          
alert(fruits); // Вишня, Абрикос

Практика

Дан пустой массив, куда нужно добавить элементы и применить метод pop():

                                    let array = 
[
];
  array.pop();
  alert(array);

Исходный массив:

Значение, которое возвращается:

Преобразованный массив:

push

Добавляет один или более элементов в конец массива.

Синтаксис:

                    
array.push(element0, element1, ..., elementN);

Пример:

                          
let fruits = ["Вишня", "Абрикос"];
  
fruits.push("Черника"); // добавляем "Черника"
                                                        
alert(fruits); // выведет Вишня, Абрикос, Черника

Практика

Дан пустой массив, куда нужно добавить элементы и применить метод push():

                                let array = 
[
];
  array.push("Новый элемент");
  alert(array);

Исходный массив:

Преобразованный массив:

shift

Удаляет из массива первый элемент и возвращает его значение.

Если метод применяется к пустому массиву, то возвращаемое значение метода будет undefined.

                    
array.shift();
// не принимает аргументов

Пример:

                          
let fruits = ["Вишня", "Абрикос", "Черника"];
  
alert(fruits.shift()); // удаляем "Вишня" и выводим это значение
                                                        
alert(fruits); // Абрикос, Черника

Практика

Дан пустой массив, куда нужно добавить элементы и применить метод shift():

                                let array = 
[
];
  array.pop();
  alert(array);

Исходный массив:

Значение, которое возвращается:

Преобразованный массив:

unsift

Добавляет элементы в начало массива.

Синтаксис:

                    
array.unshift(element0, element1, ..., elementN);

Пример:

                          
let fruits = ["Абрикос", "Черника"];
  
fruits.unshift("Вишня"); // добавляем "Вишня"
                                                        
alert(fruits); // выведет Вишня, Абрикос, Черника

Практика

Дан пустой массив, куда нужно добавить элементы и применить метод unshift():

                                let array = 
[
];
  array.unshift("Новый элемент");
  alert(array);

Исходный массив:

Преобразованный массив:

splice

Изменяет текущий массив, добавляя, удаляя или замещая элементы.

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

                    
arr.splice(start, deleteCount, element1, ..., elementN)
// начиная с позиции start, метод удаляет deleteCount элементов 
// и вставляет element1, ..., elementN на их место

Параметры:

start — индекс элемента массива, с которого будут удалены из массива и/или добавлены в массив элементы; можно использовать отрицательные значения, в этом случае start расчитывается по формуле arr.length + start;
deleteCount (необязательное значение) — число, определяющее количество удаляемых из массива элементов; если deleteCount равен 0, то элементы не удаляются; если значение deleteCount больше количества оставшихся элементов в массиве, то будут удалены все элементы до конца массива;
elementN (необязательное значение) — добавляемые к массиву элементы. Если не указывать никакого элемента, splice() просто удалит элементы из массива.

Рассмотрим примеры применения метода splice().

Удаление:

                          
let fruits = ["Банан", "Яблоко", "Мандарин"];

alert(fruits.splice(0, 1)); 
// начиная с индекса 0, удалить 1 элемент 
// и вывести удаленный элемент (Банан)
                        
alert(fruits); 
// массив изменился - Яблоко, Мандарин

Замена:

                          
let fruits = ["Банан", "Яблоко", "Мандарин"];

alert(fruits.splice(0, 2, "Манго")); 
// начиная с индекса 0, удалить 2 элемента,
// заменить их на "Манго" 
// и вывести удаленные элементы (Банан, Яблоко)
                        
alert(fruits); 
// измененный массив - Манго, Мандарин

Добавление:

                          
let fruits = ["Банан", "Яблоко", "Мандарин"];

alert(fruits.splice(1, 0, "Манго", "Груша")); 
// начиная с индекса 1, удалить 0 элементов
// и добавить "Манго", "Груша" 
// вернется пустой массив, потому что ничего не было удалено
                        
alert(fruits); 
// массив после преобразования: Банан, Манго, Груша, Яблоко, Мандарин

Практика

Дан пустой массив, куда нужно добавить элементы и применить метод splice() для замены элементов:

                                let array = 
[
];
  array.splice(1, 2, "Новый элемент");
  alert(array);

Исходный массив:

Значение, которое возвращается:

Преобразованный массив:

slice

Извлекает часть массива и возвращает новый массив.
Синтаксис:
```
                    
array.slice(start, end);
                    
                  
```
Параметры:
- start — индекс элемента массива, с которого будут выбраны элементы; если start опущен, то значение по умолчанию будет 0; можно использовать отрицательные значения, в этом случае start расчитывается по формуле arr.length + start;
- end — индекс элемента массива, на котором будет заканчиваться извлечение элементов массива (не включая его); если этот параметр не указан, то будут выбраны все элементы от start и до конца массива; можно использовать отрицательные значения, в этом случае end расчитывается по формуле arr.length + end.
Пример применения метода:
```
                          
let fruits = ["Банан", "Яблоко", "Мандарин"];

alert(fruits.slice(0, 2)); 
// копирует с индекса 0 до индекса 2, не включая его
// вернется Банан, Яблоко
                        
alert(fruits.slice(-1)); 
// копирует с индекса -1 до конца массива
// вернется Мандарин
                          
  
                        
```
Практика
Дан пустой массив, куда нужно добавить элементы и применить метод slice():

let array =
[
];
array.slice(0, 2);

Исходный массив:

Новый массив:

concat

Соединяет массивы и значения в новый массив.

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

                    
array.concat(value1, value2, ..., valueN);

Если какие-либо из аргументов concat() сами являются массивами, то присоединяются элементы этих массивов, а не сами массивы.

                          
let fruits = ["Банан", "Яблоко", "Мандарин"];
let orange = "Апельсин";
let berries = ["Вишня", "Черника", 2];

alert(fruits.concat(orange, berries)); 
// создаёт новый массив, не изменяя исходный
// выведет Банан, Яблоко, Мандарин, Апельсин, Вишня, Черника, 2

Практика

Дан пустой массив, куда нужно добавить элементы и применить метод concat():

                                let array = 
[
];
  let string = "Манго";
  let number = 100;
  let berries = ["Вишня", "Черника"];

  array.concat(string, number, berries);

Исходный массив:

Новый массив:

Преобразование элементов

join

Объединяет все элементы массива в строку.
Преобразует каждый из элементов массива в строку и затем выполняет конкатенацию этих строк, вставляя указанный разделитель между элементами.
```
                        
array.join(separator);
                        
                      
```
separator — необязательный параметр. Это символ или строка для отделения одного элемента массива от следующего в итоговой строке. По умолчанию элементы массива разделяются запятыми. Если разделитель — пустая строка, элементы массива ничем не разделяются. Если array.length === 0, то будет возвращена пустая строка.

join() делает в точности противоположное строковому методу split(). Метод split() разбивает строку на массив по заданному разделителю:
```
                              
let string = "Банан, Яблоко, Мандарин";
let fruits = string.split(', ');
    
for (let fruit of fruits) {
  alert( `Фрукты: ${fruit}.` ); 
} 
// выведет по порядку элементы массива: Фрукты: Банан (и т.д.)
                              
  
                            
```
А сейчас с помощью join() можно преобразовать элементы обратно в строку:
```
                              
let fruits = ["Банан", "Яблоко", "Мандарин"];
let string = fruits.join(', ');
    
alert(string); 
// выведет строку с элементами через запятую и пробел
                              
  
                            
```
Практика
Дан пустой массив, куда нужно добавить элементы и применить метод join():

let array =
[
];
let string = array.join(', ');

Исходный массив:

Новая строка:
sort

Сортирует элементы массива.
Элементы сортируются на месте без создания копии массива.
```
                        
array.sort(compareFunction);
                        
                      
```
Метод sort() может принимать функцию обратного вызова, но это не итерационный метод. sort() изменяет массив на месте, не принимает thisArg и может вызывать обратный вызов несколько раз для одного индекса.

Функция compareFunction — необязательный параметр. Она может применяться для определения порядка элементов.

Если sort() вызывается без аргументов, элементы массива располагаются в алфавитном порядке, то есть по умолчанию элементы сортируются как строки. Метод sort() вызывает функцию String() для каждого элемента, а затем сравнивает строки, даже если массив содержит только числа:
```
                              
let fruits = ["Банан", "Яблоко", "Мандарин"];
fruits.sort();
alert(fruits); 
// выведет Банан, Мандарин, Яблоко

let numbers = [15, 50, 3];
numbers.sort();
alert(numbers); 
// выведет 15, 3, 50 (метод сравнил числа как строки 
// и вывел по возрастанию: "15", "3", "50")
                              
  
                            
```
Во многих случаях требуется совсем не это, поэтому в метод sort() можно передать функцию сравнения, которая упорядочивает два значения.

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

Функция сравнения должна принимать два аргумента — a и b, и возвращать одно из следующих значений:
- Отрицательное число, если значение a «меньше» значения b и должно находиться в отсортированном массиве перед b.
- Ноль, если a и b эквивалентны.
- Положительное число, если значение a «больше» значения b.
Сортировка чисел в порядке возрастания:
```
                              
let numbers = [15, 50, 3, 30, 1, 150];
numbers.sort(function(a, b) {
  return a - b;
});
alert(numbers); 
// выведет 1, 3, 15, 30, 50, 150
                              
  
                            
```
Сортировка чисел в порядке убывания и получение максимального значения:
```
                              
let numbers = [15, 50, 3, 30, 1, 150];
numbers.sort(function(a, b) {
  return b - a;
});
alert(numbers[0]); 
// выведет 150, потому что первый элемент массива
// теперь число с максимальным значением
                              
  
                            
```
Практика
Дан пустой массив, куда нужно добавить числа и применить метод sort(), чтобы отсортировать числа по возрастанию, вывести отсортированный массив и наименьшее число:

let array =
[
];
array.sort(function(a, b) { return a - b; }); let min = array[0];

Исходный массив:

Отсортированный массив:

Наименьшее число:

reverse

Изменяет порядок следования элементов в массиве на обратный.

Синтаксис:

                        
array.reverse();
// не принимает аргументов

Метод reverse() не создаёт новый массив, а изменяет текущий. Это означает, что возвращаемое значение — это только ссылка на исходный массив:

                              
const fruits = ["Банан", "Яблоко", "Мандарин"];
const result = fruits.reverse();
    
alert(result);
// Мандарин, Яблоко, Банан
    
alert(fruits);
// тоже Мандарин, Яблоко, Банан
    
alert(result === fruits);
// true, так как result — это ссылка на исходный массив fruits

Если у массива есть «дырки» между элементами, то reverse() развернёт массив с учётом этих «дырок». Метод создает элементы в массиве, которые заполняют пробелы в нем. Каждый из этих созданных элементов имеет значение undefined:

                              
let fruits = ["Банан", "Яблоко", "Мандарин"];
fruits[5] = "Манго";
// добавим значение "Манго" под индексом 5
    
alert(fruits);
// получился массив с "дыркой" - Банан, Яблоко, Мандарин, , , Манго
alert(fruits[3]);
// undefined, так как элемента нет
    
fruits.reverse();
    
alert(fruits);
// метод развернул массив с учетом "дырок" - Манго, , , Мандарин, Яблоко, Банан

Практика

Дан пустой массив, куда нужно добавить элементы и применить метод reverse():

                                    let array = 
[
];
  array.reverse();

Исходный массив:

Преобразованный массив:

Поиск элементов

includes

Определяет, содержит ли массив определённый элемент.
Возвращает значение true или false. Такой же метод есть и у строк.
```
                        
array.includes(searchElement, fromIndex);
                        
                      
```
fromIndex — необязательный параметр. Это индекс в массиве, с которого нужно начинать поиск элемента searchElement. Если атрибут не указан, то поиск осуществляется с 0 индекса.

Проверим, есть ли искомый элемент в массиве. Поиск идёт с учётом регистра:
```
                              
const fruits = ["Банан", "Яблоко", "Мандарин"];
const banana = fruits.includes("Банан");
alert(banana); 
// true
    
const bananaSmall = fruits.includes("банан");
alert(bananaSmall); 
// false, потому что учитывается регистр
    
const orange = fruits.includes("Апельсин");
alert(orange); 
// false
                              
  
                            
```
Практика
Дан пустой массив, куда нужно добавить элементы, после чего указать искомый элемент и применить метод includes():

const array =
[
];
const element = array.includes
();

Исходный массив:

Результат:
indexOf

Поиск элемента с начала массива.
Возвращает первый индекс искомого элемента.
```
                        
array.indexOf(searchElement, fromIndex);
                        
                      
```
fromIndex — необязательный параметр. Это индекс в массиве, с которого нужно начинать поиск элемента searchElement. Если атрибут не указан, то поиск осуществляется с 0 индекса. Значение параметра может быть отрицательным, в этом случае поиск производится, начиная с индекса array.length + fromIndex по возрастанию.

Если элемент один, то метод возвращает индекс этого элемента. Если элементов много — возвращает индекс первого подходящего элемента. Если элемента в массиве нет — вернёт -1:
```
                              
const fruits = ["Банан", "Яблоко", "Мандарин", "Груша", "Мандарин"];
    
alert(fruits.indexOf("Мандарин"));
// выведет 2 — индекс первого элемента со значением "Мандарин" с начала массива
alert(fruits.indexOf("Манго"));
// выведет -1: такого элемента нет
                              
  
                            
```
Практика
Дан пустой массив, куда нужно добавить элементы, после чего указать искомый элемент и применить метод indexOf():

const array =
[
];
const element = array.indexOf
();

Исходный массив:

Результат:
lastIndexOf

Поиск элемента с конца массива.
Возвращает последний индекс искомого элемента.
```
                        
array.lastIndexOf(searchElement, fromIndex);
                        
                      
```
fromIndex — необязательный параметр. Это индекс в массиве, с которого нужно начинать поиск элемента searchElement. Поиск осуществляется в порядке убывания индекса. Если атрибут не указан, то поиск осуществляется с последнего индекса в массиве. Значение параметра может быть отрицательным, в этом случае поиск производится, начиная с индекса array.length + fromIndex.

Если элемент один, то метод возвращает индекс этого элемента. Если элементов много — возвращает последний индекс искомого элемента в массиве при первом совпадении. Если элемента в массиве нет — вернёт -1:
```
                              
const fruits = ["Банан", "Яблоко", "Мандарин", "Груша", "Мандарин"];
    
alert(fruits.lastIndexOf("Мандарин"));
// выведет 4 - индекс первого элемента со значением "Мандарин" 
// с конца массива (последний индекс элемента)
    
alert(fruits.lastIndexOf("Манго"));
// выведет -1
                              
  
                            
```
Практика
Дан пустой массив, куда нужно добавить элементы, после чего указать искомый элемент и применить метод lastIndexOf():

const array =
[
];
const element = array.lastIndexOf
();

Исходный массив:

Результат:

Методы, возвращающие Array Iterator

entries

Возвращает итератор, который содержит пары ключ/значение по каждому индексу в массиве.
Синтаксис:
```
                        
array.entries();
                        
                      
```
Чтобы понять суть этого метода, нужно знать, что такое итератор.

Итератор — это объект, который отслеживает свою текущую позицию, одновременно получая элементы в коллекции по одному.
- Итератор возвращает объект с двумя свойствами: done и value.
- Итератор предоставляет метод next(), который возвращает следующий элемент в последовательности.
- Когда последовательность завершится, значение value будет равно undefined, а done будет равным true.
entries() возвращает новый объект Array Iterator, который содержит пары ключей и значений для каждого индекса массива:
```
                              
const fruits = ["Банан", "Яблоко", "Мандарин"];
const entries = fruits.entries();
    
alert(entries.next().value); // 0, "Банан"
alert(entries.next().value); // 1, "Яблоко"
alert(entries.next().value); // 2, "Мандарин"
                              
  
                            
```
Чтобы получить пары ключ-значение, оптимально использование цикла for of:
```
                              
const fruits = ["Банан", "Яблоко", "Мандарин"];
const entries = fruits.entries();
    
for (let element of entries) {
  alert(element);
}
// проходим циклом по объекту 
// и выводим пары ключ-значение
                              
  
                            
```
Практика
Дан пустой массив, куда нужно добавить элементы и применить метод entries():

let array =
[
];

let entries = array.entries(); for (let element of entries) { console.log(element); }

Исходный массив:

Результат:
keys

Возвращает итератор, который содержит ключи каждого индекса в массиве.
Синтаксис:
```
                        
array.keys();
                        
                      
```
Чтобы понять суть этого метода, нужно знать, что такое итератор.

Итератор — это объект, который отслеживает свою текущую позицию, одновременно получая элементы в коллекции по одному.
- Итератор возвращает объект с двумя свойствами: done и value.
- Итератор предоставляет метод next(), который возвращает следующий элемент в последовательности.
- Когда последовательность завершится, значение value будет равно undefined, а done будет равным true.
Метод keys() возвращает новый объект Array Iterator, который содержит ключи для каждого элемента в массиве и может быть расширен с помощью метода next():
```
                              
const fruits = ["Банан", "Яблоко", "Мандарин"];
const keys = fruits.keys();
    
alert(keys.next().value); // 0
alert(keys.next().value); // 1
alert(keys.next().value); // 2
alert(keys.next().value); // undefined
                              
  
                            
```
Чтобы получить ключи, оптимально использовать цикл for of:
```
                              
const fruits = ["Банан", "Яблоко", "Мандарин"];
const keys = fruits.keys();
    
for (let key of keys) {
  alert(key);
}
// проходим циклом по объекту 
// и выводим ключи по порядку
                              
  
                            
```
Практика
Дан пустой массив, куда нужно добавить элементы и применить метод keys():

let array =
[
];
let keys = array.keys(); for (let key of keys) { console.log(key); }

Исходный массив:

Результат:
values

Возвращает итератор, который содержит значение для каждого индекса в массиве.
Синтаксис:
```
                        
array.values();
                        
                      
```
Чтобы понять суть этого метода, нужно знать, что такое итератор.

Итератор — это объект, который отслеживает свою текущую позицию, одновременно получая элементы в коллекции по одному.
- Итератор возвращает объект с двумя свойствами: done и value.
- Итератор предоставляет метод next(), который возвращает следующий элемент в последовательности.
- Когда последовательность завершится, значение value будет равно undefined, а done будет равным true.
Пример использования values() с помощью метода next():
```
                              
    const fruits = ["Банан", "Яблоко", "Мандарин"];
    const values = fruits.values();
    
    alert(values.next().value); // Банан
    alert(values.next().value); // Яблоко
    alert(values.next().value); // Мандарин
    alert(values.next().value); // undefined
                              
      
                            
```
Чтобы получить значение каждого индекса, оптимально использовать цикл for of:
```
                              
    const fruits = ["Банан", "Яблоко", "Мандарин"];
    const values = fruits.values();
    
    for (let value of values) {
      alert(value);
    }
    // проходим циклом по объекту 
    // и выводим значения индексов по порядку
                              
      
                            
```
Практика
Дан пустой массив, куда нужно добавить элементы и применить метод values():

let array =
[
];
let values = array.values(); for (let value of values) { console.log(values); }

Исходный массив:

Результат:

Прочие методы

flat

Уменьшает вложенность массива на заданное количество уровней.

Метод flat() возвращает новый массив.

                    
array.flat(depth);

Метод принимает необязательный аргумент depth — количество уровней, на которые нужно уменьшить вложенность. Значение по умолчанию — 1; если вложенность неизвестна, но нужно получить плоский массив, то можно передать аргумент Infinity.

Если массив содержит другие массивы в качестве своих элементов, то метод flat() позволяет уменьшить вложенность, вплоть до полного превращения массива в плоский:

                          
const fruits = [
  'Банан',
  'Яблоко',
  [
    'Мандарин',
    'Апельсин',
    [
      'Груша',
      'Манго'
    ]
  ]
]
// у массива fruits внутри 2 уровня вложенности

alert(fruits.flat());
// выведет Банан, Яблоко, Мандарин, Апельсин, Груша, Манго

console.log(fruits.flat());
// но в консоли будет отображаться массив 
// ['Банан', 'Яблоко', 'Мандарин', 'Апельсин', ['Груша', 'Манго']]
// остался один уровень вложенности ['Груша', 'Манго']

console.log(fruits.flat(2));
// а сейчас в консоли будет отображаться массив 
// ['Банан', 'Яблоко', 'Мандарин', 'Апельсин', 'Груша', 'Манго']
// массив стал плоским

console.log(fruits.flat(Infinity));
// массив также стал плоским

copyWithin

Копирует часть массива в тот же массив.
Метод возвращает массив без изменения размера, т.е. копирует элементы массива в пределах одного массива.
```
                    
array.copyWithin(target, start, end);
                    
                  
```
target — начальный индекс позиции цели, куда копировать элементы.

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

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

При отрицательных значениях индекс, с которого (или до которого) будет произведено копирование, рассчитывается по формуле: length + target (или start, или end).
Метод копирует элементы массива внутри него в позицию, начинающуюся по индексу target. Копия берется по индексам, задаваемым start и end:
```
                          
let fruits = ["Банан", "Яблоко", "Мандарин", "Груша", "Манго"];

alert(fruits.copyWithin(3, 0));
// Банан, Яблоко, Мандарин, Банан, Яблоко
                          
  
                        
```
Как сработал метод?

Под индексом 3 находится элемент "Груша" — это target.

Индекс 0 - элемент "Банан" — это start.

Параметр end не задан, значит, будут скопированы элементы, начиная со start до конца массива.

Метод нашёл индекс 3 и скопировал в него элемент из индекса 0, далее нашёл индекс 4 и скопировал в него элемент из индекса 1. После этого метод завершил работу, так как дошел до конца массива.
Рассмотрим пример с необязательным параметром end:
```
                          
let fruits = ["Банан", "Яблоко", "Мандарин", "Груша", "Манго"];

alert(fruits.copyWithin(-3, 0, -1));
// Банан, Яблоко, Банан, Яблоко, Мандарин
                          
  
                        
```
Как сработал метод в этом примере?

target: -3. Значит, цель — индекс 2 со значением "Мандарин".

start: индекс 0 со значением "Банан".

end: -1. Значит, конечная точка — индекс 4 со значением "Манго".

Метод помещает последовательность "Банан", "Яблоко", "Мандарин", "Груша", "Манго" в исходный массив, начиная с индекса 2 (значение "Мандарин") и заканчивая индексом 4. Поскольку метод copyWithin() не изменяет длину массива, в итоге мы получим массив ["Банан", "Яблоко", "Банан", "Яблоко", "Мандарин"].

Для наглядности заменим значения на цифры — вместо ["Банан", "Яблоко", "Мандарин", "Груша", "Манго"] возьмём массив [1, 2, 3, 4, 5]. В итоге с помощью метода copyWithin() получится массив [1, 2, 1, 2, 3].
```
                        
[1, 2, 3, 4, 5]        исходный массив
 0  1  2  3  4         индексы с начала масcива
-5 -4 -3 -2 -1         индексы с конца масcива
 ^     ^     ^         параметры метода
 |     |     *-------- end
 |     *-------------- target      
 *-------------------- start
[1, 2, 3, 4, 5]        исходный массив
[      1, 2, 3, 4, 5]  копируемые значения
[1, 2, 1, 2, 3]        результат (массив сохраняет длину)
                        
                      
```
fill

Заполняет массив указанным значением.
Синтаксис:
```
                    
array.fill(value, start, end);
                    
                  
```
Параметры:
- value — значение, которым будет заполнен массив;
- start (необязательный параметр) — индекс элемента, с которого начинается заполнение массива (по умолчанию — 0); допускается использование отрицательных значений, в этом случае индекс рассчитывается по формуле array.length + start;
- end (необязательный параметр) — индекс элемента, на котором заканчивается заполнение массива (по умолчанию — array.length); допускается использование отрицательных значений, в этом случае индекс рассчитывается по формуле array.length + end;
Метод заполняет все элементы массива от начального до конечного индексов одним значением и изменяет существующий массив, а не возвращает новый:
```
                          
const fruits = ["Банан", "Яблоко", "Мандарин", "Груша"];

alert(fruits.fill("Манго", 2, 4)); 
// заполнить массив значением "Манго" со 2 по 4 индекс
// выведет Банан, Яблоко, Манго, Манго

alert(fruits.fill("Манго", 1)); 
// заполнить массив значением "Манго" с 1 индекса
// выведет Банан, Манго, Манго, Манго

alert(fruits.fill("Манго")); 
// заполнить весь массив значением "Манго"
// выведет Манго, Манго, Манго, Манго
                          
  
                        
```

toLocaleString

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

Синтаксис:

                    
array.toLocaleString();

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

Object: Object.prototype.toLocaleString();
Number: Number.prototype.toLocaleString();
Date: Date.prototype.toLocaleString();

Пример использования метода:

                          
// создадим массив с разными типами элементов:

const arr = [5, "Яблоко", new Date()];

alert(arr.toLocaleString()); 
// выведет значение переменной arr, преобразованной
// с помощью метода в строку:
// 5, Яблоко, XX.XX.XXXX, XX:XX:XX (актуальная дата и время)

Методы, принимающие callback function

Все методы этой категории принимают в качестве аргумента функцию обратного вызова — callback function. Эта функция выполняется последовательно и не более одного раза для каждого элемента в массиве.

            
array.method(callback, thisArg);

callback принимает следующие основные параметры:

element — элемент массива в текущей итерации;
index — индекс текущего элемента;
arr — сам массив, который мы перебираем.

У некоторых методов есть и дополнительные параметры колбэка.

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

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

Кроме того, такие методы могут принимать необязательный параметр thisArg. Это объект, на который может ссылаться ключевое слово this в функции callback. Если аргумент thisArg не указан, в качестве значения this используется undefined. Аргумент thisArg не имеет значения для любого колбэка, определенного с помощью стрелочной функции, поскольку стрелочные функции не имеют собственной привязки this.

Перебор и преобразование массивов

forEach

Применяет колбэк-функцию ко всем элементам массива. Можно использовать вместо классического цикла for.

Синтаксис:

                      
array.forEach(callback(element, index, arr), thisArg);

Метод позволяет удобно получать элемент в текущей итерации, без необходимости всякий раз обращаться к массиву по индексу. В forEach() не будут работать return, break и continue:

                            
const fruits = ["Банан", "Яблоко", "Мандарин"];
fruits.forEach((element, index, arr) => {

alert('Элемент: ' + element);
alert('Его индекс: ' + index);
alert('Массив: ' + arr);
// выведет последовательно: 
// Элемент: Банан => Его индекс: 0 => Массив: Банан, Яблоко, Мандарин
// Элемент: Яблоко => Его индекс: 1 => Массив: Банан, Яблоко, Мандарин
// Элемент: Мандарин => Его индекс: 2 => Массив: Банан, Яблоко, Мандарин
})

Практика

Дан пустой массив, куда нужно добавить числа и применить метод forEach() для вычисления квадрата:

                                  let array = 
[
];
  let arraySquare = [];
  
  array.forEach(function (num) {
    let square = num * num;
    arraySquare.push(square);
  })

Исходный массив:

Новый массив:

map

Создает новый массив с результатом вызова функции-колбэка для каждого элемента массива.

Переданная функция будет вызвана для каждого элемента по порядку.

                      
array.map(callback(element, index, arr), thisArg);

Возвращает новый массив, при этом исходный массив никак не изменится:

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

const squares = array.map(function (num) {
    return num * num;
})

alert(squares);
// выведет новый массив: 1, 4, 9, 16, 25

alert(array);
// исходный массив не изменился: 1, 2, 3, 4, 5

Разберем тот же пример через классический цикл for:

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

const squares = [];
for (let i = 0; i < array.length; i++) {
  const num = array[i];
  const numSquare = num * num;
  squares.push(numSquare);
}

alert(squares);
// выведет новый массив: 1, 4, 9, 16, 25

Практика

Дан пустой массив, куда нужно добавить числа и применить метод map(), чтобы прибавить к каждому числу единицу:

                                  let array = 
[
];
  let arrayPlusOne = array.map(function (num) {
    return num + 1;
  })

Исходный массив:

Новый массив:

reduce

Используется для вычисления на основе массива какого-либо единого значения. Применяет функцию к аккумулятору и каждому значению массива слева-направо.

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

                      
array.reduce(callback(accumulator, element, index, array), initialValue);

Сама функция-колбэк в методе reduce() может принимать четыре параметра:

accumulator — текущее значение аккумулятора;
element — элемент массива в текущей итерации;
index — индекс текущего элемента;
array — сам массив, который мы перебираем.

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

Чтобы разобрать работу метода со всеми аргументами, вычислим сумму всех элементов массива, а после определим среднее арифметическое:

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

// создадим функцию-колбэк, которая суммирует числа 
// и вычисляет среднее арифметическое:
function findAverage(accumulator, element, index, array) {
  const sum = accumulator + element;

  // Если мы находимся на последнем элементе,
  // вычисляем среднее арифметическое делением 
  // на количество элементов:
  if (index === array.length - 1) {
    return sum / array.length;
  }

  return sum;
}

// помещаем функцию-колбэк в метод reduce и задаем 
// начальное значение для аккумулятора (равное 0):
const average = array.reduce(findAverage, 0);

alert(average);
// выведет среднее арифметическое элементов массива: 3

Запишем пример кода более лаконично:

                      
const array = [1, 2, 3, 4, 5]; 
const average = array.reduce(function (accumulator, element, index, array) {
    const sum = accumulator + element;
    if (index === array.length - 1) {
        return sum / array.length;
    }
  return sum;
}, 0);

Тот же пример, написанный через классический цикл for:

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

let sum = 0;
for(let i = 0; i < array.length; i++){
  sum = sum + array[i]; 
}
let average = sum / array.length;

alert(average);
// также выведет среднее арифметическое элементов массива: 3

Практика

Дан пустой массив, куда нужно добавить числа и применить метод reduce(), чтобы вычислить сумму всех элементов массива:

                                  const numbers = 
[
];
  const sum = numbers.reduce(function (accumulator, element) {
    return accumulator + element;
  }, 0)

Исходный массив:

Результат:

reduceRight

Работает точно так же, как и reduce(), но применяет функцию к аккумулятору и каждому значению массива справа налево, сводя его к одному значению.

reduceRight() не выполняет функцию для элементов массива без значений.

                      
array.reduceRight(callback(accumulator, element, index, array), initialValue);

Сама функция-колбэк в методе reduceRight() может принимать четыре параметра:

accumulator — текущее значение аккумулятора;
element — элемент массива в текущей итерации;
index — индекс текущего элемента;
array — сам массив, который мы перебираем.

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

// создадим функцию-колбэк, которая суммирует числа
// и вычисляет среднее арифметическое:
function findAverage(accumulator, element, index, array) {
  const sum = accumulator + element;

  // Если мы прошли весь цикл и находимся на первом элементе
  // (так как применяется метод reduceRight, перебор элементов
  // будет идти справа налево — от последнего к первому),
  // вычисляем среднее арифметическое делением 
  // на количество элементов:
  if (index === 0) {
    return sum / array.length;
  }

  return sum;
}

// помещаем функцию-колбэк в метод reduceRigth и задаем 
// начальное значение для аккумулятора (равное 0):
const average = array.reduceRight(findAverage, 0);

alert(average);
// выведет среднее арифметическое элементов массива: 3

Запишем пример кода более лаконично:

                      
const array = [1, 2, 3, 4, 5]; 
const average = array.reduceRight(function (accumulator, element, index, array) {
    const sum = accumulator + element;
    if (index === 0) {
        return sum / array.length;
    }
  return sum;
}, 0);

Тот же пример, написанный через классический цикл for:

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

let sum = 0;

// проходимся циклом по массиву справа налево:
for(let i = array.length - 1; i >= 0; i--){
  sum = sum + array[i]; 
}
let average = sum / array.length;

alert(average);
// также выведет среднее арифметическое элементов массива: 3

Практика

Дан пустой массив, куда нужно добавить числа и применить метод reduceRight(), чтобы вычесть числа справа налево, при этом массив должен быть отсортирован по возрастанию чисел, чтобы вычитание происходило из большего числа:

                                  const numbers = 
[
];
  numbers.sort(function(a, b) {
    return a - b;
  });
  
  const subtraction = numbers.reduceRight(function (accumulator, element) {
    return accumulator - element;
  });

Исходный массив:

Отсортированный массив:

Результат:

filter

Фильтрует элементы с помощью переданной колбэк-функции.
Позволяет получить новый массив, при этом исходный массив никак не изменится. Колбэк-функция будет вызвана для каждого элемента массива и по результату функции примет решение: включать этот элемент в новый массив или нет.
```
                      
array.filter(callback(element, index, array), thisArg);
                      
                    
```
Функция должна возвращать boolean, т.е. результатом должен быть true или false. Такие функции называют предикатами.

Рассмотрим пример, в котором нужно отфильтровать массив и вернуть новый только с нечетными числами:
```
                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

const arrayOdds = array.filter(function (num) {
  return num % 2 !== 0;
})

alert(arrayOdds);
// выведет новый массив с нечетными числами: 1, 3, 5
                            
  
                          
```
Тот же пример через классический цикл for:
```
                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

const arrayOdds = [];
for (let i = 0; i < array.length; i++) {
  if (array[i] % 2 !== 0) {
    arrayOdds.push(array[i]);
  };
}

alert(arrayOdds);
// также выведет новый массив: 1, 3, 5
                            
  
                          
```
Практика
Дан пустой массив, куда нужно добавить числа и применить метод filter(), чтобы найти все чётные числа:

const array =
[
];
let arrayEven = array.filter(function (num) { return num % 2 == 0; })

Исходный массив:

Отфильтрованный массив:

every

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

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

                      
array.every(callback(element, index, array), thisArg);

Проверим, все ли числа в массиве больше или равны единице:

                            
const array = [1, 2, 3, 4, 5]; 
const arrayNums = array.every(function (num) {
  return num >= 1;
})

alert(arrayNums);
// выведет true, потому что все числа в массиве больше 1

Пример через классический цил for:

                            
const array = [1, 2, 3, 4, 5]; 
const arrayNums = function (array) {
  for(let i = 0; i < array.length; i++){
    if(array[i] >= 1){
      return true;
    }
  }
  return false;
}


alert(arrayNums(array));
// также выведет true

Практика

Дан пустой массив, куда нужно добавить элементы и применить метод every(), чтобы узнать, все ли элементы одинаковые:

                                  const array = 
[
];
  const arrayElements = array.every(function (element) {
    return element === array[0];
  })

Исходный массив:

Результат:

some

Позволяет узнать, есть ли в массиве хотя бы один элемент, удовлетворяющий условию в функции-колбэке.

Колбэк-функция будет вызываться для каждого элемента массива до тех пор, пока не вернётся true, либо пока не закончатся элементы массива.

                      
array.some(callback(element, index, array), thisArg);

Проверим, есть ли в массиве хотя бы одно нечетное число:

                            
const array = [1, 2, 3, 4, 5]; 
const arrayNums = array.some(function (num) {
  return num % 2 !== 0;
})

alert(arrayNums);
// выведет true, потому что в массиве есть нечетное число

Пример через классический цил for:

                            
const array = [1, 2, 3, 4, 5]; 
const arrayNums = function (array) {
  for(let i = 0; i < array.length; i++){
    if(array[i] % 2 !== 0){
      return true;
    }
  }
  return false;
}


alert(arrayNums(array));
// также выведет true

Практика

Дан пустой массив, куда нужно добавить числа и применить метод some(), чтобы узнать, есть ли в массиве хотя бы одно четное число:

                                  const array = 
[
];
  const arrayNums = array.some(function (num) {
    return num % 2 === 0;
  })

Исходный массив:

Результат:

flatMap

Применяется для трансформации исходных данных с уменьшением вложенности.

Метод идентичен последовательному вызову map().flat() с параметром depth = 1. Был добавлен в стандарте ES2019. Если вы поддерживаете браузеры, выпущенные раньше 2018 года, то понадобится полифил.

                      
array.flatMap(callback(element, index, array), thisArg);

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

                        
const array = [1, 2, 3]; 
// исходный массив

// напишем функцию, которая возвращает массив из элементов
// и дублирует их:

const duplicate = function (element) {
return [element, element];
}

Если применить функцию к массиву, получим вложенный массив:

                            
const array = [1, 2, 3]; 

const duplicate = function (element) {
  return [element, element];
}

// применим функцию к массиву, трансформируя его с помощью map:

alert(array.map(duplicate));
console.log(array.map(duplicate));
// выведет вложенный массив [[1, 1], [2, 2], [3, 3]]

Извлечь вложенные массивы можно с помощью flat:

                            
const array = [1, 2, 3]; 

const duplicate = function (element) {
  return [element, element];
}

// добавляем метод flat к методу map:

alert(array.map(duplicate).flat()); 
console.log(array.map(duplicate).flat());
// выведет готовый результат — [1, 1, 2, 2, 3, 3]

В функциональном программировании такие действия с массивами встречаются часто. Поэтому появился метод flatMap(), который упрощает код. Данный метод более эффективный, чем вызов map().flat() по отдельности, поскольку обход массива совершается только один раз:

                            
const array = [1, 2, 3]; 

const duplicate = function (element) {
  return [element, element];
}

alert(array.flatMap(duplicate)); 
console.log(array.flatMap(duplicate));
// выведет готовый результат — [1, 1, 2, 2, 3, 3]

Практика

Дан пустой массив, куда нужно добавить числа и применить метод flatMap(), чтобы сформировать на основе исходного массива новый массив из элементов и их квадратов:

                                  const array = 
[
];
  const duplicateSquare = array.flatMap(function (element) {
    return [element, element**2];
  });

Исходный массив:

Новый массив:

Поиск элементов

find

Возвращает первый найденный в массиве элемент, который подходит под условие в переданной функции.

Если в массиве не найдётся ни одного подходящего элемента, то вернётся значение undefined.

                      
array.find(callback(element, index, array), thisArg);

Функция должна возвращать булевое значение true или false. find() вернёт первый элемент, на котором переданная функция-колбэк вернула true. Попробуем найти число в массиве:

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

const arrayFind = array.find(function (element) {
  return element === 2;
});
// колбэк вернул true, потому что в массиве есть число 2

alert(arrayFind);
// выведет значение найденного элемента: 2

Этот же пример, написанный с помощью классического цикла for:

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

const arrayFind = (array) => {
  for (let i = 0; i < array.length; i++) {
    if (array[i] === 2) {
      return array[i];
    }
  }
  return undefined;
};

alert(arrayFind(array));
// также выведет значение: 2

Практика

Дан пустой массив, куда нужно добавить числа и применить метод find(), чтобы узнать, есть ли там число 5:

                                  const array = 
[
];
  const arrayFind = array.find(function (element) {
    return element === 5;
  });

Исходный массив:

Результат:

findIndex

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

Если ни одного подходящего элемента не найдётся, то метод вернёт -1.

                      
array.findIndex(callback(element, index, array), thisArg);

Для примера возьмём два массива: в одном будут разные числа, во втором — только чётные. И попробуем найти в каждом массиве нечетное число и вернуть его индекс:

                            
const array = [1, 2, 3, 4, 5]; 
const arrayEven = [2, 4, 6];
// исходные массивы

// напишем функцию, которая будет искать нечетные числа:
function isOdd(element) {
  return element % 2 !== 0;
}

// применим метод find(), куда поместим функцию isOdd:

alert(array.findIndex(isOdd));
// выведет 0 — это индекс первого нечетного числа в массиве

alert(arrayEven.findIndex(isOdd));
// выведет -1, потому что в этом массиве нет нечетных чисел

Тот же пример через классический цикл for:

                            
const array = [1, 2, 3, 4, 5]; 
const arrayEven = [2, 4, 6];
// исходные массивы

// напишем функцию-предикат,
// которая вернет true или false:

function isOdd(element) {
  return element % 2 !== 0
}

// напишем функцию, которая будет принимать 2 аргумента:
// массив и функцию-предикат:

function findIndex(array, predicate) {
  for (let i = 0; i < array.length; i++) {

    // Если элемент удовлетворяет условию,
    // то возвращаем его индекс
    if (predicate(array[i])) {
      return i;
    }
  }
  return -1
}

// подставим в функцию findIndex наши аргументы - 
// массивы array и arrayEven, а также функцию isOdd

alert(findIndex(array, isOdd));
// выведет 0 — это индекс первого нечетного числа в массиве

alert(findIndex(arrayEven, isOdd));
// выведет -1, потому что в этом массиве нет нечетных чисел

Практика

Дан пустой массив, куда нужно добавить числа и применить метод findIndex(), чтобы узнать, есть ли в массиве четное число, и в случае успеха, вернуть его индекс:

                                  const array = 
[
];
  const arrayFindEven = array.findIndex(function (element) {
    return element % 2 === 0;
  });

Исходный массив:

Результат:

findLast

Возвращает первый найденный с конца массива элемент, который подходит под условие в переданной функции.

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

                      
array.findLast(callback(element, index, array), thisArg);

Функция должна возвращать булевое значение true или false. findLast() вернёт первый элемент с конца массива, на котором переданная функция-колбэк вернула true. Попробуем найти наибольшее четное число:

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

const arrayEven = array.findLast(function (element) {
  return element % 2 === 0;
});
// колбэк вернул true, потому что в массиве есть четные числа

alert(arrayEven);
// выведет значение найденного элемента: 4

Этот же пример, написанный с помощью классического цикла for:

                            
const array = [1, 2, 3, 4, 5]; 
// исходный массив

const arrayEven = (array) => {
  let even = [];
  for (let i = 0; i < array.length; i++) {
      if (array[i] % 2 === 0) {
          even.push(array[i]);
      } 
  }

  if(even.length !== 0) {
      even.sort(function(a, b) {
          return b - a;
      });
      return even[0];
  }
  
  return undefined;
};

alert(arrayEven(array));
// также выведет значение: 4

Практика

Дан пустой массив, куда нужно добавить числа и применить метод findLast(), чтобы узнать, есть ли там нечетные числа, и вернуть наибольшее:

                                  const array = 
[
];
  const arrayOdd = array.findLast(function (element) {
    return element % 2 !== 0;
  });

Исходный массив:

Результат:

findLastIndex

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

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

                      
array.findLastIndex(callback(element, index, array), thisArg);

Для примера возьмём два массива: в одном будут разные числа, во втором — только чётные. И попробуем найти в каждом массиве нечетные числа и вернуть индекс последнего:

                            
const array = [1, 2, 3, 4, 5]; 
const arrayEven = [2, 4, 6];
// исходные массивы

// напишем функцию, которая будет искать нечётные числа:
function isOdd(element) {
  return element % 2 !== 0;
}

// применим метод findLastIndex(), куда поместим функцию isOdd:

alert(array.findLastIndex(isOdd));
// выведет 4 — это индекс последнего нечётного числа в массиве

alert(arrayEven.findLastIndex(isOdd));
// выведет -1, потому что в этом массиве нет нечётных чисел

Тот же пример через классический цикл for:

                            
const array = [1, 2, 3, 4, 5]; 
const arrayEven = [2, 4, 6];
// исходные массивы

// напишем функцию-предикат,
// которая вернет true или false:

function isOdd(element) {
  return element % 2 !== 0
}

// напишем функцию, которая будет принимать 2 аргумента:
// массив и функцию-предикат:

function findLastIndex(array, predicate) {
  let odd = [];
  for (let i = 0; i < array.length; i++) {
      if (predicate(array[i])) {
          odd.push(i);
      }
  }

  if(odd.length !== 0) {
      odd.sort(function(a, b) {
          return b - a;
      });
      return odd[0];
  }

return -1
}

// подставим в функцию findLastIndex наши аргументы - 
// массивы array и arrayEven, а также функцию isOdd

alert(findIndex(array, isOdd));
// выведет 4 — это индекс последнего нечетного числа в массиве

alert(findIndex(arrayEven, isOdd));
// выведет -1, потому что в этом массиве нет нечётных чисел

Практика

Дан пустой массив, куда нужно добавить числа и применить метод findLastIndex(), чтобы узнать, есть ли в массиве чётные числа, и в случае успеха, вернуть индекс последнего:

                                  const array = 
[
];
  const arrayFindEven = array.findLastIndex(function (element) {
    return element % 2 === 0;
  });

Исходный массив:

Результат: