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

У меня есть следующий массив.

var arr = [1,0,2];

Я хотел бы удалить последний элемент, т. Е. 2.

Я использовал, arr.slice(-1);но это не удаляет значение.

Используйте сплайс (индекс, сколько)

arr.splice(-1,1)

Array.prototype.pop () по соглашению JavaScript.

let fruit = ['apple', 'orange', 'banana', 'tomato'];
let popped = fruit.pop();

console.log(popped); // "tomato"
console.log(fruit); // ["apple", "orange", "banana"]

Вы можете сделать это с помощью .slice()метода, как:

arr.slice(0, -1);    // returns [1,0]

Вот демо:

var arr = [1, 0, 2];
var newArr = arr.slice(0, -1);    // returns [1,0]

console.log(newArr);
$('#div1').text('[' + arr + ']');
$('#div2').text('[' + newArr + ']');

<script src="http://code.jquery.com/jquery.min.js"></script>
<b>Original Array    : </b>
<div id="div1"></div>
<br/>
<b>After slice(0, -1): </b>
<div id="div2"></div>

вместо того, чтобы делать:

arr.slice(-1);   // returns [2]

Вот демо:

var arr = [1, 0, 2];
var newArr = arr.slice(-1);    // returns [2]

console.log(newArr);
$('#div1').text('[' + arr + ']');
$('#div2').text('[' + newArr + ']');

<script src="http://code.jquery.com/jquery.min.js"></script>
<b>Original Array    : </b>
<div id="div1"></div>
<br/>
<b>After slice(-1): </b>
<div id="div2"></div>

Объяснение: -

Теперь основной синтаксис Array.prototype.slice()или краткий slice()метод:

arr.slice([begin[, end]])

Вот,

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

arr.slice(0)    // returns [1,0,2]

он вернул бы все элементы массива с начала последовательности с позиции 0, и это [1,0,2]. Точно так же, если мы делаем

arr.slice(1)    // returns [0,2]

он вернется, [0,2]поскольку 0 находится здесь в позиции 1 и все после этого. Теперь, в вашем случае вы передали отрицательный индекс, т. Е. В -1качестве параметра начала, который указывает смещение от конца последовательности. Итак, slice(-1)в вашем случае извлекает последний элемент массива в последовательности, и это 2( как мы уже видели в приведенной выше демонстрации ).

Теперь поговорим о endпараметре в slice()синтаксисе метода здесь. Это снова индекс, начинающийся с нуля, на котором заканчивается извлечение из массива. Итак, допустим, у нас есть массив, как: -

var arr = [1, 0, 2, 5, 3, 9];

и мы хотим получить только 2,5,3элементы в массиве. Теперь позиция 2начала последовательности 2и для последнего элемента 3это 4. Нам нужно закончить извлечение здесь позиции 5, так как нам нужно получить элемент до этой позиции. Итак, мы просто реализуем slice()метод здесь, как

arr.slice(2, 5)    // returns [2,5,3]

В вашем случае мы реализовали -1в качестве параметра конца, поэтому наш код

arr.slice(0, -1)   // returns [1,0]

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

arr.slice(0, 2)    // returns [1,0]

мы получим тот же результат. Но я использовал -1здесь, поскольку его проще реализовать даже для длинного массива, такого как

[0,2,3,1,2,9,3,6,3,9,1,0,2,9,0,1,1,2,3,4,7,9,1]

Если вы просто хотите удалить последний элемент, вы не хотите сидеть и вычислять позицию последних 9 здесь и тому подобное arr.slice(0, 22). Вы можете просто реализовать логику отрицательного индекса здесь и сделать

arr.slice(0, -1) // same result as arr.slice(0, 22)

Надеюсь, поможет!

учиться на примере:

let array_1 = [1,2,3,4];
let array_2 = [1,2,3,4];
let array_3 = [1,2,3,4];

array_1.splice(-1,1)  // output --> [4]      array_1 = [1,2,3]
array_2.slice(0,-1);  // output --> [1,2,3]  array_2 = [1,2,3,4]
array_3.pop();        // output --> 4        array_3 = [1,2,3]

Вы должны были бы сделать это, так sliceкак не изменяет исходный массив.

arr = arr.slice(-1);

Если вы хотите изменить исходный массив, вы можете использовать splice:

arr.splice(-1, 1);

или pop:

arr.pop();

Я считаю, .pop()что это наиболее «правильное» решение, однако иногда оно может не сработать, так как вам нужно использовать массив без последнего элемента прямо там ...

В таком случае вы можете использовать следующее, он вернет [1,2,3]

var arr = [1,2,3,4];
console.log(arr.splice(0,arr.length-1));

в то время как .pop()вернется 4:

var arr = [1,2,3,4];
console.log(arr.pop());

что может быть нежелательно ...

Надеюсь, это сэкономит вам время.

Для этого есть функция, объяснение здесь :

arr.pop();

Вы можете просто использовать, arr.pop()

Это удаляет последнюю запись массива.

var arr = [1,0,2]; 
var popped = arr.pop();//Now arr = [1,0] & popped = 2

Просто используйте следующее для вашего случая использования:

var arr = [1,2,3,4];
arr.pop() //returns 4 as the value
arr // value 4 is removed from the **arr** array variable

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

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

1. arr.splice(-1,1)
2. arr.splice(arr.length-1,1)

splice(position_to_start_deleting, how_many_data_to_delete) принимает два параметра.

position_to_start_deleting: Нулевой индекс, с которого начинается удаление. how_many_data_to_delete: Из указанного индекса, сколько последовательных данных должно быть удалено.

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

arr.slice(-1)вернет копию последнего элемента массива, но оставит исходный массив без изменений.

Чтобы удалить последние nэлементы из массива, используйтеarr.splice(-n) (обратите внимание на «p» в «соединении»). Возвращаемым значением будет новый массив, содержащий удаленные элементы.

Еще проще, для n == 1использованияval = arr.pop()

var arr = [1,0,2];
arr.length--; 

// удаляет последний элемент // нужно проверить, если arr.length> 0

Этот метод более полезен для удаления и сохранения последнего элемента массива.

var sampleArray = [1,2,3,4];// Declaring the array
var lastElement = sampleArray.pop();//this command will remove the last element of `sampleArray` and stores in a variable called `lastElement` so that you can use it if required.

Теперь результаты:

console.log(sampleArray); //This will give you [1,2,3]
console.log(lastElement); //this will give you 4

Стоит отметить, что sliceоба будут возвращать новый массив, тогда как .pop()и .splice()будут изменять существующий массив.

Если вам нравится обрабатывать коллекции данных с помощью связанного командного стиля, вы действительно захотите придерживаться sliceчего-то подобного.

Например:

myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

var newArrayOfThings = myArray
  .filter(x => x > 5)              // only bigly things
  .slice(-1)                       // get rid of the last item
  .map(x => `The number is: ${x}`);// map to a set of strings

Это может потребовать намного больше возни и управления переменами, чтобы сделать то же самое с «pop», так как в отличие от map, filterи т. Д., Вы не получите новый массив обратно.

Это то же самое push, что добавляет элемент в конец массива. Возможно, вам будет лучше с этим, concatтак как это позволит вам поддерживать поток.

myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

var newArrayOfThings = myArray
  .filter(x => x > 5)              // only bigly things
  .slice(-1)                       // get rid of the "10"
  .concat([100])                   // note with concat, you must pass an array
  .map(x => `The number is: ${x}`) // map to a set of strings
  

splice (index, howmany) - это решение звучит хорошо. Но этот способ будет работать только для положительного индекса массива. Чтобы удалить последние два или три элемента, используйте сам индекс.

Например, сращивание (-2), чтобы удалить два последних элемента. сращивание (-3) для удаления трех последних элементов.

С Lodash вы можете использовать dropRight , если вам не важно знать, какие элементы были удалены:

_.dropRight([1, 2, 3])
// => [1, 2]

_.dropRight([1, 2, 3], 2);
// => [1]

var a = [1,2,3,4,5,6]; 
console.log(a.reverse().slice(1).reverse());
//Array(5) [ 1, 2, 3, 4, 5 ]

Решение 2019 ECMA5:

const new_arr = arr.reduce((d, i, idx, l) => idx < l.length - 1 ? [...d, i] : d, [])

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

скажи, что у тебя есть var arr = [1,0,2]

arr.splice(-1,1)вернусь к вам, array [1,0];пока arr.slice(-1,1)вернусь к вамarray [2];

Это хороший способ удалить последний элемент:

if (arr != null && arr != undefined && arr.length > 0) {
      arr.splice(arr.length - 1, 1);
}

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

сращивание (startIndex, номер сращивания)

var stack = [1,2,3,4,5,6];

stack.reverse().shift();

stack.push(0);

Вывод будет: Array [0,1,2,3,4,5] . Это позволит вам сохранить то же количество элементов массива, что и при вводе нового значения.

Другой подход заключается в фильтрации по индексу:

arr.filter((element, index) => index < arr.length - 1);

Примечание: filter()создает новый массив, не изменяет существующий.

Если вы хотите удалить n элементов из конца массива в javascript, вы можете легко использовать:

arr.splice(-n, n);