删除JavaScript中的数组元素-删除vs拼接

在数组元素上使用与使用的区别是什么

例如：

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

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

---

如果我可以像删除对象一样删除数组元素，为什么还要使用拼接方法呢？

因为删除只会从数组中的元素中删除对象，数组的长度不会改变。“拼接”将删除对象并缩短阵列

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

以下代码将显示“a”、“b”、“未定义”、“d”

myArray=['a'，'b'，'c'，'d']；删除myArray[2]；
对于（var count=0；count

而这将显示“a”、“b”、“d”

myArray=['a'，'b'，'c'，'d']；myArray.剪接（2,1）；
对于（var count=0；count

delete

将删除对象属性，但不会重新索引数组或更新其长度。这使其看起来似乎未定义：

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

请注意，它实际上并没有设置为值

undefined

，而是将属性从数组中删除，使其看起来未定义。Chrome开发工具通过在记录阵列时打印

empty

来明确这一区别

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

实际上删除元素，重新索引数组，并更改其长度

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

发件人：

删除数组元素时 数组长度不受影响。对于 例如，如果删除[3]，则会删除[4] 仍然a[4]和a[3]未定义。这 即使删除最后一个，也会保留 数组的元素（删除 a[a.length-1]）

---

拼接

将与数字索引一起使用

而

delete

可以用于其他类型的索引

例如：

delete myArray['text1'];

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

Array.remove（）方法 jQuery的创建者John Resig创建了一个非常方便的

数组

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

我在试图理解如何从数组中删除元素的每个匹配项时偶然发现了这个问题。用于从
项目
数组中删除每个
'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（）会很昂贵，因为splice（）每次都必须对后续元素重新编制索引。因为数组在Javascript中是关联的，所以删除单个元素然后重新索引数组会更有效

您可以通过构建新阵列来实现这一点。e、 g

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

但是我不认为您可以修改原始数组中的键值，这会更有效-看起来您可能需要创建一个新数组

注意，您不需要检查“未定义”条目，因为它们实际上不存在，for循环也不会返回它们。这是一个数组打印的工件，将它们显示为未定义。它们似乎不存在于记忆中

如果您可以使用像slice（）这样更快的东西，那就太好了，但它不会重新编制索引。有人知道更好的方法吗


实际上，您可以按如下方式进行操作，这可能更高效、更高效：

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)
},

可能还值得一提的是，splice仅适用于阵列。（不能依赖对象属性来遵循一致的顺序。）

要从对象中删除键值对，实际上需要删除：

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

你可以用这样的东西


var my_数组=[1,2,3,4,5,6]；
删除我的_数组[4]；
log（my_array.filter（函数（a）{returntypeof a！='undefined'；}））；//[1,2,3,4,6]
//结果：myArray=['b'，'c'，'d']
 删除的行为类似于非真实世界的情况，它只是删除项目，但数组长度保持不变：

来自节点终端的示例：

> 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”。
indexOf
也接受引用类型。假设以下场景：


var arr=[{item:1}，{item:2}，{item:3}]；
var found=find（2,3）//伪代码：将返回[{item:2}，{item:3}]
var l=找到的长度；
而(l--){
var index=arr.indexOf（找到[l]）
阵列拼接（索引1）；
}
控制台日志（arr.length）//1
最简单的方法可能是

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

希望这有帮助。
参考文献：
< P>如果要删除的元素在中间（比如我们想删除‘C’，它的索引是1），可以使用：

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

如上所述，使用
splice（）
似乎是一个完美的选择

splice（）方法通过删除现有元素和/或添加新元素来更改数组的内容

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

语法
参数
开始
开始更改数组的索引。如果大于数组的长度，则实际起始索引将设置为数组的长度。如果是负数，那么许多元素都将从末尾开始

删除计数
一个整数，指示要删除的旧数组元素数。如果deleteCount为0，则不删除任何元素。在这种情况下，您应该至少指定一个新元素。如果deleteCount大于从开始时开始的数组中剩余的元素数，则所有元素
var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

const arr = [1, 2, 3, 4, 5];

delete arr[1];

[1, empty, 3, 4, 5];

arr[1]; //undefined

arr.splice(1, 1);

[1, 3, 4, 5];

arrName.pop();

arrName.shift();

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

arrName.splice(-1);

 delete arrName[1];

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

let y = 1;
let ary = [];
console.log("Fatal Error Coming Soon");
while (y < 4294967295)
{
    ary.push(y);
    ary[y] = undefined;
    y += 1;
}
console(ary.length);

FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory.

let x = 1;
let ary = [];
console.log("This will take a while, but it will eventually finish successfully.");
while (x < 4294967295)
{
    ary.push(x);
    ary[x] = undefined;
    delete ary[x];
    x += 1;
}
console.log(`Success, array-length: ${ary.length}.`);

myArray = ['a', 'b', 'c', 'd'];
myArray = myArray.filter(x => x !== 'b');