从数组中删除最后一项

我有以下数组。

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作为begin参数，它指示与序列末尾的偏移量。因此，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为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个位置以及do like的位置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()删除最后一个元素，因为as 从某个数组中删除了最后一个元素。
采用arr.pop()

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

要从n数组中删除最后一个元素，请使用arr.splice(-n)（请注意“ splice”中的“ 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）-这个解决方案听起来不错。但这种的howmany只会工作的积极数组索引。要删除最后两个或三个项目，请使用索引本身。

例如，splice（-2）删除最后两个项目。splice（-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()创建新数组，不更改现有数组。

如果要从javascript数组末尾删除n个项目，可以轻松使用：

arr.splice(-n, n);