从数组中删除最后一项

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

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

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

---

使用splice(startPosition, deleteCount)

array.splice(-1)

var 数组 = ['abc','def','ghi','123']; var 移除 = array.splice(-1); //最后一项 console.log('array:', array); console.log('已删除：', 已删除);

---

您可以使用 .slice() 方法执行此操作，例如：

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

这是一个演示：

var arr = [1, 0, 2]; var newArr = arr.slice(0, -1); // 返回 [1,0] console.log(newArr); $('#div1').text('[' + arr + ']'); $('#div2').text('[' + newArr + ']'); 原始数组：

切片后(0, -1):

而不是这样做：

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

这是一个演示：

var arr = [1, 0, 2]; var newArr = arr.slice(-1); // 返回 [2] console.log(newArr); $('#div1').text('[' + arr + ']'); $('#div2').text('[' + newArr + ']'); 原始数组：

切片后（-1）：

解释：-

现在 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)

希望能帮助到你！

---

以身作则：

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]

---

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

arr = arr.slice(0, -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];控制台.log(arr.pop());

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

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

---

有一个功能，解释here：

arr.pop();

---

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

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

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

---

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

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

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

---

值得注意的是，slice 都将返回一个 new 数组，而 .pop() 和 .splice() 将改变 现有 数组。

如果您喜欢使用链式命令样式处理数据集合，那么您将真的希望坚持使用 slice 来完成类似的操作。

例如：

myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; var newArrayOfThings = myArray .filter(x => x > 5) // 只有大的东西 .slice(0, -1) // 去掉最后一项！ slice(-1) 将给出第一个元素 .map(x => `The number is: ${x}`);// 映射到一组字符串

使用“pop”做同样的事情可能需要更多的混乱和变量管理，因为与 map、filter 等不同，您不会得到新的数组。

与 push 类似，它将一个项目添加到数组的末尾。使用 concat 可能会更好，因为它可以让您保持流程继续进行。

myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; var newArrayOfThings = myArray .filter(x => x > 5) // 只有大的东西 .slice(-1) // 去掉 "10" .concat([100]) // 注意 concat，你必须通过an array .map(x => `The number is: ${x}`) // 映射到一组字符串

---

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

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

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

---

您可以使用 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()

---

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

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

---

另一种方法是基于索引进行过滤：

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

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

---

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

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

---

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

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

---

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

---

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

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

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

---

var arr = [ 0, 1, 2, 3, 4, 5, 6, 7 ]; // 使用切片 arr = arr.slice(0, -1); console.log('arr : ', arr); // 使用拼接 arr.splice(-1); console.log('arr : ', arr); // 使用弹出 arr.pop(); console.log('arr : ', arr); // 使用移位和反向 arr.reverse().shift() arr.reverse(); console.log('arr : ', arr); // 使用扩展运算符和反向 const [, ...exceptLast] = arr.reverse(); arr = exceptLast.reverse(); console.log('arr : ', arr); // 删除最后一个索引 arr.length -= 1; console.log('arr : ', arr);

---

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);
}

拼接细节如下：

splice(startIndex, 拼接数)

---

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

stack.reverse().shift();

stack.push(0);

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

---

如果您想在 javascript 中从数组末尾删除 n 项，您可以轻松使用：

arr.splice(-n, n);

---

使用扩展运算符：

const a = [1,2,3] const [, ...rest] = a.reverse(); const withoutLast = rest.reverse(); console.log（没有最后一个）

---

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

---

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

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

---

我得到了最好的答案！

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]

---