Verification: a143cc29221c9be0

Php array push в начало массива

Php array push в начало массива

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

Метод JavaScript toString() преобразует массив в строку значений массива (разделенных запятыми).

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.toString();

Результат:

Banana,Orange,Apple,Mango

Попробуйте сами »

Метод join() также объединяет все элементы массива в строку.

Он ведет себя так же toString(), но в дополнение можно указать разделитель:

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.join(" * ");

Результат:

Banana * Orange * Apple * Mango

Попробуйте сами »


Выталкивание и толчки

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

Вот что такое выталкивание и толкание:

Извлечение элементов из массива или перемещение элементов в массив.



Выскакивают

Метод pop() удаляет последний элемент из массива:

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();              // Удаляет последний элемент ("Mango") из fruits

Попробуйте сами »

Метод pop() возвращает значение, которое "выскочило":

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x = fruits.pop();      // значение x "Mango"

Попробуйте сами »


Толкать

Метод push() добавляет новый элемент в массив (в конце):

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi");       //  Добавляет новый элемен ("Kiwi") к fruits

Попробуйте сами »

Метод push() возвращает новую длину массива:

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x = fruits.push("Kiwi");   // значение x равно 5

Попробуйте сами »


Сдвиг элементов

Сдвиг эквивалентен выталкиванию, работая с первым элементом вместо последнего.

Метод shift() удаляет первый элемент массива и "сдвиги" все другие элементы к более низкому индексу.

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift();            // Удаляет первый элемент "Banana" из fruits

Попробуйте сами »

Метод shift() возвращает строку, которая была "сдвинута":

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x = fruits.shift();    // значение x равно "Banana"

Попробуйте сами »

Метод unshift() добавляет новый элемент в массиве (в начале), и "unshifts" старые элементы:

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon");    // Добавляет новый элемент "Lemon" к fruits

Попробуйте сами »

Метод unshift() возвращает новую длину массива.

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon");    // Возвращает 5

Попробуйте сами »


Смена элементов

Доступ к элементам массива осуществляется по их порядковому номеру:

Индексы массива начинаются с 0. [0] - первый элемент массива, [1] - второй, [2] - третий ...

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[0] = "Kiwi";        // Изменяет первый элемент фруктов на "Kiwi"

Попробуйте сами »

Свойство length обеспечивает простой способ для добавления нового элемента в массив:

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[fruits.length] = "Kiwi";          // Appends "Kiwi" to fruits

Попробуйте сами »


Удаление элементов

Поскольку массивы JavaScript являются объектами, элементы можно удалять с помощью delete оператора JavaScript:

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
delete fruits[0];           // Изменяет первый элемент в фруктах на undefined

Попробуйте сами »

Использование delete может оставить неопределенные дыры в массиве. Вместо этого используйте pop() или shift().


Объединение массива

Метод splice() может быть использован для добавления новых элементов в массив:

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2, 0, "Lemon", "Kiwi");

Попробуйте сами »

Первый параметр (2) определяет позицию, в которой должны быть добавлены новые элементы (врезаны).

The second parameter (0) defines how many elements should be removed.

The rest of the parameters ("Lemon" , "Kiwi") define the new elements to be added.

The splice() method returns an array with the deleted items:

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2, 2, "Lemon", "Kiwi");

Попробуйте сами »


Использование splice() для удаления элементов

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

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(0, 1);        // Удаляет первый элемент фруктов

Попробуйте сами »

Первый параметр (0) определяет позицию, в которую должны быть добавлены (соединены) новые элементы.

Второй параметр (1) определяет, сколько элементов следует удалить.

Остальные параметры опущены. Новые элементы добавляться не будут.


Слияние (конкатенация) массивов

Метод concat() создает новый массив путем слияния (конкатенации) существующих массивов:

Пример (объединение двух массивов)

var myGirls = ["Cecilie", "Lone"];
var myBoys = ["Emil", "Tobias", "Linus"];
var myChildren = myGirls.concat(myBoys);   // Конкатенирует (объединяет) myGirls и myBoys

Попробуйте сами »

Метод concat() не изменяет существующие массивы. Он всегда возвращает новый массив.

Метод concat() может принимать любое количество аргументов массива:

Пример (объединение трех массивов)

var arr1 = ["Cecilie", "Lone"];
var arr2 = ["Emil", "Tobias", "Linus"];
var arr3 = ["Robin", "Morgan"];
var myChildren = arr1.concat(arr2, arr3);   // Объединяет arr1 с arr2 и arr3

Попробуйте сами »

Метод concat() может также принимать строки в качестве аргументов:

Пример (слияние массива со значениями)

var arr1 = ["Emil", "Tobias", "Linus"];
var myChildren = arr1.concat("Peter"); 

Попробуйте сами »


Нарезка массива

Метод slice() нарезает из куска массива в новый массив.

В этом примере вырезается часть массива, начиная с элемента массива 1 ("Оранжевый"):

Пример

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1);

Попробуйте сами »

Метод slice() создает новый массив. Он не удаляет какие-либо элементы из исходного массива.

В этом примере вырезается часть массива, начиная с элемента массива 3 ("Apple"):

Пример

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(3);

Попробуйте сами »

Метод slice() может принимать два аргумента , как slice(1, 3).

Затем метод выбирает элементы из начального аргумента и до конечного аргумента (но не включая его).

Пример

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1, 3);

Попробуйте сами »

Если конечный аргумент опущен, как в первых примерах, slice() метод вырезает остальную часть массива.

Пример

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(2);

Попробуйте сами »


Автоматический toString()

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

Это всегда так, когда вы пытаетесь вывести массив.

Эти два примера дадут одинаковый результат:

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.toString();

Попробуйте сами »

Пример

var fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits;

Попробуйте сами »

Все объекты JavaScript имеют метод toString().


Нахождение максимальных и минимальных значений в массиве

Нет встроенных функций для поиска самого высокого или самого низкого значения в массиве JavaScript.

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


Сортировка массивов

Сортировочные массивы рассматриваются в следущей главе этого руководства.


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

Массив – это специальная структура данных, которая предназначена для хранения упорядоченных коллекций значений.

Массивы очень полезны и довольно часто используются в коде, т.к. позволяют нам хранить несколько значений в одной переменной.

Например, вместо того чтобы использовать 5 переменных можно объявить одну со всеми этими значениями:

const ocean1 = 'Атлантический';
const ocean2 = 'Индийский';
const ocean3 = 'Тихий';
const ocean4 = 'Северный Ледовитый';
const ocean5 = 'Южный';
// вместо них массив
const oceans = ['Атлантический', 'Индийский', 'Тихий', 'Северный Ледовитый', 'Южный'];

Каждое значение в массиве имеет свой порядковый номер (индекс). Значения называются элементами. Первый элемент массива имеет индекс 0, второй – 1, третий – 2 и т.д.

На следующем рисунке показан массив, состоящий из 5 элементов: 123, 7, 50, -9, 24.

JavaScript массив и его индексы

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

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

Создание массива в JavaScript можно выполнить двумя способами: с помощью литерала и конструктора Array().

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

// посредством литерала массива
const arr = [];
// с использованием конструктора Array()
const otherArr = new Array();

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

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

const numArr = [3, -5, 9, 1, 21];
// с помощью Array()
// const numArr = new Array(3, -5, 9, 1, 21);

Внимание! Если конструктору Array() передать один аргумент, который является числом, то он создаст массив с указанным количеством элементов. Значения элементов при этом будут неопределёнными (пустыми):

const arr = new Array(3); // [ , , ]

При создании массивов в конец разрешается вставлять необязательную завершающую запятую:

const coffee = [
  Lavazza,
  Nescafe,
  Jardin,
];

Доступ к элементам

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

Так как индексы нумеруются с 0, то для получение первого, второго и третьего элемента нужно использовать индексы 0, 1 и 2.

const colors = ['black', 'white', 'grey'];
console.log( colors[0] ); // 'black'
console.log( colors[1] ); // 'white'
console.log( colors[2] ); // 'grey'

При попытке получить доступ к несуществующему элементу возвращается undefined:

console.log( colors[3] ); // undefined

Чтобы изменить элемент, ему нужно просто присвоить новое значение:

colors[1] = 'yellow'; // ['black', 'yellow', 'grey']

Сейчас в переменной $colors три элемента. Для добавления нового элемента в массив, можно просто присвоить нужное значение следующему индексу:

colors[3] = 'red'; // ['black', 'yellow', 'grey', 'red']

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

colors[5] = 'green'; // ['black', 'yellow', 'grey', 'red', , 'green']
console.log( colors[4] ); // undefined

Определить количество элементов в массиве можно с помощью свойства length:

console.log( colors.length ); // 6

Зная количество, получить последний элемент можно так:

const lastIndex = colors.length – 1;
console.log( colors[lastIndex] ); // "green"

Пример массива, элементы которого содержат различные типы данных:

const arr = [5, {name: 'Василий', age: 35}, [7, 54, 2], true, function() { console.log('good'); }];

// получим элемент с индексом 1, который является объектом, а затем значение его свойства age
console.log( arr[1].age ); // 35
// получим элемент с индексом 2, который является массивом, а затем его элемент с индексом 1
console.log( arr[4][1] ); // 35
// получим элемент с индексом 4, т.е. функцию и выполним её
arr[2](); // "good"

В качестве элементов массива можно использовать выражения:

const ratio = 5;
const point = [3 * ration, 7 * ratio];

Массивы – это объекты?

Массивы в JavaScript не являются каким-то определённым типом данных. Это объекты, а точнее их определённый вид (Array).

Например, получим с помощью оператора typeof тип данных:

const arr = ['One', 'Two', 'Three'];
console.log( typeof arr ); // "object"

А так как массивы являются объектами, то при его копировании, передаётся не он сам, а ссылка на него:

const names = ['Иван', 'Вася'];
const copyNames = names;
copyNames[1] = 'Петр';
console.log( names ); // ['Иван', 'Петр']

Для копирования массива можно воспользоваться следующими способами:

const names = ['Иван', 'Вася'];
// клонирование массива с помощью slice
const cloneNames1 = names.slice();
// с помощью оператора spread
const cloneNames2 = [...names];
// с помощью Array.from
const cloneNames3 = Array.from(names);

Конструктором массивов является Array:

const arr = ['One', 'Two', 'Three'];
console.log( arr.constructor === Array ); // true

При этом прототипом массивов является «Array.prototype»:

console.log( Object.prototype.toString.call(arr) ); // "[object Array]"
console.log( Object.prototype.toString.call(Array.prototype) ); // "[object Array]"

Проверить содержит ли переменная массив можно следующим образом:

// 1 способ
console.log( Array.isArray(arr) ); // true
// 2 способ
console.log( arr instanceof Array ); // true
// 3 способ
console.log( arr.constructor === Array ); // true

Перебор массива

Перебор элементов можно выполнить различными способами.

Один из первых способов – это использовать цикл for:

const students = ['Петя', 'Вася', 'Коля', 'Максим'];
for (let i = 0, length = students.length; i 

Второй способ – метод forEach:

students.forEach(function(item) {
  console.log( item );
});

Третий способ – цикл цикл for..of:

for (let item of students) {
  console.log( item );
}

Если нужно с индексами:

const nums = ['One', 'Two', 'Three'];
// 1 способ
for (let i = 0, length = nums.length; i 


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

Найти элемент в массиве можно с помощью метода indexOf():

const disks = ['500Gb', '1Tb', '2Tb'];
const index = disks.indexOf('1Tb'); // 1

В качестве результата он возвращает индекс первого найденного элемента.

Если элемент не найден, то indexOf() возвращает -1. Это можно использовать, например, чтобы проверить существует ли элемент в массиве:

const disks = ['500Gb', '1Tb', '2Tb'];
if (disks.indexOf('1Tb') > -1) {
  console.log( 'Этот элемент в массиве есть!' );
}

Метод indexOf() позволяет искать элементы не только с начала, но и с определённого индекса. Для этого ему нужно его указать в качестве второго аргумента:

const nums = ['One', 'Two', 'One'];
nums.indexOf('One', 1); // 2

Метод lastIndexOf() выполняет то же самое что indexOf(), только осуществляет это с конца:

// arr – массив, element – искомый элемент, from – индекс (по умолчанию arr.length)
arr.lastIndexOf(element[, from])

Пример:

const nums = ['One', 'Two', 'Three', 'One'];
nums.lastIndexOf('One'); // 3
nums.lastIndexOf('Two'); // 1

Начиная с версии ECMAScript 7 появился новый метод includes().

Он позволяет проверить содержит ли массив указанный элемент:

// arr – массив, element – искомый элемент, from – индекс (по умолчанию 0)
arr.includes(element[, from])

Он похож на indexOf(), но в отличие от него возвращает true или false.

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false

С использованием второго аргумента:

[1, 2, 3].includes(2, 1); // true
[1, 2, 3].includes(2, -1); // false

При отрицательных значениях from поиск выполняется начиная с array.length + from.

В отличие от indexOf(), в котором используется строгое равенство (Strict Equality Comparison), в includes() используется алгоритм равенства SameValueZero. Это значит, что вы можете, например, определить, содержит ли массив NaN:

[1, 2, NaN].includes(NaN); // true
[1, 2, NaN].indexOf(NaN); // -1

Также в отличие от indexOf(), includes() не пропускает отсутствующие элементы:

[1, , 3].includes(undefined); // true
[1, , 3].indexOf(undefined); // -1

Для чего предназначен оператор delete

Оператор delete используется не для удаления элемента из массива, а для присваиванию данному элементу массива значение undefined.

let namePlanets = new Array ("Венера","Меркурий","Земля","Марс");
delete namePlanets[1];
for (let i=0; i 


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

В JavaScript для добавления и удаления элементов имеются следующие методы:

  • push() – для добавления одного или нескольких элементов в конец массива;
  • unshift() – для добавления одного или нескольких элементов в начало массива;
  • pop() – для удаления последнего элемента;
  • shift() – для удаления первого элемента.

push - добавление элемента в конец массива

Метод push предназначен для добавления элемента в конец массива. Значение этого элемента указывается в качестве параметра данного метода. В качестве результата метод push возвращает количество элементов в массиве с учётом добавленного.

let namePlanets = ["Венера", "Меркурий", "Земля", "Марс"];
namePlanets.push("Юпитер"); // 5
console.log(namePlanets); // ["Венера", "Меркурий", "Земля", "Марс", "Юпитер"]

pop - удаление последнего элемента из массива

Метод pop предназначен для удаления последнего элемента из массива. У данного метода нет параметров. В качестве результата он возвращает значение последнего (удалённого) элемента массива.

let namePlanets = ["Венера", "Меркурий", "Земля", "Марс"];
namePlanets.pop(); // "Марс"
console.log(namePlanets); // ["Венера", "Меркурий", "Земля"]

shift - удаление первого элемента из массива

Метод shift предназначен для удаления первого элемента из массива, т.е. элемента, имеющего индекс 0. Все остальные элементы массива смещаются к началу, т.е. у каждого из них индекс уменьшается на 1. Данный метод в качестве результата возвращает значение удалённого элемента.

let namePlanets = ["Венера", "Меркурий", "Земля", "Марс"];
namePlanets.shift(); // "Венера"
console.log(namePlanets); // ["Меркурий", "Земля", "Марс"]

unshift - добавление элемента в начало массива

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

let namePlanets = ["Меркурий", "Земля", "Марс", "Юпитер"];
namePlanets.unshift("Венера"); // 5
console.log(namePlanets); // ["Венера", "Меркурий", "Земля", "Марс", "Юпитер"]

Методы добавления элементов

1. Метод push() предназначен для добавления элемента в конец массива.

Пример:


const array = [1,2,3];
console.log(array.push(4)) // [1,2,3,4]

2. Метод unshift() добавляет элемент в начало массива и возвращает новую длину массива.

Пример:


const array = [1,2,3]
console.log(array.unshift(4)) // [4,1,2,3] 

3.  Добавление элемента по индексу.

Пример:


const array = [1,2,3,4]
array[4] = 5
console.log(array) // [1, 2, 3, 4, 5]

Данным способом можно также изменять элемент по индексу.

Пример:


const array = [1,2,3,4]
array[3] = 5
console.log(array) // [1, 2, 3, 5]

Методы удаления элементов

1. Метод shift() используется для удаления первого элемента массива.

Пример:


const array = [1,2,3,4]
array.shift() 
console.log(array) // [2,3,4]

2. Метод pop() предназначен для удаления последнего элемента массива.

Пример:


const array = [1,2,3,4]
array.pop()
console.log(array) // [1,2,3]

3. Удаление элемента массива по индексу. Результатом метода slice() является новый массив. В параметрах указываем начальный и конечный индекс нового массива.

Пример:


const array = [1,2,3,4]
array.slice(0,1)
console.log(array) // [1]

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

Циклы перебора элементов массива

1. Цикл for является «классикой» для перебора элементов массива и используется в JavaScript с начала его создания.

Пример:


const array = [1,2,3,4]
for (let i = 0; i 

2. Цикл for..in – так как массивы в JS это объекты, имеется возможность использовать данный цикл для переборов объектов.

Пример:


const array =  [1,2,3,4]
for (let key in array) {
  console.log( array[key] )
}

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

3. Цикл for..of – данный цикл возвращает значение элементов, но при этом он не предоставляет доступ к номерам элементов. Это является главным его недостатком.

Пример:


const array =  [1,2,3,4]
for (let n of array) {
  console.log( n );
}

После циклов давайте разберем методы, которые имеют массивы перебора элементов.

Методы перебора элементов

1. Перебор элементов массива с помощью метода forEach().

Пример:


const array = [1,2,3,4]
array.forEach(function(item, index) {
  console.log(item, index);
})
// 1 0
// 2 1
// 3 2
// 4 3

2. Метод map() проходится по элементам массива и как результат возвращает новый массив.

Пример:


const array = [1,2,3,4]
const array2 = array.map(el => {
	return el + 1
})
console.log(array2) // [2, 3, 4, 5]

3. Метод filter() предназначен для фильтрации массива через функцию. Данный метод вернет новый массив в зависимости от истинности выполненного условия для каждого элемента.

Пример:


const array = [1,2,1,1]
const array2 = array.filter(el => {
	return el !== 1
})
console.log(array2) // [2]

4. Метод every() используется для проверки значений массива на равенство. Если при вызове колкэк-функции каждый элемент массива будет соответствовать условиям, то данный метод вернет true.

Пример:


const arr = [-2, -1, 0, 1]
function isСheck(n) {
  return n > 0;
}
console.log( arr.every(isСheck) ); // false

5. Метод some() похож на метод every(), но при этом он отличается тем, что возвращает true, если при вызове колбэк-функции хотя бы один из элементов будет равен указанному условию.

Пример:


const arr = [-2, -1, 0, 1]
function isСheck(n) {
  return n > 0;
}
console.log(arr.some(isСheck)) // true

6. Метод reduce() позволяет обойти каждый элемент массива с возможностью сохранения промежуточного результата. Reduce() часто используется в качестве замены нескольких методов, которые потребовалось бы применить для достижения аналогичного результата.

Пример:


const array = [1, 2, 3]
const res = array.reduce((accumulator, currentValue) => { 
 return accumulator + currentValue
} ))
console.log(res)

7. Метод reduceRight() работает так же как и reduce(), но идет по элементам массива справа налево.

Методы поиска по массиву

1. Поиск индекса элемента в массиве по значению. Данный метод производит поиск ближайшего элемента в массиве, который совпадает с переданным значением параметра. Если совпадение не обнаружено, то результатом будет -1.

Пример:


const array = [1, 2, 3, 0, 2]
console.log(array.indexOf(3)) // 2
console.log(array.indexOf(10)) // -1

2. Метод lastIndexOf() повторяет логику работы метода indexOf(), отличительной особенностью является то, что он возвращает последний индекс элемента (вместо первого) среди найденных значений.

Пример:


const array = [1, 2, 3, 0, 3]
console.log(array.lastIndexOf(3)) // 4
console.log(array.lastIndexOf(10)) // -1

3. Метод includes() проверяет содержит ли массив нужное значение, в результате чего возвращается (true/false).

Пример:


const array = [1, 2, 3]
console.log(array.includes(1)) // true
console.log(array.includes(4)) // false

4. Метод find() проходится по элементам массива и возвращает первое найденное значение.

Пример:


const array = [1, 2, 3]
console.log(array.find(n => n === 1)) // 1

5. Метод findIndex() проходится по элементам массива и возвращает индекс найденного элемента.

Пример:


const array = [1, 2, 3]
console.log(array.findIndex(n => n === 1)) // 0

Дополнительные методы

1. Получение первого элемента массива

Пример:


const array = [1, 2, 3] 
console.log(array[0]) // 1

2. Получение последнего элемента массива

Пример:


const array = [1, 2, 3] 
console.log(array[array.length - 1]) // 3

3. Создание копии массива

Пример:


const array = [1, 2, 3]
const arrayTwo = array.slice()
console.log(arrayTwo) // [1,2,3]

4. Получение длины массива (количество элементов массива)

Пример:


const array = [1, 2, 3]
console.log(array.length) // 3

5. Метод splice() предназначен для изменения содержимого массива. Первый параметр отвечает за количество элементов в массиве, от начала которых нужно отступить. Второй параметр указывает на количество элементов для удаления. Третий параметр используется в случае, когда требуется добавить значение для нового элемента.

Пример:


const array = [1, 2, 3]
array.splice(2, 0, 2.3)
console.log(array) // [1, 2, 2.3, 3]

6. Метод сортировки массивов

Пример:


const array = [4, 5, 2, 1]
console.log(array.sort()) // [1, 2, 4, 5] 

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

Пример:


const array = [1, 2, 3]
array.reverse()
console.log(array) // [3, 2, 1]

8. Метод concat() создает новый массив на основе переданных значений и предыдущего массива.

Пример:


let a = [1,2,3]
console.log(array.concat([4,5])) // [1,2,3,4,5]

9. Метод flat() создаст новый массив на основе вложенных массивов. В параметре метода можно указать число вложений, которые требуется преобразовать в «плоский» массив.

Пример:


let array = [1,2, [3,4]]
console.log(array.flat()) // [1,2,3,4]