从数组中删除最后一项

Array.prototype.pop（） by JavaScript 约定。

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

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

.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 作为 begin 参数，它指示与序列末尾的偏移量。因此，在您的情况下，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 作为 end 参数，因此我们的代码类似于

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];
console.log(arr.pop());

这可能不可取...

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

有一个函数，在这里解释：

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 都会返回一个新数组，而 .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
  

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

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

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

splice()以两种方式执行此操作：

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

splice(position_to_start_deleting, how_many_data_to_delete)采用两个参数。

零开始删除的索引。 how_many_data_to_delete：从指示的索引中，应删除多少个连续数据。

您还可以使用 pop() 删除最后一个元素，因为pop()从某个数组中删除最后一个元素。
使用 arr.pop()

var arr = [ 0, 1, 2, 3, 4, 5, 6, 7 ];
// using slice
arr = arr.slice(0, -1);
console.log('arr : ', arr);
// using splice
arr.splice(-1);
console.log('arr : ', arr);
// using pop
arr.pop();
console.log('arr : ', arr);
// using shift and reverse
arr.reverse().shift()
arr.reverse();
console.log('arr : ', arr);
// using spread Operator and reverse
const [, ...exceptLast] = arr.reverse();
arr = exceptLast.reverse();
console.log('arr : ', arr);
// removing last index
arr.length -= 1;
console.log('arr : ', arr);

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

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

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

此方法更有助于删除和存储 数组。

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

拼接（索引，多少） - 这个解决方案听起来不错。但是这个多少只适用于正数组索引。要删除最后两个项目或三个项目，请使用索引本身。

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

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 = [1,0,2];
arr.length--; 

删除最后一个元素，但您可能需要先检查是否arr.length > 0。

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];

使用展开运算符：

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

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

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

拼接细节如下：

（起始索引，拼接数）

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

如果您正在寻找不需要初始化多个变量的单行代码：

var arr = [1,0,2];
arr = arr.filter((_,i,a) => i !== (a.length-1));

解释：我们使用数组过滤器方法，该方法接受 3 个回调：

1. element （ _ ）： 迭代期间的当前元素
2. index （ i ）： 元素迭代的索引
3. array （ a ）： 用于筛选器的数组

因此，我们只需跳过该元素if它是正在使用的array中的最后一个元素。

_只是一个占位符，因为我们实际上并没有使用它。

简单地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]