从数组中删除最后一项

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

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

如果要更改原始数组，可以使用：splice

arr.splice(-1, 1);

或：pop

arr.pop();

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

Array.prototype.pop（） 通过 JavaScript 约定。

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

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

有一个功能，这里解释：

arr.pop();

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

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

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

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

解释：-

现在 or in short 方法的基本语法是：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 位于此处的位置 1 以及之后的所有内容。现在，在您的例子中，您已经传递了一个负索引，即作为 begin 参数，它表示与序列末尾的偏移量。因此，在您的例子中，提取序列中的最后一个数组元素，即（正如我们在上面的演示中已经看到的那样）。[0,2]-1slice(-1)2

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

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

我们只想得到数组中的元素。现在，从序列开始的位置是，对于最后一个元素，它是 。我们需要在这里结束位置 5 的提取，因为我们需要在该位置之前获取元素。因此，我们将在这里简单地实现方法，例如2,5,32234slice()

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

在你的例子中，我们已经实现了作为结束参数，所以我们的代码是这样的-1

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

作为负索引，表示与序列末尾的偏移量。因此，通过序列中的倒数第二个元素提取第一个元素。因此，我们得到了所需的输出。我们也可以做endslice(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 个的位置，然后像 .然后，您可以简单地在此处实现负索引逻辑 & doarr.slice(0, 22)

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

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

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

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

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

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

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

arr.splice(-1,1)会回到你身边，而会回到你身边array [1,0];arr.slice(-1,1)array [2];

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

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

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

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

拼接细节如下：

splice（startIndex， 拼接数）

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

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(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”做同样的事情，因为与 、 等不同，你不会得到一个新的数组。mapfilter

这与 是一样的，它将一个项目添加到数组的末尾。你可能会更好，因为这样可以让你保持流动。pushconcat

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
  

举例学习：

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]

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

stack.reverse().shift();

stack.push(0);

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

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

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

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

我认为这是最“正确”的解决方案，但是，有时它可能不起作用，因为您需要在没有最后一个元素的情况下使用数组.......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());

这可能不可取......

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

您可以使用两种方式做到这一点：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

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

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, [])

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

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

arr.splice(-n, n);

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

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.filter((element, index) => index < arr.length - 1);

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

使用点差运算符：

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

简直就可以了。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]

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

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

var arr = [1,0,2];

arr = arr.filter((_,i,a) => i !== (a.length-1));

解释： 我们使用的是数组筛选方法，它接受 3 个回调：

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

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

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