javascript - 从数组中删除最后一项

Question

我有以下数组。

var arr = [1,0,2];

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

我使用过arr.slice(-1);，但它不会删除该值。

Answer 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"]

Answer 2

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

Answer 3

您可以使用以下.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()现在or方法的基本语法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（正如我们在上面的演示中已经看到的那样）。

现在，让我们在这里谈谈方法语法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)

希望能帮助到你！

Answer 4

以身作则：

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]

Answer 5

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

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

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

arr.splice(-1, 1);

或pop：

arr.pop();

Answer 6

我认为.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());

这可能是不可取的......

希望这可以节省您一些时间。

Answer 7

有一个功能，在这里解释：

arr.pop();

Answer 8

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

var arr = [1,2,3,4];
arr.pop() //returns 4 as the value
arr // value 4 is removed from the **arr** array variable

只是一个注释。当您执行pop()函数时，即使该行返回了弹出的项目，原始数组也会受到影响并删除弹出的元素。

Answer 9

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

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

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

Answer 10

值得注意的是，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
  

Answer 11

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

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

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

Answer 12

您可以使用以下两种方式进行操作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()aspop()从某个数组中删除最后一个元素来删除最后一个元素。
利用arr.pop()

Answer 13

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

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

Answer 14

另一种方法是基于索引进行过滤：

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

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

Answer 15

splice(index,howmany) - 这个解决方案听起来不错。但是这多少只适用于正数组索引。要删除最后两项或三项，请使用索引本身。

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

Answer 16

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

// 删除最后一个元素 // 需要检查 arr.length > 0

Answer 17

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

Answer 18

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

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

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

Answer 19

2019 ECMA5解决方案：

const new_arr = arr.reduce((d, i, idx, l) => idx < l.length - 1 ? [...d, i] : d, [])

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

Answer 20

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

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

Answer 21

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

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

拼接细节如下：

splice(startIndex, 拼接数)

Answer 22

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

stack.reverse().shift();

stack.push(0);

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

Answer 23

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

arr.splice(-n, n);

Answer 24

使用扩展运算符：

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

Answer 25

干脆arr.splice(-1)就行。

Answer 26

// Setup
var myArray = [["John", 23], ["cat", 2]];

// Only change code below this line
var removedFromMyArray;
removedFromMyArray = myArray.pop()

Answer 27

我得到了最好的答案！

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]