it-swarm.cn

如何从JavaScript中删除数组中的特定元素?

我有一个Numbers数组,我正在使用.Push()方法向它添加元素。

有没有一种简单的方法从数组中删除特定元素?等同于array.remove(number);之类的东西。

我必须使用 core JavaScript - no frameworks是允许的。

7085
Walker

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

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

var array = [2, 5, 9];
console.log(array)
var index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}
// array = [2, 9]
console.log(array);

splice的第二个参数是要删除的元素数。请注意,splice会修改数组并返回一个包含已删除元素的新数组。

9908
Tom Wadley

我不知道你是如何期待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];
1011
Peter Olson

编辑于2016年10月

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

删除项目(ECMA-262 Edition 5 code aka oldstyle JS)

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 ]

删除项目(ES2015代码)

let value = 3

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

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

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

_ important _ ES2015“()=> {}”IE中根本不支持箭头函数语法,Chrome版本为45版本,Firefox版本为22版本,Safari版本为10版本。要在旧浏览器中使用ES2015语法,您可以使用 BabelJS


删除多个项目(ES2016代码)

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

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 ]

_ important _ “array.includes(...)”功能在IE中根本不支持,Chrome在47版本之前,Firefox之前是43版本,Safari之前是9版本和Edge在14版之前所以 这里是来自Mozilla的polyfill

删除多个项目(尖端实验性JavaScript ES2018?)

// 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中自己试试:)

参考

831
Ujeenator

取决于你是否想留空。

如果你想要一个空插槽,删除就可以了:

delete array[ index ];

如果不这样做,你应该使用 splice 方法:

array.splice( index, 1 );

如果你需要该项的值,你可以只存储返回的数组的元素:

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

如果你想按某种顺序进行,你可以使用array.pop()作为最后一个,或array.shift()作为第一个(并且都返回项目的值)。

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

383
xavierm02

一位朋友在 Internet Explorer 8 中遇到问题,并向我展示了他的所作所为。我告诉他这是错的,他告诉我他在这里得到了答案。当前的最佳答案不适用于所有浏览器(例如Internet Explorer 8),它只会删除第一次出现的项目。

从阵列中删除所有实例

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

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

251
Ben Lesh

有两种主要方法:

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

  2. 删除 delete anArray[index];

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

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

使用删除后,您还可能会在索引号中出现漏洞,例如:你可能最终得到索引1,3,4,8,9,11和使用删除之前的长度。 在这种情况下,所有索引的for循环都会崩溃,因为索引不再是顺序的。

如果由于某种原因被迫使用delete,那么当需要循环遍历数组时,应该使用 for each loops。事实上,如果可能的话,总是避免使用索引for循环。这样,代码将更加健壮,并且不易出现索引问题。

142
Sasa
Array.prototype.remByVal = 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].remByVal(3);

Array.prototype.remByVal = 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.remByVal('hello')

console.log(rooms)

118
Zirak

无需使用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);
    }
  }
}

nodejs上运行时间为1000个元素(平均超过10000次运行)的数组:

indexofmove慢约10倍。即使通过在splice中删除对indexOf的调用来改进它,它也比move更糟糕。 

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
87
slosd

太老了回复,但可能通过提供谓词而不是值来帮助某人。

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

用法

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

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的原始实现没有这个问题。

56
Roger

Underscore.js 可用于解决多个浏览器的问题。它使用内置浏览器方法(如果存在)。如果它们不存在,就像旧的Internet Explorer版本一样,它使用自己的自定义方法。

从数组中删除元素的简单示例(来自网站):

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

您可以使用 filter method轻松完成:

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

这将从数组中删除所有元素,并且比slice和indexOf的组合更快地工作

53
Salvador Dali

如果要删除删除位置的新数组,可以始终删除特定元素并过滤掉数组。它可能需要扩展 数组对象 对于没有实现过滤方法的浏览器,但从长远来看它更容易,因为你所做的就是:

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]

42
Loupax

您可以使用ES6。 

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

输出: 

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

看看这段代码。它适用于每个 主要浏览器

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);
35
Ekramul Hoque

你可以使用lodash _.pull (mutate array), _.pullAt (mutate array)或 _.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']
33
Chun Yang

好的, 例如你有下面的数组:

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

我们想删除4号,你可以简单地做下面的代码:

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

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

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] s,那该怎么办?

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。

32
Alireza

我是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”]

您可能有不同的需求,因此您可以轻松修改它以适应它们。我希望这可以帮助别人。

27
sofiax

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

const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

然后 : 

removeByIndex([33,22,11,44],1) //=> [33,11,44]
24
Abdennour TOUMI

更新: 仅当您不能使用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]
22
zykadelic

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

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

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

以下是使用JavaScript从数组中删除项目的几种方法)。

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

如果您知道项目的索引

假设您有一个数组,并且想要删除i位置的项目。

一种方法是使用slice()

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i-1).concat(items.slice(i, 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/

20
Flavio Copes

你永远不应该在你的数组中改变你的数组。因为这是针对功能编程模式的。您可以做的是创建一个新数组,而不引用要使用es6方法更改数据的数组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文档 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

19
Adeel Imran

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

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

然后:

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

产量: 

[1, 2, 4]

你可以使用 Babelpolyfill service 来确保浏览器能够很好地支持它。

18
bjfletcher

我知道已有很多答案,但其中许多似乎使问题复杂化。这是一种删除键的所有实例的简单递归方法 - 调用self直到找不到索引。是的,它仅适用于具有indexOf的浏览器,但它很简单,并且可以轻松填充。

独立功能

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

原型方法

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}
16
wharding28

我有另一个很好的解决方案从数组中删除:

var words = ['spray', 'limit', 'Elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(Word => Word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

15
Aram Grigoryan

如果元素有多个实例,则可以执行向后循环以确保不会搞砸索引。

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

现场演示

15
Jeff Noel

基于所有主要正确的答案并考虑到建议的最佳实践(特别是不直接使用Array.prototype),我想出了以下代码:

function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

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

  return arrCopy;
}

回顾上述功能,尽管它工作正常,但我意识到可能会有一些性能提升。使用ES6而不是ES5也是一种更好的方法。为此,这是改进的代码:

const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.Push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

如何使用:

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

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)

我目前正在撰写一篇博文,其中我对Array的几个解决方案进行了基准测试,没有出现问题,并比较了运行所需的时间。完成该帖后,我将使用链接更新此答案。只是为了让你知道,我已经将上面的内容与lodash进行了比较,如果浏览器支持Map,它就会超过lodash!请注意,我没有使用Array.prototype.indexOfArray.prototype.includes将exlcudeValues包装在MapObject中使查询速度更快!

15
Ardi

你有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);


如果你想要多个值ex: - 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, 5 removed", newNumberArray);


如果要删除数组ex中的数组值: - [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);

包括支持的浏览器是 链接

14
Thilina Sampath
  Array.prototype.removeItem = function(a) {
            for (i = 0; i < this.length; i++) {
                if (this[i] == a) {
                    for (i2 = i; i2 < this.length - 1; i2++) {
                        this[i2] = this[i2 + 1];
                    }
                    this.length = this.length - 1
                    return;
                }
            }
        }

    var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
    recentMovies.removeItem('Superman');
13
Don Vincent Preziosi

按索引删除

返回没有索引元素的数组副本的函数。

/**
* removeByIndex
* @param {Array} array
* @param {Number} index
*/
function removeByIndex(array, index){
    return array.filter(function(elem, _index){
        return index != _index;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByIndex(l, 1));

$> [ 1, 4, 5, 6, 7 ]

按值删除

返回没有Value的数组副本的函数。

/**
* removeByValue
* @param {Array} array
* @param {Number} value
*/
function removeByValue(array, value){
    return array.filter(function(elem, _index){
        return value != elem;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByValue(l, 5));

$> [ 1, 3, 4, 6, 7]
13
nsantana

我想根据ES6回答。假设你有一个如下数组:

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]

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

11
AmerllicA

创建新数组:

var my_array = new Array();

向此数组添加元素:

my_array.Push("element1");

函数indexOf(返回索引或未找到时为-1):

var indexOf = function(needle) 
{
    if(typeof Array.prototype.indexOf === 'function') // newer browsers
    {
        indexOf = Array.prototype.indexOf;
    } 
    else // older browsers
    {
        indexOf = function(needle) 
        {
            var index = -1;

            for(var i = 0; i < this.length; i++) 
            {
                if(this[i] === needle) 
                {
                    index = i;
                    break;
                }
            }
            return index;
        };
    }

    return indexOf.call(this, needle);
};

检查此元素的索引(使用firefox和IE8 +测试):

var index = indexOf.call(my_array, "element1");

从数组中删除位于索引处的1个元素

my_array.splice(index, 1);
11
Enrico

我还遇到了必须从Array中删除元素的情况。 .indexOf无法在IE*中工作,因此共享我的工作jQuery.inArray()解决方案。

var index = jQuery.inArray(val,arr);
if (index > -1) {
    arr.splice(index, 1);
    //console.log(arr);
}
10
NullPointer

2017-05-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}]

ValuesAreEqual有替代/更快的实现,但这可以完成工作。如果要检查特定字段(例如,某些检索到的UUID与本地UUID),您还可以使用自定义比较器。

另请注意,这是一个功能操作,这意味着它不会改变原始数组。

9
Aidan Hoolachan

我认为很多JavaScript指令都没有经过深思熟虑的函数式编程。 Splice返回已删除的元素,大多数时候您需要减少的数组。这是不好的。

想象一下,你正在做一个递归调用,并且必须传递一个少一项的数组,可能没有当前的索引项。或者想象你正在进行另一个递归调用,并且必须传递一个带有元素的数组。

在这两种情况下,您都可以执行myRecursiveFunction(myArr.Push(c))myRecursiveFunction(myArr.splice(i,1))。第一个白痴实际上将传递数组的长度,第二个白痴将传递已删除的元素作为参数。

所以我实际上做了...为了删除一个数组元素并将结果作为参数传递给一个函数同时我做如下

myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

说到Push更傻......我喜欢,

myRecursiveFunction((myArr.Push(c),myArr))

我相信一个正确的函数式语言,一个方法变异它所调用的对象必须返回对该对象的引用作为结果。

9
Redu

CoffeeScript

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
8
Nigel Sheridan-Smith

使用jQuery InArray:

A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`   

注意:如果找不到元素,inArray将返回-1。

7
Do Hoa Vinh

Vanilla JavaScript(ES5.1) - 就地 edition

浏览器支持: Internet Explorer 9 或更高版本( 详细的浏览器支持

/**
 * Removes all occurences of the item from the array.
 *
 * Modifies the array “in place”, i.e. the array passed as an argument
 * is modified as opposed to creating a new array. Also returns the modified
 * array for your convenience.
 */
function removeInPlace(array, item) {
    var foundIndex, fromIndex;

    // Look for the item (the item can have multiple indices)
    fromIndex = array.length - 1;
    foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item (in place)
        array.splice(foundIndex, 1);

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    }

    // Return the modified array
    return array;
}

Vanilla JavaScript(ES5.1) - immutable edition

浏览器支持:与Vanilla JavaScript in place edition相同

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    var arrayCopy;

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

Vanilla ES6 - immutable edition

浏览器支持:Chrome 46,Edge 12,Firefox 16,Opera 37,Safari 8( 详细的浏览器支持

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    // Copy the array
    array = [...array];

    // Look for the item (the item can have multiple indices)
    let fromIndex = array.length - 1;
    let foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item by generating a new array without it
        array = [
            ...array.slice(0, foundIndex),
            ...array.slice(foundIndex + 1),
        ];

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex)
    }

    // Return the new array
    return array;
}
6
Lars Gyrup Brink Nielsen

删除索引i处的元素,而不改变原始数组:

/**
* removeElement
* @param {Array} array
* @param {Number} index
*/
function removeElement(array, index) {
   return Array.from(array).splice(index, 1);
}

// Another way is
function removeElement(array, index) {
   return array.slice(0).splice(index, 1);
}
6
alejandro

我喜欢这个版本的splice,使用$.inArray删除元素的值:

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});
6
mboeckle

如果array中存在splice- item和array,则可以迭代它们。

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}
6
yckart

我刚刚通过Array.prototypeObject.defineProperty上创建了一个polyfill来删除数组中的所需元素,而不会在稍后通过for .. in ..进行迭代时导致错误

if (!Array.prototype.remove) {
  // Object.definedProperty is used here to avoid problems when iterating with "for .. in .." in Arrays
  // https://stackoverflow.com/questions/948358/adding-custom-functions-into-array-prototype
  Object.defineProperty(Array.prototype, 'remove', {
    value: function () {
      if (this == null) {
        throw new TypeError('Array.prototype.remove called on null or undefined')
      }

      for (var i = 0; i < arguments.length; i++) {
        if (typeof arguments[i] === 'object') {
          if (Object.keys(arguments[i]).length > 1) {
            throw new Error('This method does not support more than one key:value pair per object on the arguments')
          }
          var keyToCompare = Object.keys(arguments[i])[0]

          for (var j = 0; j < this.length; j++) {
            if (this[j][keyToCompare] === arguments[i][keyToCompare]) {
              this.splice(j, 1)
              break
            }
          }
        } else {
          var index = this.indexOf(arguments[i])
          if (index !== -1) {
            this.splice(index, 1)
          }
        }
      }
      return this
    }
  })
} else {
  var errorMessage = 'DANGER ALERT! Array.prototype.remove has already been defined on this browser. '
  errorMessage += 'This may lead to unwanted results when remove() is executed.'
  console.log(errorMessage)
}

删除整数值

var a = [1, 2, 3]
a.remove(2)
a // Output => [1, 3]

删除字符串值

var a = ['a', 'ab', 'abc']
a.remove('abc')
a // Output => ['a', 'ab']

删除布尔值

var a = [true, false, true]
a.remove(false)
a // Output => [true, true]

也可以通过Array.prototype.remove方法删除数组中的对象。您只需要指定要删除的Objectkey => value

删除对象值

var a = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 3, b: 2}]
a.remove({a: 1})
a // Output => [{a: 2, b: 2}, {a: 3, b: 2}]
5
Victor

我对基础JavaScript数组做了一个相当有效的扩展:

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};
5
Shawn Deprey

通过我的解决方案,您可以使用纯JavaScript删除数组中的一个或多个项目。不需要另一个JavaScript库。

var myArray = [1,2,3,4,5]; // First array

var removeItem = function(array,value) {  // My clear function
    if(Array.isArray(value)) {  // For multi remove
        for(var i = array.length - 1; i >= 0; i--) {
            for(var j = value.length - 1; j >= 0; j--) {
                if(array[i] === value[j]) {
                    array.splice(i, 1);
                };
            }
        }
    }
    else { // For single remove
        for(var i = array.length - 1; i >= 0; i--) {
            if(array[i] === value) {
                array.splice(i, 1);
            }
        }
    }
}

removeItem(myArray,[1,4]); // myArray will be [2,3,5]
5
Kamuran Sönecek

使用松散比较删除一个值,而不改变原始数组ES6

/**
 * Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
 * 
 * @param {Array} array Array to remove value from
 * @param {*} value Value to remove
 * @returns {Array} Array with `value` removed
 */
export function arrayRemove(array, value) {
    for(let i=0; i<array.length; ++i) {
        if(array[i] == value) {
            let copy = [...array];
            copy.splice(i, 1);
            return copy;
        }
    }
    return array;
}
4
mpen

还有另外一个答案,对我来说越简单就越好,而且正如我们在2018年(2019年附近)我给你(近)一个班轮来回答原来的问题:

Array.prototype.remove = function (value) { 
    return this.filter(f => f != value) 
}

有用的是你可以在咖喱表达中使用它,例如:

[1,2,3].remove(2).sort()

4
Sebastien H.

虽然上面的大部分答案都回答了这个问题,但尚不清楚为什么没有使用slice()方法。是的,filter()符合不变性标准,但如何做以下更短的等价物:

const myArray = [1,2,3,4];

现在让我们说我们应该从数组中删除第二个元素,我们可以简单地做:[。_____。] const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]

由于其简单且不可改变的特性,今天在社区中强烈鼓励这种从数组中删除元素的方式。通常,应避免引起突变的方法。例如,建议您使用Push()concat()替换为splice()slice() 

4
Stelios Voskos

使用 jQuery.grep()

var y = [1, 2, 3, 9, 4]
var removeItem = 9;

y = jQuery.grep(y, function(value) {
  return value != removeItem;
});
console.log(y)
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>

4
Mahendra Kulkarni

从数组中删除一个特定的元素/字符串可以在一个单独的衬里中完成:[。_____。]我仍然认为这是你可以为这类问题得到的最优雅的一个衬里: 

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

'theArray'是你要删除特定内容的数组。

4
Max Alexander Hanna

发布我的代码,删除数组元素,并减少数组长度。

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();
}
3
hailong

这里有很多很棒的答案,但对我来说,最简单的方法是不完全从数组中删除我的元素,而只是将它的值设置为null。这适用于我所拥有的大多数情况,并且是一个很好的解决方案,因为我稍后将使用该变量并且不希望它消失,现在只是空的。此外,这种方法完全兼容跨浏览器。

array.key = null;
3
rncrtr

删除上次出现或所有出现次数,还是第一次出现? 

var array = [2, 5, 9, 5];

// Remove last occurrence (or all occurrences)
for (var i = array.length; i--;) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Remove this line to remove all occurrences
  }
}

要么

var array = [2, 5, 9, 5];

// Remove first occurrence
for (var i = 0; array.length; i++) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Do not remove this line
  }
}
3
MEC

对于任何想要复制一个方法的人来说,这个方法将返回一个删除了重复数字或字符串的新数组,这已经从现有答案中汇总了:

function uniq(array) {
  var len = array.length;
  var dupFree = [];
  var tempObj = {};

  for (var i = 0; i < len; i++) {
    tempObj[array[i]] = 0;
  }

  console.log(tempObj);

  for (var i in tempObj) {
    var element = i;
    if (i.match(/\d/)) {
      element = Number(i);
    }
    dupFree.Push(element);
  }

  return dupFree;
}
3
cjjenkinson

我做了一个功能 

function pop(valuetoremove, myarray) {
var indexofmyvalue = myarray.indexOf(valuetoremove);
myarray.splice(indexofmyvalue, 1);
}

像这样使用。

pop(valuetoremove,myarray);

干杯!

3
Ali Akram

非常天真的实施如下:

Array.prototype.remove = function(data) {
    const dataIdx = this.indexOf(data)
    if(dataIdx >= 0) {
        this.splice(dataIdx ,1);
    }
    return this.length;
}

let a = [1,2,3];
// this will change arr a to [1, 3]
a.remove(2);

我从函数返回数组的长度,以符合其他方法,如Array.prototype.Push()

3
Gaurang Patel

我自己遇到这个问题(在更换数组的情况下是可以接受的)并用一个简单的方法解决了这个问题:

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

此解决方案应与参考和价值项一起使用。这完全取决于您是否需要维护对原始阵列的引用,以确定此解决方案是否适用。 

2
Phil
var array = [2, 5, 9];
array.splice(array.findIndex(x => x==5), 1);

使用Array.findindex,我们可以减少代码行数。

developer.mozilla.org

2
sujithklr93
var index,
    input = [1,2,3],
    indexToRemove = 1;
    integers = [];

for (index in input) {
    if (input.hasOwnProperty(index)) {
        if (index !== indexToRemove) {
            integers.Push(result); 
        }
    }
}
input = integers;

此解决方案将采用一系列输入,并将在输入中搜索要删除的值。这将循环遍历整个输入数组,结果将是已删除特定索引的第二个数组整数。然后将整数数组复制回输入数组。 

2
penguin

您的问题并未表明是否需要订单或不同的值。

如果您不关心订单,并且容器中的值不会超过一次,请使用Set。它会更快,更简洁。 

var aSet = new Set();

aSet.add(1);
aSet.add(2);
aSet.add(3);

aSet.delete(2);
2
Steven Spungin
[2,3,5].filter(i => ![5].includes(i))
2

使用索引和拼接删除值!

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

从上次删除元素 

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];
2
Srikrushna Pal

很遗憾你有一个整数数组,而不是一个对象,其中键是这些整数的字符串等价物。

我已经查看了很多这些答案,据我所知他们似乎都使用“蛮力”。我没有检查过每一个,如果不是这样,请道歉。对于一个小的数组,这很好,但是如果你有000个整数呢?

如果我错了,请纠正我,但是我们不能假设在一个JS对象的key => value映射中,可以假设密钥检索机制是高度设计和优化的吗? (注意,如果一些超级专家告诉我情况并非如此,我建议使用ES6的 地图类 相反,这肯定会是)。

我只是建议,在某些情况下,最好的解决方案可能是将数组转换为对象......问题当然是你可能有重复的整数值。我建议把它们放在桶中作为key => value条目的“值”部分。 (注意,如果您确定没有任何重复的数组元素,这可以更简单:值“与”键相同,只需返回Object.values(...)即可获取修改后的数组)。

所以你可以这样做:

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =   function( acc, val, currIndex ){ 
    // not seen this val before: make bucket... NB although val's typeof is 'number'
    // there is seamless equivalence between the object key (always string)
    // and this variable val 
    ! ( val in acc ) ? acc[ val ] = []: 0;
    // drop another array index in the bucket
    acc[ val ].Push( currIndex );
    return acc; 
}
const myIntsMapObj = arr.reduce( f, {});

console.log( myIntsMapObj );

输出:

对象[<1空插槽>,数组 1 ,数组[2],数组 1 ,数组 1 ,<5 空插槽>,46更多...]

然后很容易删除所有数字55

delete myIntsMapObj[ 55 ]; // again, although keys are strings this works

您不必全部删除它们:索引值按外观顺序推入其存储桶中,因此(例如):

myIntsMapObj[ 55 ].shift(); // and
myIntsMapObj[ 55 ].pop(); 

将分别删除第一个和最后一个匹配项。您可以轻松计算出现频率,通过将一个桶的内容转移到另一个桶等,将所有55s替换为3s等。

...稍微涉及到修改后的int数组:但每个存储桶包含(字符串)键表示的值的索引(在原始数组中)。这些桶值中的每一个也是唯一的:因此您将它们转换为新对象中的键,将“整数字符串键”中的(实际)整数作为值...然后对键进行排序并转到Object.values( ... )

这听起来非常复杂和耗时......但显然一切都取决于具体情况和所需的用法。我的理解是JS的所有版本和上下文只在一个线程中运行,并且线程不会“放开”,因此可能会出现一些使用“暴力”方法的可怕拥塞:由indexOf操作引起的不那么多,但多次重复slice/splice ops。

附录
如果你是 确定 这对你的用例来说太过于工程设计肯定是最简单的“蛮力”方法

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(是的,其他答案都发现Array.prototype.filter...)

2
mike rodent

以下方法将从数组中删除给定值的所有条目,而不创建新数组,并且只有一次迭代,即 superfast 。它适用于古代 Internet Explorer 5.5 浏览器:

function removeFromArray(arr, removeValue) {
  for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
    if (k > 0)
      arr[i - k] = arr[i];

    if (arr[i] === removeValue)
      k++;
  }

  for (; k--;)
    arr.pop();
}

var a = [0, 1, 0, 2, 0, 3];

document.getElementById('code').innerHTML =
  'Initial array [' + a.join(', ') + ']';
//Initial array [0, 1, 0, 2, 0, 3]

removeFromArray(a, 0);

document.getElementById('code').innerHTML +=
  '<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]
<code id="code"></code>

2
Eugene Tiurin

要删除特定元素或后续元素, Array.splice() 方法效果很好。[。_____。] splice()方法通过删除或替换现有元素和/或添加新元素来更改数组的内容。它返回已删除的项目。

语法: array.splice(index,deleteCount,item1,.....,itemX)

这里index是必需的,rest参数是可选的。

例如:

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]

注意: 如果您知道要删除的元素的索引,则可以使用Array.splice() 方法。但我们可能会有更多个案,如下所述 -

  1. 如果你想删除最后一个元素,你可以使用 Array.pop()

  2. 如果你想删除第一个元素,你可以使用 Array.shift()

  3. 如果您只知道元素而不知道元素的位置(或索引),并且想要使用 Array.filter() method删除所有匹配的元素:

    let arr = [1, 2, 1, 3, 4, 1, 5, 1];
    
    let newArr = arr.filter(function(val){
        return val !== 1;
     });
     //newArr => [2, 3, 4, 5]
    

或者使用splice()方法作为 -

let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    for( let i = 0; i < arr.length-1; i++){
       if ( arr[i] === 11) {
         arr.splice(i, 1); 
       }
    }
    console.log(arr);
    // [1, 2, 3, 4, 5, 6]

或者假设我们要从数组arr中删除del

let arr = [1, 2, 3, 4, 5, 6];
let del = 4;
if(arr.indexOf(4) >= 0) {
arr.splice(arr.indexOf(4), 1)
}

OR

let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
    if(arr[i] === del) {
       arr.splice(i, 1);
    }
}
  1. 如果您只知道元素而不知道元素的位置(或索引),并且想要使用splice()方法删除第一个匹配元素:

    let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    
    for( let i = 0; i < arr.length-1; i++){
      if ( arr[i] === 11) {
        arr.splice(i, 1);
        break;
      }
    }
    console.log(arr);
    // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
    
1
Chang

如果您必须支持旧版本的Internet Explorer,我建议使用以下polyfill(注意:这是 not 框架)。它是所有现代阵列方法(JavaScript 1.8.5/ECMAScript 5 Array Extras)的100%向后兼容替代品,适用于Internet Explorer 6 +,Firefox 1.5 +,Chrome,Safari和Opera。

https://github.com/plusdude/array-generics

1
Matt Brock

通常最好只使用过滤功能创建一个新数组。

const array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]

这也提高了可读性。我不是粉丝的粉丝,虽然它知道有时你应该去做。

1
codepleb

使用JavaScript的prototying功能在数组对象上定义一个名为remove()的方法。

使用 splice() 方法来满足您的要求。

请看下面的代码。

Array.prototype.remove = function(item) {
    // index will have -1 if item does not exist
    // else it will have the index of 1st item found in array
    var index = this.indexOf(item); 

    if (index > -1) {
        // splice() method is used to add/remove items(s) in array
        this.splice(index, 1); 
    }

    return index;
}


var arr = [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];

// Printing array
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// Removing 67 (getting its index i.e. 2)
console.log("Removing 67")
var index = arr.remove(67)

if (index > 0){
    console.log("Item 67 found at ", index)
} else {
    console.log("Item 67 does not exist in array")
}

// Printing updated array
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// ............... Output ................................
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
// Removing 67
// Item 67 found at  2
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]

注意: 下面是在 Node.js REPL 上执行的完整示例代码,它描述了Push(),pop(),shift(),unshift()和splice的使用() 方法。

> // Defining an array
undefined
> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
undefined
> // Getting length of array
undefined
> arr.length;
16
> // Adding 1 more item at the end i.e. pushing an item
undefined
> arr.Push(55);
17
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34, 55 ]
> // Popping item from array (i.e. from end)
undefined
> arr.pop()
55
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Remove item from beginning
undefined
> arr.shift()
12
> arr
[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Add item(s) at beginning
undefined
> arr.unshift(67); // Add 67 at begining of the array and return number of items in updated/new array
16
> arr
[ 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.unshift(11, 22); // Adding 2 more items at the beginning of array
18
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> // Define a method on array (temorarily) to remove an item and return the index of removed item; if it is found else return -1
undefined
> Array.prototype.remove = function(item) {
... var index = this.indexOf(item);
... if (index > -1) {
..... this.splice(index, 1); // splice() method is used to add/remove items in array
..... }
... return index;
... }
[Function]
>
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(45);   // Remove 45 (You will get the index of removed item)
3
> arr
[ 11, 22, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(22)    // Remove 22
1
> arr
[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.remove(67)    // Remove 67
1
> arr
[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(89)    // Remove 89
2
> arr
[ 11, 67, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(100);  // 100 doesn't exist, remove() will return -1
-1
>

谢谢。

1
hygull

从数组中删除元素的拼接,过滤和删除

每个数组都有它们的索引,它有助于删除带有索引的特定元素。

splice()方法  

array.splice(index, 1 ); 第一个参数是索引,第二个是你的元素数

想要从该索引中删除。

因此,对于单个元素,我们使用1。 

删除方法

删除数组[索引]

filter()方法

如果要删除在数组中重复的元素,则过滤该数组。

removeAll = array.filter(e => e!= elem);

其中elem是要从数组中删除的元素,数组是您的数组名称

1
ashish

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

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

开始

开始更改数组的索引(使用Origin 0)。如果大于数组的长度,实际的起始索引将设置为数组的长度。如果为负数,将从数组末尾开始那么多元素(使用Origin -1),如果绝对值大于数组的长度,则将设置为0。

deleteCount可选

一个整数,表示要删除的旧数组元素的数量。如果省略deleteCount,或者如果它的值大于array.length - start(即,如果它大于剩下的元素数量)数组,从start开始),然后将删除从开始到数组末尾的所有元素。[。_____。]如果deleteCount为0或负数,则不删除任何元素。在这种情况下,您应该至少指定一个新元素(见下文)。

item1,item2,...可选

要添加到数组的元素,从起始索引开始。如果未指定任何元素,则splice()将仅从数组中删除元素。

如需更多参考,请通过:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

0
ashish

已经有很多答案了,但因为还没有人用一个班轮做过,我想我会展示我的方法。它利用了string.split()函数在创建数组时将删除所有指定字符的事实。这是一个例子: 

var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);

在这个例子中,所有4个都从数组ary中删除。但是,请务必注意,包含字符“ - ”的任何数组都会导致此示例出现问题。简而言之,它会导致连接(“ - ”)函数将您的字符串拼凑不正确。在这种情况下,上述snipet中的所有“ - ”字符串都可以替换为原始数组中不使用的任何字符串。这是另一个例子: 

var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("[email protected]#").split("[email protected]#[email protected]#").join("[email protected]#").split("[email protected]#");
console.log(out);

0
Partial Science

利用减少方法如下:

case a)如果你需要通过索引删除元素:

function remove(arr, index) {
  return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}

case b)如果你需要通过element(int)的值删除元素:

function remove(arr, value) {
  return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}

因此,通过这种方式,我们可以返回一个新的数组(将是一个很酷的功能方式 - 比使用Push或splice更好),并删除了元素。

0
alejoko
Array.prototype.remove = function(x) {
    var y=this.slice(x+1);
    var z=[];
    for(i=0;i<=x-1;i++) {
        z[z.length] = this[i];
    }

    for(i=0;i<y.length;i++){
        z[z.length]=y[i];
    }

    return z;
}
0
user4109793
var arr =[1,2,3,4,5];

arr.splice(0,1)

console.log(arr)

输出[2,3,4,5];

0
Shahriar Ahmad