从数组中删除最后一项答案

【问题标题】：Remove last item from array从数组中删除最后一项
【发布时间】：2013-11-01 21:25:13
【问题描述】：

我有以下数组。

var arr = [1,0,2];

我想删除最后一个元素，即 2。

我使用了arr.slice(-1);，但它没有删除该值。

【问题讨论】：

to remove first and last element in array using jquery 的可能重复项
使用 arr.pop()
arr.splice(-1,1) 将返回给您数组 [1,0]; arr.slice(-1,1) 会返回给你[2]
arr.slice(0,-1) 对我来说是最好的解决方案
这个问题有点含糊，因为“删除最后一个元素”可能意味着从数组中删除元素并保留数组（少一个元素）。但这也可能意味着删除元素并保留元素。第一种情况：splice()，第二种情况：pop()。

标签： javascript arrays slice

【解决方案1】：

您需要这样做，因为slice 不会改变原始数组。

arr = arr.slice(0, -1);

如果你想改变原来的数组你可以使用splice:

arr.splice(-1, 1);

或pop:

arr.pop();

【讨论】：

使用arr = arr.slice(0, -1); 而不是arr = arr.slice(-1);

【解决方案2】：

我得到了最好的答案！

var array = [1, 2, 3, 4]
array.length = array.length - 1

console.log(array)
> [1, 2, 3]

老实说，JS 在这一点上是一个模因。

PS：这会影响变量及其任何引用，如果您不想影响任何变量的引用，您可以这样做：

var array = [1, 2, 3, 4]
var modifiedArray = Array.from(array)
modifiedArray .length = modifiedArray .length - 1

console.log(modifiedArray )
> [1, 2, 3]

【讨论】：

这可能是一种不安全的做法，并且根据javascript的实现它可能不起作用，所以不要使用它。

【解决方案3】：

使用splice(startPosition, deleteCount)

array.splice(-1)

var array = ['abc','def','ghi','123'];
var removed = array.splice(-1);  //last item
console.log( 'array:', array );
console.log( 'removed:', removed );

【讨论】：

@PrithvirajMitra 你想删除 1 和 0？那么数组 ==[2] ?
不适用于单元素数组：[1].splice(-1, 1) => [1]
这不是最好的解决方案，最好的是弹出功能。不是这个。
Pop 本身只会返回最后一个元素的值。如果我理解正确，@PrithvirajMitra 想要两件事：1) 从原始数组中删除最后一个元素，2) 将该元素作为单个元素数组返回 - 即：[0,1,2] -> [2]，留下[0,1]。如果是这样，那么[arr.pop()] 就可以了。
请注意array.pop() 将更改修改array，而slice(0, -1) 不会。 Pop 当然更快，但可能并不总是适合所有需求。

【解决方案4】：

值得注意的是，slice 都将返回 new 数组，而 .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(0, -1)                       // get rid of the last item ! slice(-1) will give first element
  .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

【讨论】：

【解决方案5】：

以身作则：

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

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

【讨论】：

这应该是公认的答案，因为它说明了大多数出错的地方。 > 返回你想要的数组或以你想要的方式改变数组。
@RaisingAgent 感谢您注意到这些事情 :)
最完整的答案?谢谢队友！

【解决方案6】：

// Setup
var myArray = [["John", 23], ["cat", 2]];

// Only change code below this line
var removedFromMyArray;
removedFromMyArray = myArray.pop()

【讨论】：

请在原始代码之外添加一些 cmets 以使其成为更好的答案。

【解决方案7】：

只需arr.splice(-1) 即可。

【讨论】：

不，删除最后一项使用arr.slice(0, -1)，它不是修改，应该保存为：var newArray = arr.slice(0, -1)
我同意@diti，这只是我建议的简写。

【解决方案8】：

使用扩展运算符：

const a = [1,2,3]
const [, ...rest] = a.reverse();
const withoutLast = rest.reverse();
console.log(withoutLast)

【讨论】：

【解决方案9】：

只需将以下内容用于您的用例：

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

只是一个注释。当您执行pop() 函数时，即使该行返回了弹出的项目，原始数组也会受到影响并移除弹出的元素。

【讨论】：

【解决方案10】：

另一种方法是根据索引进行过滤：

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

注意：filter() 创建新数组，不会更改现有数组。

【讨论】：

【解决方案11】：

如果你想在javascript中从数组末尾删除n项，你可以很容易地使用：

arr.splice(-n, n);

【讨论】：

【解决方案12】：

2019 ECMA5 解决方案：

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

非破坏性、通用、单行，只需要在数组末尾复制和粘贴。

【讨论】：

“非破坏性”听起来不像原始问题想要的那样：I would like to remove the last element 。这需要对原始数组进行破坏性/变异操作。

【解决方案13】：

Array.prototype.pop() 按 JavaScript 约定。

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

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

【讨论】：

Array.prototype.pop() 似乎是最快的jsperf.com/slice-vs-splice-vs-pop/3
使用pop()时，一定不要做jQuery('#foo').val(numbers.pop())，除非你只想把数组的最后一项放到场地。 pop() 返回删除的元素。正如 Stuart 所做的那样，首先执行 numbers.pop();然后做 jQuery('#foo').val(numbers)...
拥有返回数组其余部分的 unpop() 会很酷。
在保持数组不可变的同时有什么方法可以做到这一点？
@nayiaw 是的，ES6 扩展语法：let fruit = ['apple', 'orange', 'banana', 'tomato']; let popped = [...fruit].pop(); popped 然后等于tomato，而fruit 仍然等于['apple', 'orange', 'banana', 'tomato']。

【解决方案14】：

我认为.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());

这可能是不可取的......

希望这可以为您节省一些时间。

【讨论】：

谢谢老兄，这是我需要使用的确切示例。我很感激:)
这是最正确的答案。可惜其他人排名更高。

【解决方案15】：

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

【讨论】：

虽然此代码可能会回答问题，但提供有关它如何和/或为什么解决问题的额外上下文将提高答案的长期价值。

【解决方案16】：

你可以通过两种方式使用splice()：

arr.splice(-1,1)
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() 删除最后一个元素，因为pop() 会从某个数组中删除最后一个元素。
使用arr.pop()

【讨论】：

【解决方案17】：

如果您不想知道删除了哪些元素，您可以使用 Lodash dropRight：

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

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

【讨论】：

【解决方案18】：

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

stack.reverse().shift();

stack.push(0);

输出将是：Array[0,1,2,3,4,5]。这将允许您在推入新值时保持相同数量的数组元素。

【讨论】：

您需要在轮班后或推动后再次反转才能再次获得正确的订单
Reverse 反转原始数组。抓住了我...让我们说一两次...

【解决方案19】：

这种方法更有助于删除和存储一个元素的最后一个元素数组。

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

【讨论】：

这个answer有什么不同？
是的，但这个更详细。你的答案对于初学者来说很难理解。

【解决方案20】：

这是删除最后一项的好方法：

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

拼接细节如下：

拼接（起始索引，拼接数量）

【讨论】：

【解决方案21】：

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

// 删除最后一个元素 // 需要检查 arr.length > 0

【讨论】：

【解决方案22】：

您可以使用.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（我们已经在上面的演示中看到）。

现在，让我们在这里谈谈slice() 方法语法中的end 参数。它也是一个从零开始的索引，从数组中提取结束。所以，假设我们有一个像这样的数组：-

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)

希望对你有帮助！

【讨论】：

这很好用，只要确保你注意到这是对 .slice() 的调用，而不是对 .splice() 的调用。
应该注意的是，此解决方案不会删除数组arr 中的最后一项，而是返回一个不包括最后一项的新数组。正如 Mozilla 的文档所说：“ slice() 方法将数组的一部分的浅拷贝返回到新的数组对象中。”。
该问题的示例代码隐含地询问如何从原始数组中删除最后一个值的新数组。所以arr.slice(0, -1) 是最好的答案。
切片更好，因为它不会修改原始数组

【解决方案23】：

说你有var arr = [1,0,2]

arr.splice(-1,1) 将返回给您array [1,0];，而arr.slice(-1,1) 将返回给您array [2];

【讨论】：

【解决方案24】：

splice(index,howmany) - 这个解决方案听起来不错。但是这个 howmany 只适用于正数组索引。要删除最后两项或三项，请使用索引本身。

例如，splice(-2) 删除最后两项。 splice(-3) 用于删除最后三个项目。

【讨论】：

【解决方案25】：

有一个功能，解释here：

arr.pop();

【讨论】：

【解决方案26】：

arr.slice(-1) 将返回数组最后一个元素的副本，但不修改原始数组。

要从数组中删除最后一个n 元素，请使用arr.splice(-n)（注意“splice”中的“p”）。返回值将是一个包含已删除元素的新数组。

更简单，对于n == 1，使用val = arr.pop()

【讨论】：

【解决方案27】：

你可以简单地使用，arr.pop()

这会删除数组的最后一个条目。

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

【讨论】：