从数组中删除最后一项

我有以下数组。

var arr = [1,0,2];

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

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

1103981 次浏览
小开

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

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

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

arr.splice(-1, 1);

或pop：

arr.pop();
小开
最佳答案

使用开始拼接删除数

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]

下面是一个demo：

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]

下面是一个demo：

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)这样做。然后你可以简单地在这里实现负索引逻辑&do 

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

希望有帮助！

小开

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

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

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

小开

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

例如，spice（-2）删除最后两个项目。spice（-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（start Index，拼接数）

小开

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

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”做同样的事情可能需要更多的混乱和变量管理，因为与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

小开

通过例子学习：

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

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

小开

使用Lodash，您可以使用删除权限，如果您不关心删除了哪些元素：

_.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：从指示的索引中，应该删除多少连续数据。

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


提交答案