关于javascript：从数组中删除最后一项


Remove last item from array

我有以下数组。

1
var arr = [1,0,2];

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

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

相关讨论

1
2
3
4
5
let fruit = ['apple', 'orange', 'banana', 'tomato'];
let popped = fruit.pop();

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

MDN上array.prototype.pop的文档

相关讨论

使用拼接(索引，多少)

1
arr.splice(-1,1)
相关讨论

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

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

这是一个演示：

1
2
3
4
5
6
var arr = [1, 0, 2];
var newArr = arr.slice(0, -1);    // returns [1,0]

console.log(newArr);
$('#div1').text('[' + arr + ']');
$('#div2').text('[' + newArr + ']');
1
2
3
4
5
<script src="http://code.jquery.com/jquery.min.js">
Original Array    :

<br/>
After slice(0, -1):

而不是：

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

这是一个演示：

1
2
3
4
5
6
var arr = [1, 0, 2];
var newArr = arr.slice(-1);    // returns [2]

console.log(newArr);
$('#div1').text('[' + arr + ']');
$('#div2').text('[' + newArr + ']');
1
2
3
4
5
<script src="http://code.jquery.com/jquery.min.js">
Original Array    :

<br/>
After slice(-1):

说明：

现在，Array.prototype.slice()或简而言之，slice()方法的基本语法是：

1
arr.slice([begin[, end]])

在这里，

begin参数是从数组开始提取的基于零的索引。所以，假设基于上面的例子，如果我们做类似的事情

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

它将从位置0开始返回序列的所有数组元素，即[1,0,2]。同样，如果我们这样做

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

它将返回[0,2]，因为0在这里和之后的所有位置1。现在，在您的例子中，您已经传递了一个负索引，即-1作为开始参数，它表示从序列结束的偏移量。因此，在您的例子中，slice(-1)提取序列中的最后一个数组元素，即2(我们已经在上面的演示中看到)。

现在，我们来讨论一下slice()方法语法中的end参数。它也是一个以零为基的索引，从数组中提取的结果将在此结束。所以，假设我们有一个类似的数组：

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

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

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

在您的例子中，我们已经实现了-1作为结束参数，因此我们的代码如下

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

作为一个负指数，end表示序列末端的偏移量。因此，slice(0,-1)通过序列中的第二个到最后一个元素提取第一个元素。所以，我们得到了期望的输出。我们也可以喜欢

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

我们将得到相同的输出。但是，我在这里使用了-1，因为即使对于像

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

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

希望它有帮助！

相关讨论

以身作则：

1
2
3
4
5
6
7
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不会更改原始数组。

1
arr = arr.slice(-1);

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

1
arr.splice(-1, 1);

或pop：

1
arr.pop();

这里有一个函数，解释如下：

1
arr.pop();
相关讨论

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

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

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

我认为EDOCX1[1]是最"正确"的解决方案，但是，有时它可能不起作用，因为您需要在没有最后一个元素的情况下使用数组…

在这种情况下，您可能需要使用以下内容，它将返回[1,2,3]。

1
2
var arr = [1,2,3,4];
console.log(arr.splice(0,arr.length-1));

当.pop()返回4时：

1
2
var arr = [1,2,3,4];
console.log(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()。

    This method is more helpful to delete and store the last element of an
    array.

    1
    2
    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.

    Now the results are:

    1
    2
    console.log(sampleArray); //This will give you [1,2,3]
    console.log(lastElement); //this will give you 4
    相关讨论

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

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

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

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

    //删除最后一个元素//需要检查arr.length是否大于0

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

    如果您喜欢使用链接的命令样式处理数据集合，那么对于类似的事情，您真的需要使用slice。

    例如:

    1
    2
    3
    4
    5
    6
    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合作，因为这样可以让你继续前进。

    1
    2
    3
    4
    5
    6
    7
    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

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

    例如，拼接(-2)以删除最后两个项目。用于移除最后三个项目的接头(-3)。

    假设你有var arr = [1,0,2]。

    arr.splice(-1,1)将返回你的array [1,0];，arr.slice(-1,1)将返回你的array [2];。

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

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

    stack.reverse().shift();

    stack.push(0);

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

    相关讨论

    如果你不想知道哪些元素被移除了，你可以使用DropRight：

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

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

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

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

    拼接细节如下：

    拼接(开始索引，拼接数量)