不需要使用 indexof 或 spolice 。 但是, 如果您只想要删除一个元素的发生, 它的效果会更好 。

查找并移动( 移动) :

function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

使用索引和串点( 索引) :

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

只使用复数( 复数) :

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

带有 1000 元素的阵列( 平均超过 10,000 次运行) 的节点js 上的运行时间 :

指数比移动要慢10倍左右。 即使通过删除对 Enterof 的调用来改进指数,它的表现也比移动差得多。

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms

理解这一点:

您可以使用 JavaScript 阵列来组合数值, 并在它们上面循环。 数组项目可以以多种方式被添加和删除。 总共有9种方法( 使用其中适合你的任何一种方法) 。 JavaScript 阵列不使用删除方法, 而是有多种方法可以清除数组值 。

这样做的不同方法:

您可以以这些方式从 JavaScript 阵列中删除元素 :

1-pop: 从阵列结尾处移除 。

2- Shift: 从数组的开头删除 。

3- 秒: 从特定的阵列索引中删除 。

4- 过滤器 : 允许您通过程序从矩阵中移除元素 。

---

方法 1: 从 JavaScript 阵列起始时删除元素

var ar = [“零 ” , “一 ” , “二 ” , “二 ” , “三 ” ; ar. shift (); ; // 返回“ 零” 控制台. log (ar ) ; / / [“ 1 ” , “ 2 ” , “ 三 ” ]

方法2:从 JavaScript 阵列结束时删除元素

var ar ar = [1、2、3、4、5、6]; ar = 4; // 设定删除元素控制台的长度; log( ar ); / / [ 1、 2、 3、 4] var ar ar = [ 1、 2、 3、 4、 5、 6] ; ar.pop (); / 返回 6 lador. log ( ar ); / [ 1、 2、 3、 4、 5]

方法 3: 在 JavaScript 中使用串列来移除队列元素

var arr = [1、2、3、4、5、6、7、8、9、10] ; var = rr.spice(2,2,2); laporal.log(arr); var list = [“巴”、“巴”、“巴”、“巴”、“瓦兹”、““foo”、“qux”; 列表.spice(0, 2); laft.log(list);

方法 4 : 使用 Splice 按值删除队列项目

var arr = [1、2、3、4、4、5、6、7、8、9、10]; for( var i = 0; i < arr. long; i++){如果( rr) = 5 { rr.spice(i, 1);} { rr.spice( y, 1);} { { [1, 2, 3, 4, 4, 6, 7, 8, 9, 9, 10];f( var i = 0; i < arr. lon; i++){ 如果 (rr) = 5 { arr.spice(i, 1); i-;} } /[1, 2, 3, 4, 6, 7, 8, 9, 10]

方法5:使用矩阵过滤法按值删除项目

var 数组 = [1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10] ; var 过滤 = 数组. filter( 功能( 值、 索引、 rr) { 返回值 > 5; } // filter { [6, 7, 8, 9] / filter { [1、2, 3, 4, 5, 6, 7, 8, 9, 10]

方法6: Lodash 阵列清除方法

var 数组 = [1, 2, 3, 4] ; var evens =_.remove( 数组, 函数(n) { 返回 n%% 2 { { 0;} ); 控制台. log( 数组); / / { {[ 1, 3] 等式. log( events); / { { {[ 2, 4]

方法7:制定方法

var 数组 = [1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10]; 函数数组 remove( rr, value) { 返回 arr. filter( ele) { 返回 ele yel = value;}} var 结果 = tratremove( 数组, 6); / 结果 = [1, 2, 3, 4, 5, 7, 8, 9, 10]

方法 8 : 使用 删除运算符明确删除矩阵元素

var ar = [1, 2, 3, 4, 4, 5, 6]; 删除 ar[4]; // 删除含有索引 4 控制台的元素 。 log( ar ); / [ 1, 2, 3, 4, 未定义, 6] 警报( ar ); / 1, 2, 3,4,6

方法 9: 清除或重置 JavaScript 阵列

var ar = [1、2、3、4、4、5、6];//do staffar = [];//a new, 空阵列;vararar1 = [1、2、3、4、5、6];varar2 = arr1;/ 参考rr1 由另一个变量ar1 = [;控制台(rr2);/ 输出[1、2、3、4、4、5、6] rr1 = [1、2、3、4、5、6] ;varar2 = arr1;// 参考arr1 =另一个变量ar1 = [;控制台(rr2);/ 输出[1、2、3、4、5、6]

摘要:

关键是要通过删除 JavaScript 矩阵项目来管理您的数据。 虽然没有单一的“ 撤销” 功能, 但您可以使用各种方式和战略清除不必要的阵列元素 。

我张贴我的代码,删除一个阵列元素, 并缩短阵列长度 。

function removeElement(idx, arr) {
    // Check the index value
    if (idx < 0 || idx >= arr.length) {
        return;
    }
    // Shift the elements
    for (var i = idx; i > 0; --i) {
        arr[i] = arr[i - 1];
    }
    // Remove the first element in array
    arr.shift();
}

我本人也有这个问题(在更换阵列是可以接受的情况下),

var filteredItems = this.items.filter(function (i) {
    return i !== item;
});

要给上面的片段略加上下文:

self.thingWithItems = {
    items: [],
    removeItem: function (item) {
        var filteredItems = this.items.filter(function (i) {
            return i !== item;
        });

        this.items = filteredItems;
    }
};

此解决方案应该同时使用引用项和值项。 它都取决于您是否需要保持对原始数组的引用, 以判断该解决方案是否适用 。

Array. prototype. removeByValue = 函数( val) {, 对于 (var i = 0; i < this. long; i++) { 如果 (i) val) { this. splice (i, 1); i- ; } 返回此 ;} var falts = [apple, 'banana', 'carrot', 'orange' ] ; falves.remove ByValue ('banana'); 礼服. log (fruts); / / - > [apple, 'carrot', 'orange' ]

2017-005-08

大多数给定的回答都用于严格的比较, 意思是两个对象在内存( 或原始类型) 中引用完全相同的对象, 但通常您想要从具有一定值的数组中删除一个非原始对象。 例如, 如果您给服务器打电话, 并想要对照本地对象检查已检索到的对象 。

const a = {'field': 2} // Non-primitive object
const b = {'field': 2} // Non-primitive object with same value
const c = a            // Non-primitive object that reference the same object as "a"

assert(a !== b) // Don't reference the same item, but have same value
assert(a === c) // Do reference the same item, and have same value (naturally)

//Note: there are many alternative implementations for valuesAreEqual
function valuesAreEqual (x, y) {
   return  JSON.stringify(x) === JSON.stringify(y)
}


//filter will delete false values
//Thus, we want to return "false" if the item
// we want to delete is equal to the item in the array
function removeFromArray(arr, toDelete){
    return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
}

const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
const resultArray = removeFromArray(exampleArray, a);

//resultArray = [{'field':90}]

数值AreEqual有替代/更快的操作,但这样可以操作。如果您有特定的字段要检查,也可以使用自定义的比较器(例如,有些已检索的 UUID 相对于本地的 UUID ) 。

2. 还注意到这是一个功能操作,意即它不改变原始阵列。