我有下面的数组。
var arr = [1,0,2];
我想删除最后一个元素,即2。
我使用了arr。slice(-1);但它并没有删除值。
我有下面的数组。
var arr = [1,0,2];
我想删除最后一个元素,即2。
我使用了arr。slice(-1);但它并没有删除值。
你需要这样做,因为slice不会改变原始数组。
arr = arr.slice(0, -1);
如果你想改变原始数组,你可以使用splice:
arr.splice(-1, 1);
或者流行:
arr.pop();
使用splice(startPosition, deleteCount)
array.splice(-1)
Var数组= ['abc','def','ghi','123']; Var remove = array.splice(-1);/ /最后一项 Console.log ('array:', array); Console.log ('removed:', removed);
使用JavaScript约定的Array.prototype.pop()。
let fruit = ['apple', 'orange', 'banana', 'tomato'];
let popped = fruit.pop();
console.log(popped); // "tomato"
console.log(fruit); // ["apple", "orange", "banana"]
你可以简单地使用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。片(0,1);//返回[1,0] console.log (newArr); $ (" # div1”)。Text ('[' + arr + ']'); $ (" # div2”)。text('[' + newArr + ']'); < script src = " http://code.jquery.com/jquery.min.js " > < /脚本> <b>原始阵列:</b> . < div id = " div1 " > < / div > < br / > <b>切片后(0,-1):</b> < div id = " div2 " > < / div >
而不是做:
arr.slice(-1); // returns [2]
下面是一个演示:
Var arr = [1,0,2]; var newArr = arr.slice(-1);//返回[2] console.log (newArr); $ (" # div1”)。Text ('[' + arr + ']'); $ (" # div2”)。text('[' + newArr + ']'); < script src = " http://code.jquery.com/jquery.min.js " > < /脚本> <b>原始阵列:</b> . < div id = " div1 " > < / div > < br / > <b>切片后(-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()方法语法中的结束参数。它同样是一个从零开始的索引,从数组的提取在此结束。假设我们有一个数组:-
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)从序列中倒数第二个元素提取第一个元素。所以,我们得到了想要的输出。我们也可以做like
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一样。片(0,22)。然后,您可以在这里简单地实现负索引逻辑& do
arr.slice(0, -1) // same result as arr.slice(0, 22)
art .slice(-1)将返回数组最后一个元素的副本,但原始数组不作修改。
要从数组中移除最后n个元素,使用arr.splice(-n)(注意“splice”中的“p”)。返回值将是一个包含已删除元素的新数组。
更简单的是,对于n == 1,使用val = arr.pop()
splice(index,howmany) -这个解决方案听起来不错。但是This howmany只适用于正数组下标。若要删除最后两项或三项,请使用索引本身。
例如,使用splice(-2)删除最后两项。拼接(-3)用于移除最后三个项目。
这是删除最后一项的好方法:
if (arr != null && arr != undefined && arr.length > 0) {
arr.splice(arr.length - 1, 1);
}
拼接细节如下:
splice(startIndex, splice的个数)
类的最后一个元素删除和存储时,此方法更有用 数组中。
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) //只有大的东西 .slice(0, -1) //删除最后一项!Slice(-1)将给出第一个元素 .map(x => '数字是:${x} ')
它可能需要更多的混乱和变量管理,用“pop”做同样的事情,因为不像map, filter等,你不会得到一个新的数组。
push也是一样,它将一个元素添加到数组的末尾。你最好使用concat,因为它可以让你保持流动。
myArray = [1,2,3,4,5,6,7,8,9,10]; var newArrayOfThings = myArray .filter(x => x > 5) //只有大的东西 .slice(-1) //去掉"10" .concat([100]) //使用concat时,必须传递一个数组 .map(x => ' number is: ${x} ') //映射到一组字符串
以身作则:
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():
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 ()
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,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)
// 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);