Javascript 如何从数组中删除特定项？_Javascript_Arrays

Javascript 如何从数组中删除特定项？

javascript arrays

Javascript 如何从数组中删除特定项？,javascript,arrays,Javascript,Arrays,我有一个数字数组，我正在使用.push（）方法向其中添加元素有没有一种简单的方法可以从数组中删除特定的元素我在寻找类似于： array.remove（数字）；我必须使用核心JavaScript。不允许使用框架。Array.prototype.remove\u by\u value=function（val）{ for（var i=0；i-1）{ 阵列拼接（索引1）； } //数组=[2,9] console.log（数组）这取决于您是否想保留一个空白点如果您确实想要一个空插槽： arr

我有一个数字数组，我正在使用

.push（）

方法向其中添加元素

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

我在寻找类似于：

array.remove（数字）；

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

Array.prototype.remove\u by\u value=function（val）{
for（var i=0；i



Array.prototype.remove_by_value=函数（val）{
for（var i=0；iconsole.log（rooms）
我不知道您对数组的期望是什么。有三种可能性我可以想到，你可能会想要
要删除索引i
处的数组元素，请执行以下操作：
阵列拼接（i，1）；

如果要从数组中删除每个值为number
的元素：
for（var i=array.length-1；i>=0；i--）{
if（数组[i]==编号）{
阵列拼接（i，1）；
}
}

如果只想使索引i
处的元素不再存在，但不想更改其他元素的索引：
delete array[i];

找到要使用删除的数组元素的索引
，然后使用删除该索引
splice（）方法通过删除
现有元素和/或添加新元素

const数组=[2,5,9]；
console.log（数组）；
const index=array.indexOf（5）；
如果（索引>-1）{
阵列拼接（索引1）；
}
//数组=[2,9]
console.log（数组）这取决于您是否想保留一个空白点
如果您确实想要一个空插槽：
array[index] = undefined;

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

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

如果您不想要一个空插槽，请执行以下操作：
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
（如果未找到）。
如果要删除删除位置的新数组，可以始终删除特定元素并过滤掉数组。对于未实现过滤方法的浏览器，它可能需要扩展，但从长远来看更容易，因为您只需执行以下操作：
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]
有两种主要方法：
splice（）：anArray.splice（索引，1）

删除：删除数组[索引]

对数组使用delete
时要小心。它适用于删除对象的属性，但不适用于数组。最好对阵列使用拼接

请记住，当您对数组使用delete
时，可能会得到anArray.length
的错误结果。换句话说，delete
将删除元素，但不会更新length属性的值
在使用delete之后，您还可能会在索引编号中出现漏洞，例如，您可能最终会得到索引1、3、4、8、9和11以及使用delete之前的长度。在这种情况下，对于
循环，所有索引的都将崩溃，因为索引不再是连续的
如果由于某种原因而被迫使用delete
，那么在需要循环数组时应该使用循环。事实上，如果可能，请始终避免对
循环使用索引的。这样，代码将更加健壮，不易出现索引问题。
更新：仅当您无法使用ECMAScript 2015（以前称为ES6）时，才建议使用此方法。如果您可以使用它，这里的其他答案提供了更整洁的实现

将解决您的问题，并删除所有出现的参数，而不仅仅是1（或指定的值）
查看此代码。它可以在每个主要浏览器中运行

remove_item=函数（arr，值）{
var b=''；
对于（arr中的b）{
if（arr[b]==值）{
阵列拼接（b，1）；
打破
}
}
返回arr；
};
变量数组=[1,3,5,6,5,9,5,3,55]
var res=移除_项（数组，5）；
console.log（res）
一位朋友在中遇到问题，并向我展示了他的做法。我告诉他这是错误的，他告诉我他在这里得到了答案。当前的顶部答案不能在所有浏览器中使用（例如Internet Explorer 8），它只会删除第一个出现的项目
从数组中删除所有实例
它向后循环数组（因为索引和长度会随着项目的移除而改变），如果找到了项目，就会移除它。它适用于所有浏览器。
如果元素有多个实例，您可以执行反向循环，以确保不会破坏索引

var myElement=“chocolate”；
var myArray=['chocolate'，'poptart'，'poptart'，'poptart'，'chocolate'，'poptart'，'poptart'，'chocolate']；
/*重要代码*/
对于（var i=myArray.length-1；i>=0；i--）{
if（myArray[i]==myElement）myArray.splice（i，1）；
}
log（myArray）John Resig：
最终得到一个8元素数组。不知道为什么，但我确认John最初的实现没有这个问题。
没有必要使用索引
function removeAllInstances(arr, item) {
   for (var i = arr.length; i--;) {
     if (arr[i] === item) arr.splice(i, 1);
   }
}

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

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

myArray.remove(8);

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

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 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 ]

let value = 3

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

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

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

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-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 ]

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

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

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

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

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

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']

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

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

[1, 2, 4]

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

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

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

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

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

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]

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

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

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

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

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

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

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

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

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

var array = ['1','2','3','4','5','6'];
var newArray = array.filter(function(item){ return item !== '3' });