如何从数组中删除特定项目?

2020/09/12 19:33 · javascript ·  · 0评论

我有一个数字数组,正在使用该.push()方法向其中添加元素。

有没有一种简单的方法可以从数组中删除特定元素?

我正在寻找类似的东西:

array.remove(number);

我必须使用核心 JavaScript。不允许使用框架。

使用查找index要删除的数组元素的indexOf,然后使用删除该索引splice

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

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array); 

的第二个参数splice是要删除的元素数。注意,splice将在适当位置修改数组,并返回一个包含已删除元素的新数组。


出于完整性的原因,这里有一些功能。第一个功能仅删除一个匹配项(即,5从中删除第一个匹配项[2,5,9,1,5,8,5]),而第二个功能则删除所有匹配项:

function removeItemOnce(arr, value) {
  var index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}

function removeItemAll(arr, value) {
  var i = 0;
  while (i < arr.length) {
    if (arr[i] === value) {
      arr.splice(i, 1);
    } else {
      ++i;
    }
  }
  return arr;
}
//Usage
console.log(removeItemOnce([2,5,9,1,5,8,5], 5))
console.log(removeItemAll([2,5,9,1,5,8,5], 5))

我不知道你的array.remove(int)表现如何我想到了您可能想要的三种可能性。

要在索引处删除数组的元素i

array.splice(i, 1);

如果number要从数组中删除每个具有值的元素

for(var i = array.length - 1; i >= 0; i--) {
    if(array[i] === number) {
        array.splice(i, 1);
    }
}

如果只想使索引处的元素i不再存在,但又不想更改其他元素的索引:

delete array[i];

于2016年10月编辑

  • 做到简单,直观和明确(Occam的剃刀
  • 做到一成不变(原始数组保持不变)
  • 如果您的浏览器不支持标准JavaScript函数,请执行此操作- 使用polyfill

在此代码示例中,我使用“ array.filter(...)”函数从数组中删除不需要的项。此函数不会更改原始数组,而是创建一个新数组。如果您的浏览器不支持此功能(例如,版本9之前的Internet Explorer或版本1.5之前的Firefox),请考虑使用Mozilla中的过滤器polyfill

删除项目(ECMA-262版本5代码又称为旧式JavaScript)

var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) {
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

删除项目(ECMAScript 6代码)

let value = 3

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

重要说明 ECMAScript 6箭头函数语法完全不受Internet Explorer,45之前的Chrome,22之前的Firefox和10之前的Safari的支持。要在旧的浏览器中使用ECMAScript 6语法,可以使用BabelJS


删除多个项目(ECMAScript 7代码)

此方法的另一个优点是您可以删除多个项目

let forDeletion = [2, 3, 5]

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

重要提示 “ array.includes(...)”功能在Internet Explorer,47之前的Chrome,43之前的Firefox,9之前的Safari和14之前的Edge中完全不支持,因此这里是Mozilla的polyfill

删除多个项目(将来可能)

如果“此绑定语法”提议曾经被接受,则可以执行以下操作:

// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

let arr = [1, 2, 3, 4, 5, 3]

// :: This-Binding Syntax Proposal
// using "remove" function as "virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

在BabelJS中自己尝试:)

参考

这取决于您是否要保留空白位置。

如果您确实想要一个空插槽:

array[index] = undefined;

如果你想要一个空槽:

//To keep the original:
//oldArray = [...array];

//This modifies the array.
array.splice(index, 1);

而且,如果您需要该项目的值,则可以只存储返回的数组的元素:

var value = array.splice(index, 1)[0];

如果要删除数组的任一端,则可以将其array.pop()用于最后一个数组array.shift()第一个数组(也都返回该项的值)。

如果您不知道该项目的索引,则可以使用array.indexOf(item)获取它(在if()中获取一个项目或在while()中获取所有项目)。array.indexOf(item)返回索引或-1找不到索引。 

一个朋友在Internet Explorer 8中遇到问题,向我展示了他的工作。我告诉他这是错误的,他告诉我他在这里得到了答案。当前的最佳答案不能在所有浏览器(例如Internet Explorer 8)中都起作用,并且只会删除该项目的第一个匹配项。

从阵列中删除所有实例

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

它向后循环遍历数组(因为索引和长度会随着项目的删除而改变),并在找到后删除该项目。它适用于所有浏览器。

有两种主要方法:

  1. splice()anArray.splice(index, 1);

  2. 删除delete anArray[index];

对数组使用delete时要小心。这对删除对象的属性很有用,但对数组却不太好。最好splice用于数组。

请记住,当您使用delete数组时,可能会得到错误的结果anArray.length换句话说,delete将删除该元素,但不会更新length属性的值。

您还可以期望在使用delete后索引号中出现空洞,例如,最终可能会具有使用delete之前的索引1、3、4、8、9和11,以及长度。在这种情况下,所有索引for循环都会崩溃,因为索引不再是顺序的。

如果delete由于某种原因而被迫使用,则for each在需要遍历数组时应使用循环。实际上for,如果可能,请始终避免使用索引循环。这样,代码将更健壮,并且不易出现索引问题。

Array.prototype.remove_by_value = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remove_by_value(3);

Array.prototype.remove_by_value = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remove_by_value('hello')

console.log(rooms)

无需使用indexOfsplice但是,如果只想删除一个元素,它的性能会更好。

查找并移动(移动):

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

使用indexOfsplice(indexof):

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

仅使用splice(拼接):

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

在具有1000个元素的数组的nodejs上的运行时(平均运行10000次以上):

indexof大约比move慢10倍即使除去调用改进indexOf拼接它的性能比更糟糕的举动

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

这提供了谓词而不是值。

注意:它将更新给定的数组,并返回受影响的行。

用法

var removed = helper.removeOne(arr, row => row.id === 5 );

var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

定义

var helper = {

    // Remove and return the first occurrence

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences

    remove: function(array, predicate) {
        var removed = [];

        for (var i = 0; i < array.length;) {

            if (predicate(array[i])) {
                removed.push(array.splice(i, 1));
                continue;
            }
            i++;
        }
        return removed;
    }
};

您可以使用filter方法轻松完成此操作

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log(remove([1, 2, 1, 0, 3, 1, 4], 1));

这消除了来自阵列的所有元素和也工作速度比的组合sliceindexOf

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

如果您不想扩展全局对象,则可以执行以下操作:

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

但是,我发布此消息的主要原因是为了警告用户不要该页面的注释(2007年12月14日)中建议的替代实现:

Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

一开始它似乎运行良好,但是经过一个痛苦的过程,我发现当尝试删除数组中倒数第二个元素时它失败了。例如,如果您有一个包含10个元素的数组,并尝试使用此元素删除第9个元素:

myArray.remove(8);

您最终得到一个8元素数组。不知道为什么,但是我确认John的原始实现没有这个问题。

Underscore.js可用于解决多个浏览器的问题。如果存在,它将使用内置浏览器方法。如果缺少它们(例如在较旧的Internet Explorer版本中),则使用其自己的自定义方法。

一个简单的示例(从网站上)从数组中删除元素:

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]

您可以使用ES6。例如,在这种情况下删除值“ 3”:

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');
console.log(newArray);

输出:

["1", "2", "4", "5", "6"]

如果要删除删除位置的新数组,则始终可以删除特定元素并过滤掉该数组。对于未实现filter方法的浏览器,可能需要扩展array对象,但是从长远来看,这很容易,因为您要做的就是:

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]

这是使用JavaScript从数组中删除项目的几种方法

所描述的所有方法都不会改变原始数组,而是创建一个新数组

如果您知道项目的索引

假设您有一个数组,并且要删除position中的项目i

一种方法是使用slice()

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))

console.log(filteredItems)

slice()使用接收到的索引创建一个新数组。我们只需创建一个新数组,即从开始到要删除的索引,然后从我们删除的数组之后的第一个位置到数组的末尾连接另一个数组。

如果你知道价值

在这种情况下,一个不错的选择是使用filter(),它提供了一种更具声明性的方法:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(item => item !== valueToRemove)

console.log(filteredItems)

这将使用ES6箭头功能。您可以使用传统功能来支持较旧的浏览器:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

或者,您可以使用Babel并将ES6代码重新编译回ES5,以使其更易于被旧的浏览器使用,但仍可以在代码中编写现代的JavaScript。

删除多个项目

如果要删除多个项目而不是单个项目怎么办?

让我们找到最简单的解决方案。

按索引

您可以只创建一个函数并删除一系列项目:

const items = ['a', 'b', 'c', 'd', 'e', 'f']

const removeItem = (items, i) =>
  items.slice(0, i-1).concat(items.slice(i, items.length))

let filteredItems = removeItem(items, 3)
filteredItems = removeItem(filteredItems, 5)
//["a", "b", "c", "d"]

console.log(filteredItems)

按价值

您可以在回调函数中搜索包含项:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter(item => !valuesToRemove.includes(item))
// ["a", "b", "e", "f"]

console.log(filteredItems)

避免改变原始数组

splice()(不要与混淆slice())会使原始数组变异,因此应避免使用。

(最初发布在我的网站https://flaviocopes.com/how-to-remove-item-from-array/上

查看此代码。它适用于所有主流浏览器

remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

调用此功能

remove_item(array,value);

ES6且无突变:(2016年10月)

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)

您可以使用lodash _.pull(变异数组),_。pullAt(变异数组)或_.without(不变异数组),

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']

从数组中删除特定的元素/字符串可以用一种方法完成:

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

哪里:

theArray:要从中删除特定内容的数组

stringToRemoveFromArray:要删除的字符串,1是要删除的元素数量。

注意:如果“ stringToRemoveFromArray”不在数组中,则将删除数组的最后一个元素。

在删除元素之前,先检查该元素是否存在于数组中始终是一个好习惯。

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

如果您可以在客户端计算机上访问较新的Ecmascript版本(警告,在较旧的工作站上可能无法使用):

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');

其中“ 3”是要从数组中删除的值。该数组将变为:['1','2','4','5','6']

好的,例如,您具有以下数组:

var num = [1, 2, 3, 4, 5];

我们要删除数字4。您可以简单地使用以下代码:

num.splice(num.indexOf(4), 1); // num will be [1, 2, 3, 5];

如果要重用此函数,请编写一个可重用的函数,该函数将附加到本数组函数,如下所示:

Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1)
      return;
  this.splice(i, 1); // num.remove(5) === [1, 2, 3];
}

但是,如果有下面的数组而不是数组中有[5]个,那又如何呢?

var num = [5, 6, 5, 4, 5, 1, 5];

我们需要一个循环来检查所有这些,但是更简单,更有效的方法是使用内置的JavaScript函数,因此我们编写了一个使用如下过滤器的函数:

const _removeValue = (arr, x) => arr.filter(n => n!==x);
//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]

此外,还有第三方库(如Lodash或Underscore)可以帮助您完成此任务。有关更多信息,请查看lodash _.pull,_。pullAt或_.without。

性能

今天(2019-12-09)我针对选定的解决方案在macOS v10.13.6(High Sierra)上进行了性能测试。我显示了delete(A),但是我没有将其与其他方法进行比较,因为它在数组中留下了空白。

结论

  • 最快的解决方案是array.splice(C)(对于第二次使用小型阵列的Safari除外)
  • 对于大型数组,array.slice+splice(H)是Firefox和Safari最快的不变解决方案;Array.from(B)在Chrome中最快
  • 可变解决方案通常比不可变解决方案快1.5到6倍
  • 对于Safari上的小表,令人惊讶的是,可变解决方案(C)比不可变解决方案(G)慢

细节

在测试中,我以不同的方式从数组中删除了中间元素。A,C的解决方案是原地。B,d,E,F,G,H的解决方案是不可变的。

包含10个元素的数组的结果

在此处输入图片说明

在Chrome中,array.splice(C)是最快的就地解决方案。array.filter(d)是最快的不可变的溶液。最慢的是array.slice(F)。您可以在此处在机器上执行测试

包含1.000.000元素的数组的结果

在此处输入图片说明

在Chrome中,array.splice(C)是最快的就地解决方案(delete(C)相似得很快-但它在阵列中留下了一个空插槽(因此它不执行“完全删除”))。array.slice-splice(H)是最快的不可变的溶液。最慢的是array.filter(D和E)。您可以在此处在机器上执行测试

浏览器比较:Chrome v78.0.0,Safari v13.0.4和Firefox v71.0.0

在此处输入图片说明

我刚接触JavaScript,需要此功能。我只是这样写:

function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

然后,当我想使用它时:

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

输出-如预期。[“ item1”,“ item1”]

您可能与我有不同的需求,因此您可以轻松地对其进行修改以适合他们。我希望这可以帮助别人。

我想根据ECMAScript 6回答假设您有一个如下数组:

let arr = [1,2,3,4];

如果要删除像这样的特殊索引2,请编写以下代码:

arr.splice(2, 1); //=> arr became [1,2,4]

但是,如果您要删除特殊项目,例如,3并且不知道其索引,请执行以下操作:

arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

提示:请使用箭头函数进行过滤器回调,除非您得到一个空数组。

如果数组中有复杂的对象,可以使用过滤器吗?在$ .inArray或array.splice不那么容易使用的情况下。特别是如果对象在数组中可能很浅。

例如,如果您有一个带有Id字段的对象,并且希望将该对象从数组中删除:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});

更新:仅当您不能使用ECMAScript 2015(以前称为ES6)时,才建议使用此方法。如果可以使用它,这里的其他答案将提供更整洁的实现。


这里的要点将解决您的问题,还将删除所有出现的参数,而不仅仅是1(或指定值)。

Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

    for(var i = 0; i < this.length; i++){

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

用法:

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]

您绝对不应更改数组。因为这与功能编程模式相反。您可以使用ECMAScript 6方法创建一个新数组,而无需引用要更改数据的数组filter

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

假设您5要从数组中删除,只需执行以下操作即可:

myArray = myArray.filter(value => value !== 5);

这将为您提供一个没有要删除的值的新数组。因此结果将是:

 [1, 2, 3, 4, 6]; // 5 has been removed from this array

为了进一步理解,您可以阅读Array.filter上的MDN文档

一种更现代的ECMAScript 2015(以前称为Harmony或ES 6)方法。鉴于:

const items = [1, 2, 3, 4];
const index = 2;

然后:

items.filter((x, i) => i !== index);

屈服:

[1, 2, 4]

您可以使用Babelpolyfill服务来确保跨浏览器都很好地支持此功能。

ES10更新

这篇文章总结了自ECMAScript 2019(ES10)起从数组中删除元素的常用方法。

1.一般情况

1.1。使用值按值删除数组元素.splice()

| 就地:是|

|
删除重复项:是(循环),否(indexOf)|

|
按值/索引:按索引|

如果知道要从数组中删除的值,则可以使用splice方法。首先,您必须确定目标项目的索引。然后,您将索引用作开始元素,并仅删除一个元素。

// With a 'for' loop
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for( let i = 0; i < arr.length; i++){
  if ( arr[i] === 5) {
    arr.splice(i, 1);
  }
} // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

// With the .indexOf() method
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf(5);
arr.splice(i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

1.2。使用.filter()方法删除数组元素

| 就地:否|

|
删除重复项:是|

|
按值/索引:按值|

通过提供过滤功能,可以从数组中过滤出特定元素然后为数组中的每个元素调用此函数。

const value = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter(item => item !== value)
console.log(arr)
// [ 1, 2, 4, 5 ]

1.3。通过扩展删除数组元素Array.prototype

| 就地:是/否(取决于实现)|

|
删除重复项:是/否(取决于实现)|

|
按值/索引:按索引/按值(取决于实现)|

Array的原型可以使用其他方法扩展。这样,这些方法将可用于创建的数组。

注意:从JavaScript的标准库(如Array)扩展对象的原型被认为是一种反模式。

// In-place, removes all, by value implementation
Array.prototype.remove = function(item) {
    for (let i = 0; i < this.length; i++) {
        if (this[i] === item) {
            this.splice(i, 1);
        }
    }
}
const arr1 = [1,2,3,1];
arr1.remove(1) // arr1 equals [2,3]

// Non-stationary, removes first, by value implementation
Array.prototype.remove = function(item) {
    const arr = this.slice();
    for (let i = 0; i < this.length; i++) {
        if (arr[i] === item) {
            arr.splice(i, 1);
            return arr;
        }
    }
    return arr;
}
let arr2 = [1,2,3,1];
arr2 = arr2.remove(1) // arr2 equals [2,3,1]

1.4。使用delete运算符删除数组元素

| 就地:是|

|
删除重复项:否|

|
按值/索引:按索引|

使用delete运算符不会影响length属性。它也不会影响后续元素的索引。数组变得稀疏,这是说删除的项目没有被删除而是变成未定义的一种奇特的方式。

const arr = [1, 2, 3, 4, 5, 6];
delete arr[4]; // Delete element with index 4
console.log( arr ); // [1, 2, 3, 4, undefined, 6]

delete运算符旨在从JavaScript对象(这些数组是对象)中删除属性。

1.5。使用Object实用程序(> = ES10)删除数组元素

| 就地:否|

|
删除重复项:是|

|
按值/索引:按值|

引入了ES10 Object.fromEntries,可用于从任何类似Array的对象创建所需的Array,并在此过程中过滤不需要的元素。

const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values(Object.fromEntries(
  Object.entries(object)
  .filter(([ key, val ]) => val !== valueToRemove)
));
console.log(arr); // [1,2,4]

2.特殊情况

2.1删除元素(如果它在数组的末尾)

2.1.1。改变数组length

| 就地:是|

|
删除重复项:否|

|
按值/索引:N / A |

通过将length属性设置为小于当前值的值,可以从数组末尾删除JavaScript Array元素。索引大于或等于新长度的任何元素将被删除。

const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Set length to remove element
console.log( arr ); // [1, 2, 3, 4, 5]

2.1.2。使用.pop()方法

| 就地:是|

|
删除重复项:否|

|
按值/索引:N / A |

pop方法删除数组的最后一个元素,返回该元素,并更新length属性。pop方法修改在其上调用它的数组,这意味着与使用delete不同,最后一个元素被完全删除并且数组长度减小。

const arr = [1, 2, 3, 4, 5, 6];
arr.pop(); // returns 6
console.log( arr ); // [1, 2, 3, 4, 5]

2.2。如果元素在数组的开头,则将其删除

| 就地:是|

|
删除重复项:否|

|
按值/索引:N / A |

.shift()除了删除JavaScript数组的第一个元素而不是最后一个元素之外,方法的工作方式与pop方法非常相似。删除元素后,其余元素将向下移动。

const arr = [1, 2, 3, 4];
arr.shift(); // returns 1
console.log( arr ); // [2, 3, 4]

2.3。如果元素是数组中的唯一元素,则将其删除

| 就地:是|

|
删除重复项:N / A |

|
按值/索引:N / A |

最快的技术是将数组变量设置为空数组。

let arr = [1];
arr = []; //empty array

通过将长度设置为0,可以使用2.1.1中的替代技术。

如果该元素存在多个实例,则可以执行向后循环以确保不破坏索引。

var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

/* Important code */
for (var i = myArray.length - 1; i >= 0; i--) {
  if (myArray[i] == myElement) myArray.splice(i, 1);
}
console.log(myArray);

现场演示

您的数组中有1到9,并且要删除5。使用以下代码:

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);

如果要多个值。范例:-1,7,8

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 1,7 and 8 removed", newNumberArray);

如果要删除数组中的数组值。范例:[3,4,5]

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

包括受支持的浏览器是link

本文地址:http://javascript.askforanswer.com/ruhecongshuzuzhongshanchutedingxiangmu.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

下一篇:

评论已关闭!