Удалить последний элемент массива js: Array.prototype.pop() — JavaScript | MDN

Как удалить последний символ в строке? — efim360.ru

 

Есть строка:

var stroka = "Subaru/"

Нам нужно удалить из этой строки последний символ косой линии «/». Как это сделать?

 

Видео на русском языке

В видеоролике показаны два способа удаления последнего символа строки. Все команды пишутся напрямую в консоль браузера Google Chrome.

 

Решение № 1 — Через метод slice()

Воспользуемся методом slice(), который наследуется нашим экземпляром строки от объекта -прототипа String.

String.prototype.slice (

start, end )

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

Команда по удалению последнего символа строки:

stroka.slice(0, -1)

Мы передали два параметра в метод slice(). В первый параметр start мы передали числовое значение «0» — это индекс первого элемента строки с которого мы начнём нарезание на кусочки («кусочничать»). Во второй параметр end мы передали числовое значение «-1«.

Удалили последний элемент из строки — JavaScript

Так как второй параметр end отрицательный, то применилось правило (sourceLength + end).

В нашем случае (stroka.length + (-1)). Это (7 — 1) = 6. Таким образом второй параметр end стал равен 6.

Символ косой линии на конце строки — JavaScript

Под индексом 6 в нашей исходной строке находится косая линия, но метод slice() не включит её в итоговую строку. Индекс 6 не попадёт в итоговый результат по правилу работы метода slice().

ВАЖНО! Метод slice() возвращает новую строку. Это значит, что оригинальная строка на которой вызывается метод slice() не изменяется.

 

Свой метод

Можно расширить стандартный набор методов языка JavaScript для объектов-прототипов String и написать свой собственный.

String.prototype.delOneLast = function () {
   return this.slice(0, -1)
}

Теперь можно протестировать вызов метода delOneLast() на разных строках:

Свой метод delOneLast для строк — JavaScript

 

Способ № 2 — метод replace() и регулярное выражение

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

var stroka = "Subaru/"
stroka.replace(/.$/,"")
"Subaru"

 

 

Как это работает?

Метод replace() всегда принимает два параметра:

1. searchValue — значение для поиска
2. replaceValue — значение для замены

Первым параметром мы передадим регулярное выражение. Литеральное объявление регулярного выражения в JavaScript обозначается двумя косыми линиями / /. Между этими линиями записывается конструкция сопоставления — шаблон регулярного выражения (pattern).

У шаблона достаточно большой синтаксис по оформлению, но в нашем случае достаточно знать два производства:

1. Утверждения (Assertion)
2. Атомы (Atom)

Знак доллара $ принадлежит утверждению № 2 и означает правую границу строки.

Знак точки . принадлежит атому № 2 и означает один какой-то любой символ.

Вторым параметром мы передаём пустую строку. Мы меняем найденное на пустую строку. По смыслу происходит удаление, хотя по факту это операция замены.

Результат:

Метод replace и регулярное выражение — JavaScript

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

 

Метод exec() для регулярного выражения

Можно провести сопоставление шаблона регулярного выражения по исходной строке.

/.$/.exec("Subaru/")

Такое сопоставление по строке возвращает нам массив. Это не обычный массив. В нём есть строковые свойства.

Регулярное выражение нашло последной символ строки — JavaScript

Что нас интересует в этом массиве?

1. Значения свойств, которые обозначаются целочисленными индексами.
2. Значение свойства «index»

В данном случае значение под свойством «index» равно числу 6 (шесть). Это индекс позиции символа, подходящего под сопоставление шаблона регулярного выражения. Этим значением является косая линия.

 

Дополнительно

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

 

Как удалить последние 5 (пять) символов строки?

"кораблик".slice(0,-5)
"кор"

"кораблик".replace(/.{5}$/,"")
"кор"

Удалили последние 5 символов в строке — JavaScript

 

Информационные ссылки

Стандарт ECMAScript — Раздел «22.1.4 Properties of String Instances» — https://tc39.es/ecma262/#sec-properties-of-string-instances

Как удалить первый символ в строке?

JavaScript | Строки (String)

Официальная страница стандарта ECMAScript — Объект String — https://tc39.

es/ecma262/#sec-string-objects

Метод slice() — https://tc39.es/ecma262/#sec-string.prototype.slice

15 методов работы с массивами в JavaScript

Оригинал: 15 must-know JavaScript array methods in 2020, автор Ibrahima Ndaw

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

В этой статье мы разберем 15 встроенных методов объекта Array.prototype:

• forEach()
• find()
• findIndex()
• some()
• every()
• includes()
• reverse()
• map()
• filter()
• reduce()
• sort()
• concat()
• fill()
• flat()
• flatMap()

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

// вместо такого кода
myAwesomeArray.some(test => {
  if (test === "d") {
    return test
  }
})
// мы будем использовать такой
myAwesomeArray.some(test => test === "d")

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

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: undefined

Этот метод просто выполняет функцию-коллбэк для каждого элемента в массиве.

const myAwesomeArray = [
  { id: 1, name: "john" },
  { id: 2, name: "Ali" },
  { id: 3, name: "Mass" },
]
myAwesomeArray.  forEach(element => console.log(element.name))
// john
// Ali
// Mass

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: первый подходящий элемент массива или undefined

Функции-коллбэк должна вернуть true, если элемент соответствует определенным критериями, или

false, если не соответствует. Если вернулся результат true, итерация прекращается. Результатом работы метода становится найденный элемент.

const myAwesomeArray = [
  { id: 1, name: "john" },
  { id: 2, name: "Ali" },
  { id: 3, name: "Mass" },
]
myAwesomeArray.find(element => element.id === 3) // {id: 3, name: "Mass"}
myAwesomeArray.find(element => element.id === 7) // undefined

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

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

-1

Работает аналогично методу find, но возвращает не сам элемент, а его индекс в исходном массиве.

const myAwesomeArray = [
  { id: 1, name: "john" },
  { id: 2, name: "Ali" },
  { id: 3, name: "Mass" },
]
myAwesomeArray.findIndex(element => element.id === 3) // 2
myAwesomeArray.findIndex(element => element.id === 7) // -1

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: true или false

Этот метод используется, чтобы найти в массиве хотя бы один элемент, который соответствует определенному условию. Если функция-коллбэк вернет true, то итерация по элементам остановится и весь метод вернет true. Если для всех элементов вернулось false, то весь метод вернет false.

const myAwesomeArray = ["a", "b", "c", "d", "e"]
myAwesomeArray.some(test => test === "d") // true

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: true или false

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

const myAwesomeArray = ["a", "b", "c", "d", "e"]
myAwesomeArray.every(test => test === "d") // false
const myAwesomeArray2 = ["a", "a", "a", "a", "a"]
myAwesomeArray2.every(test => test === "a") // true

Параметры метода:

значение для сравнения, индекс, с которого нужно начинать поиск (необязательный, по умолчанию — 0)

Результат: true или false

Работает аналогично методу some, то есть проверяет, есть ли в массиве хоть один подходящий под условие элемент. Однако в отличие от some принимает не функцию, а конкретное значение для сравнения. Сравнение строгое.

const myAwesomeArray = [1, 2, 3, 4, 5]
myAwesomeArray.includes(3) // true
myAwesomeArray.includes(8) // false
myAwesomeArray.includes('3') // false

Результат: «перевернутый массив»

Мутация исходного массива: да, «переворот» массива происходит «на месте», без создания копии

Метод обращает порядок следования элементов массива — «переворачивает» его. Последний элемент становится первый, предпоследний — вторым и т. д.

const myAwesomeArray = ["e", "d", "c", "b", "a"]
myAwesomeArray.reverse() // ['a', 'b', 'c', 'd', 'e']

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: новый массив такой же длины, состоящий из преобразованных элементов старого

Мутация исходного массива: нет

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

const myAwesomeArray = [5, 4, 3, 2, 1]
myAwesomeArray.map(x => x * x) // [25, 16, 9, 4, 1]

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: новый массив, состоящий только отобранных элементов исходного

Мутация исходного массива: нет

Функция-коллбэк должна «фильтровать» элементы исходного массива, возвращая для них true (элемент удовлетворяет условию и должен быть в результирующем массиве) или false (элемент не удовлетворяет условию).

const myAwesomeArray = [
  { id: 1, name: "john" },
  { id: 2, name: "Ali" },
  { id: 3, name: "Mass" },
  { id: 4, name: "Mass" },
]
myAwesomeArray.filter(element => element.name === "Mass")
// [ {id: 3, name: "Mass"}, {id: 4, name: "Mass"} ]

Параметры метода: функция-коллбэк, начальное значение аккумулятора

Параметры функции-коллбэка: текущее накопленное значение, текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: «накопленное значение» аккумулятора

Коллбэк этого метода при итерации по массиву получает не только текущий элемент, но и «накопленное значение» — accumulator. Функция может изменять его в зависимости от значения элемента и обязательно должна вернуть новое «накопленное значение». Результатом работы всего метода является именно аккумулятор, измененный во всех коллбэках.

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

const myAwesomeArray = [1, 2, 3, 4, 5]
myAwesomeArray.reduce((accumulator, value) => accumulator * value)
// 1 * 2 * 3 * 4 * 5 = 120

Параметры метода: функция-компаратор для сравнения двух значений

Результат: отсортированный массив

Мутация исходного массива: да, сортировка происходит «на месте» без создания копии массива

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

const myAwesomeArray = [5, 4, 3, 2, 1]
// Сортировка по возрастанию
myAwesomeArray. sort((a, b) => a - b) // [1, 2, 3, 4, 5]
// Сортировка по убыванию
myAwesomeArray.sort((a, b) => b - a) // [5, 4, 3, 2, 1]

Параметры метода: массивы для объединения с исходным (количество параметров не ограничено)

Результат: новый массив, состоящий из элементов всех полученных массивов

Мутация исходного массива: нет

Метод просто объединяет несколько массивов в один

const myAwesomeArray = [1, 2, 3, 4, 5]
const myAwesomeArray2 = [10, 20, 30, 40, 50]
myAwesomeArray.concat(myAwesomeArray2) // [1, 2, 3, 4, 5, 10, 20, 30, 40, 50]

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

Результат: Массив с измененными значениями.

Мутация исходного массива: да

Этот метод заменяет текущие элементы массива на указанное значение — «заполняет» массив указанным значением.

const myAwesomeArray = [1, 2, 3, 4, 5]
// Первый аргумент (0) - само значение для заполнения
// Второй аргумент (1) - индекс элемента, с которого нужно начать замену
// Третий аргумент (3) - индекс элемента, на котором нужно закончить замену
myAwesomeArray.fill(0, 1, 3) // [1, 0, 0, 4, 5]

Параметры метода: глубина разворачивания (по умолчанию 1)

Результат: новый массив, состоящий из элементов развернутых подмассивов

Мутация исходного массива: нет

Если в вашем исходном массиве есть вложенные массивы, то этот метод «развернет» их, уменьшив «мерность».

const myAwesomeArray = [[1, 2], [3, 4], 5]
myAwesomeArray.flat() // [1, 2, 3, 4, 5]
const myAwesomeArray2 = [[[1, 2], [3, 4]], 5]
myAwesomeArray2.flat(2) // [1, 2, 3, 4, 5]

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Комбинация методов flat() и map(). При этом сначала отрабатывает map — к каждому элементу применяется функция-коллбэк, которая должна вернуть его модифицированную версию. После этого отрабатывает flat с глубиной 1- мерность массива уменьшается.

const myAwesomeArray = [[1], [2], [3], [4], [5]]
myAwesomeArray.flatMap(arr => arr * 10) // [10, 20, 30, 40, 50]
// то же самое с flat() + map()
myAwesomeArray.map(arr => arr * 10).flat() // [10, 20, 30, 40, 50]

Работа с массивами в JavaScript

Как удалить первый и последний элемент в массиве в JavaScript

JavaScript

7 месяцев назад

от Sharqa Hameed

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

В этой статье описана процедура удаления первого и последнего элемента массива в JavaScript.

Как удалить/опустить первый и последний элементы массива в JavaScript?

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

• « shift() » и « pop() » методы
• « slice() » метод

Теперь мы рассмотрим каждый из упомянутых методов один за другим!

Метод 1: удаление/опускание первого и последнего элементов массива в JavaScript с использованием методов shift() и pop()

В JavaScript метод « shift() » используется для исключения первого элемента массива. В то время как метод « pop() » опускает последний элемент массива. Эти методы можно использовать в комбинации для удаления первого и последнего элементов массива.

Синтаксис

array. shift(), array.pop()

Здесь « array » относится к определенному массиву, к которому будут применены методы shift() и pop() для удаления первого и последние элементы массива соответственно.

Посмотрите на указанный пример для демонстрации.

Пример

В следующем примере инициализируйте массив с именем « remArr » целым числом и строковым значением в нем:

var remArr= [1, 2, ‘a’]

Теперь применим метод « shift() » для удаления первого элемента « 1 » из массива и отображения его на консоли с помощью метода « console.log() »:

remArr.shift()

console.log(«Массив после удаления первого элемента:», remArr)

После этого мы воспользуемся методом « pop() », чтобы удалить последний элемент « a » из массива и отобразить его:

remArr. pop()

console.log(«Array after удаление последнего элемента:», remArr)

Наконец, распечатайте массив обновлений на консоли:

console.log(«Новый массив становится:», remArr)

Output

Метод 2. Удаление первого и последнего элементов массива в JavaScript с использованием метода slice()

В JavaScript метод « slice() » нарезает элементы массива и возвращает их как новый массив. Вы можете применить этот метод для нарезки первого и последнего элементов массива, обратившись к их индексам и удалив их из массива.

Синтаксис

array.slice(start, end)

Здесь « start » и « end » относятся к первому и последнему индексу массива.

Следующий пример поясняет заявленную концепцию:

Пример

Теперь мы применим метод « slice() » к строке « remArr » и обратимся к начальному и конечному индексам « 1 » и « -1 », соответственно. Это приведет к удалению элементов с первым и последним индексами из данного массива: вывести результирующий массив на консоль:

console.log(«Новый массив после удаления первого и последнего элементов становится:», firstLast)

Output

Мы предоставили все самые простые методы для удаления первого и последнего элемента в массиве в JavaScript.

Заключение

Для удаления первого и последнего элементов массива можно использовать методы « shift() » и « pop() » для удаления первого и последнего элементов массива соответственно и Метод « slice() » для указания в его аргументе индекса элемента, который необходимо удалить. Оба метода изменяют длину исходного массива. В этой статье объяснялись методы удаления первого и последнего элементов массива в JavaScript.

Об авторе

Sharqa Hameed

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

Посмотреть все сообщения

Удалить последний элемент из массива в TypeScript/JavaScript

Независимо от того, являетесь ли вы разработчиком JavaScript/TypeScript или только начинаете его изучать, массив — это то, с чем вам приходится часто иметь дело. В зависимости от характера вашей работы или проблемы, которую вы решаете, вам необходимо выполнять операции с массивами и манипулировать ими. Некоторые распространенные операции и манипуляции с массивами включают объединение двух массивов, извлечение пар ключ/значение, фильтрацию, удаление элементов из массива и многое другое. Среди этих операций в этой статье будет рассмотрено удаление последнего элемента из массива.

Примечание: Методы, описанные в статье, применимы как к JavaScript, так и к TypeScript. В статье мы будем ссылаться на JavaScript.

Используйте метод pop() для удаления последнего элемента из массива в JavaScript. Метод массива pop() не только удаляет последний элемент из массива, но и возвращает удаленный элемент.

Хотите изучить, изучить и реализовать метод pop() для удаления последнего элемента из массива с практическим опытом? Читай дальше! Эта статья объяснит все, что вам нужно знать.

Содержание

Удаление последнего элемента из массива в JavaScript с использованием метода

pop()

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

Наряду с несколькими другими методами массива, такими как push() , unshift() , shift() и т. д.; метод pop() демонстрирует изменчивость. Это означает, что массив меняет свое значение после применения к нему операции с массивом. Другими словами, массив обновляется после удаления последнего элемента.

Давайте разберемся с изменяемым свойством метода pop() на примере.

 переменная обр = [1,2,3]
console.log(arr.pop()) // 3
console.log(arr) // [1, 2] 

В приведенном выше примере массив arr содержит три позиции: 1 , 2 и 3 . После операции pop() , когда вы записываете массив в консоль, он возвращает только 1 и 2 . Здесь переменная arr изменилась. Поэтому метод pop() является изменяемой операцией.

До сих пор вы знали, что метод pop() является изменяемой операцией. Однако изменчивость имеет несколько недостатков. При мутации изменение состояния затрудняет отслеживание изменений, так как не будет базы для сравнения. В результате это затрудняет отладку. Мутация также нарушает предсказуемость программы. Следовательно, необходимо заменить неизменяемые операции неизменяемыми операциями.

Альтернативные решения (неизменяемые операции)

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

Удалить последний элемент из массива в JavaScript с помощью метода

slice()

Вы можете использовать метод slice() для выбора последовательности элементов массива от первого индекса до предпоследнего индекса и следовательно, удалите последний элемент массива. Это неизменяемая операция и альтернатива методу pop() .

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

Например, рассмотрим произвольный массив и найдем его длину, используя свойство length . Теперь вы можете найти индекс последнего элемента массива, вычитая 1 из длины, так как индекс массива начинается с 0 . Наконец, вы можете установить start как 0 и end как индекс последнего элемента как параметры метода slice() .

 вар обр = ['Хонда', 'ямаха', 'ктм', 'бмв']
var len = arr.length // 4
console.log(arr.slice(0, len-1)) // ["honda", "yamaha", "ktm"] 

В приведенном выше примере функция arr.slice(0, len-1) переводится в arr.slice(0, 3) . Как указывалось ранее, метод slice() не включает конечный индекс, поэтому он возвращает элементы массива из индексов 0 до 2 . Таким образом, последний элемент удаляется из массива.

Обратите внимание на разницу в возвращаемом значении метода slice() и метода pop() . Метод slice() возвращает новый массив, а метод pop() возвращает удаленный элемент.

Вместо вычисления длины массива для доступа к последнему индексу можно использовать сокращенный метод. Проблемы можно уменьшить, используя отрицательное значение для конца параметр. Значение -1 в качестве параметра end для метода slice() обозначает последний индекс массива. Если бы значение было -2 , оно представляло бы второй индекс массива. Таким образом, эквивалентный фрагмент кода приведенного выше примера показан ниже.

 console.log(arr.slice(0, -1)) // ["honda", "yamaha", "ktm"] 

В этих примерах показано неизменяемое свойство метода slice() . Когда вы регистрируете массив в консоли, он не показывает никаких изменений в значениях даже после slice() операция.

 console.log(arr) // ['honda', 'yamaha', 'ktm', 'bmw'] 

Удалить последний элемент из массива в JavaScript с помощью метода

filter()

Другая альтернатива удаление последнего элемента из массива использует метод filter() для массива. Метод filter() можно использовать для создания условия, которое проверяет, меньше ли каждый индекс массива, чем результат вычитания 1 из длины массива. В результате последний элемент будет опущен во вновь возвращаемом массиве. Операция filter() также является неизменяемой операцией.

 вар обр = ['Хонда', 'ямаха', 'ктм', 'бмв']
var newArr = arr.filter((элемент, индекс) => index < arr.length - 1 )
console.log(newArr) // ["honda", "yamaha", "ktm"] 

Здесь метод filter() вернет только те элементы массива, которые удовлетворяют условию. Условие подготовлено таким образом, что последний элемент не сможет удалить себя из массива. Давайте применим условие к последнему элементу массива и посмотрим, как оно работает.

Поскольку длина массива равна 4 , индекс последнего элемента равен 3 . Условие внутри метода filter() проверяет, меньше ли индекс 3 , чем arr.length - 1 , что равно 3 . Условие не выполняется, так как 3 (индекс последнего элемента) не меньше 3 ( arr.length-1 ). Остальные элементы массива проходят условие, так как их индексы меньше 3 . Следовательно, последний элемент не будет включен в возвращаемый массив, что приведет к его удалению.

Когда вы записываете массив в консоль, исходные элементы массива остаются нетронутыми, демонстрируя неизменное свойство метода filter() .

 console.log(arr) //[ 'honda', 'yamaha', 'ktm', 'bmw' ]
 

Заключение

В этой статье представлена ​​пара способов удаления последнего элемента из массива.