javascript - javaScript Array删除元素

  显示原文与译文双语对照的内容

使用delete 运算符在数组元素上的区别是什么,而不是使用 Array.splice 方法? 例如:


myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//or
myArray.splice (1, 1);

如果我可以删除数组元素( 如我可以使用对象),为什么还要使用拼接方法?

时间:

在本例中删除只将元素设置为未定义:


> myArray = ['a', 'b', 'c', 'd']
 ["a","b","c","d"]
> delete myArray[0]
 true
> myArray
 [undefined,"b","c","d"]

拼接实际上从数组中删除元素:


> myArray = ['a', 'b', 'c', 'd']
 ["a","b","c","d"]
> myArray.splice(0, 2)
 ["a","b"]
> myArray
 ["c","d"]

Array.remove() 方法

John Resig,jQuery创建了一个非常方便的Array.remove 方法,我总是在我的项目中使用它。


//Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
 var rest = this.slice((to || from) + 1 || this.length);
 this.length = from <0? this.length + from : from;
 return this.push.apply(this, rest);
};

下面是如何使用它的一些示例:


//Remove the second item from the array
array.remove(1);
//Remove the second-to-last item from the array
array.remove(-2);
//Remove the second and third items from the array
array.remove(1,2);
//Remove the last and second-to-last items from the array
array.remove(-2,-1);

的网站

因为删除只删除数组中元素的对象,所以数组的长度不会改变。 拼接删除对象并缩短阵列。

下面的代码将显示"一个","b","未定义",""


myArray = ['a', 'b', 'c', 'd']; delete myArray[2];

for (var count = 0; count <myArray.length; count++) {
 alert(myArray[count]);
}

虽然这将显示"一个","b","d"


myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count <myArray.length; count++) {
 alert(myArray[count]);
}

我在试图理解如何从数组中删除元素的每一次出现时遇到了这个问题。 splicedelete的比较,用于从 items 数组中删除每个 'c'


var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c')!== -1) {
 items.splice(items.indexOf('c'), 1);
}

console.log(items);//["a","b","d","a","b","d"]

items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c')!== -1) {
 delete items[items.indexOf('c')];
}

console.log(items);//["a","b", undefined,"d","a","b", undefined,"d"]
​

splice 将使用数字索引。

delete 可以用于其他类型的索引。

例如:


delete myArray['text1'];

也许值得注意的是,拼接只在数组上工作。 ( 对象属性不能依赖于一致的顺序。)

要从对象中删除key-value对,删除实际上是你想要的:


delete myObj.propName;//, or:
delete myObj["propName"];//Equivalent.

如果你想要迭代一个大数组并有选择地删除元素,那么每次删除时调用 splice() 都会很昂贵,因为 splice() 每次都需要re-index元素。 因为数组在Javascript中是关联的,所以删除单个元素的效率会更高,然后再将数组删除。

你可以通过构建一个新数组来完成它。 e.g


function reindexArray( array )
{
 var result = [];
 for( var key in array )
 result.push( array[key] );
 return result;
};

但是我不认为你可以修改原始数组中的键值,这将更加高效- 看起来你必须创建一个新数组。

注意,你不需要检查"未定义"条目,因为它们实际上不存在,并且for循环does不返回它们。 它是数组打印的一个工件,以未定义的方式显示它们。 它们似乎在内存中不存在。

如果你能使用 slice() 这样的东西会比较好,但它并不是 re-index 。 谁知道更好的方法?


实际上,你可以按照下面的方式进行,它可能更高效,performance-wise:


reindexArray : function( array )
{
 var index = 0;//The index where the element should be
 for( var key in array )//Iterate the array
 {
 if( parseInt( key )!== index )//If the element is out of sequence
 array[index] = array[key];//Move it to the correct, earlier position in the array
 ++index;//Update the index
 }

 array.splice( index );//Remove any remaining elements (These will be duplicates of earlier items)
},

删除就像一个非现实世界的情况下,它只是删除条目,但是数组长度保持不变:

节点终端示例:


> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b',, 'd', 'e' ]

这是一个按索引删除数组项的函数,使用了 slice(),它将arr作为第一个参数,而你想要删除的成员索引作为第二个参数。 可以看到,它实际上删除了数组的成员,并将数组长度减少 1


function(arr,arrIndex){
 return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

上面的函数是把所有成员带到索引,索引之后的所有成员,并将它们连接起来,并返回结果。

下面是一个使用上面的函数作为节点模块的示例,查看终端会很有用:


> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ]//c ya later
> newArray.length
3

请注意,这将不是工作一个数组有受骗的人,因为 indexOf("c") 就会第一个出现,只有拼接和删除第一个"c"它发现。

你可以用这样的东西


var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a!== 'undefined';}));

应该显示 [1, 2, 3, 4, 6 ]

...