如何使用JavaScript从数组中删除对象？

我有一个JavaScript对象，如下所示：

id="1";
name = "serdar";

我有一个数组，它包含了上面的许多对象。如何从该数组中删除对象，例如：

obj[1].remove();

使用该方法

（至少我假设这就是答案，你说你有一个对象，但你给出的代码只创建了两个变量，没有迹象表明数组是如何创建的）

使用delete关键字

delete obj[1];

编辑： 见： 删除将取消定义偏移量，但不会完全删除条目。就像大卫说的那样，拼接是正确的

delete obj[1];

请注意，这不会更改数组索引。您删除的任何数组成员都将保留为“插槽”，其中包含

未定义的
您可以使用该方法或运算符

var arr = [0,1,2];
delete arr[1];
// [0, undefined, 2]

主要区别在于，使用
delete
操作符删除数组元素时，即使删除了数组的最后一个元素，数组的长度也不会受到影响。另一方面，
splice（）
方法移动所有元素，以使删除的元素所在的位置不留孔

使用
delete
操作符的示例：

var trees = ["redwood", "bay", "cedar", "oak", "maple"];  
delete trees[3];  
if (3 in trees) {  
   // this does not get executed  
}
console.log(trees.length);  //  5
console.log(trees);         //  ["redwood", "bay", "cedar", undefined, "maple"]

使用
splice（）
方法的示例：

var trees = ["redwood", "bay", "cedar", "oak", "maple"];  
trees.splice(3, 1);
console.log(trees.length);  //  4
console.log(trees);         //  ["redwood", "bay", "cedar", "maple"]

井
拼接
工作：

var arr = [{id:1,name:'serdar'}];
arr.splice(0,1);
// []

不要对数组使用
delete
运算符
delete
不会从数组中删除条目，它只会将其替换为
undefined

var arr = [0,1,2];
delete arr[1];
// [0, undefined, 2]

但也许你想要这样的东西

var removeByAttr = function(arr, attr, value){
    var i = arr.length;
    while(i--){
       if( arr[i] 
           && arr[i].hasOwnProperty(attr) 
           && (arguments.length > 2 && arr[i][attr] === value ) ){ 

           arr.splice(i,1);

       }
    }
    return arr;
}

下面只是一个例子

var arr = [{id:1,name:'serdar'}, {id:2,name:'alfalfa'},{id:3,name:'joe'}];
removeByAttr(arr, 'id', 1);   
// [{id:2,name:'alfalfa'}, {id:3,name:'joe'}]

removeByAttr(arr, 'name', 'joe');
// [{id:2,name:'alfalfa'}]

如果它是数组中的最后一项，则可以执行
obj.pop（）
如果您知道对象在数组中的索引，则可以使用splice（），如其他人所述，即：

var removedObject = myArray.splice(index,1);
removedObject = null;

如果不知道索引，则需要在数组中搜索它，即：

for (var n = 0 ; n < myArray.length ; n++) {
    if (myArray[n].name == 'serdar') {
      var removedObject = myArray.splice(n,1);
      removedObject = null;
      break;
    }
}

for（var n=0；n

马塞洛
//K.I.S.S.方法
  //K.I.S.S. method
  //(the setup/comments is/are longer than the code)
  //cards is a two dimensional array object
  //  has an array object with 4 elements at each first dimensional index
  //var cards = new Array()
  //cards[cards.length] = new Array(name, colors, cost, type)
  //Can be constructed with Associated arrays, modify code as needed.
  //my test array has 60 'cards' in it
  //  15 'cards' repeated 4 times each
  //  groups were not sorted prior to execution
  //  (I had 4 groups starting with 'U' before the first 'A')
  //Should work with any dimensionality as long as first
  //index controls sort order

  //sort and remove duplicates
  //Algorithm:
  //  While same name side by side, remove higher entry;
  //  assumes 'cards' with same name have same other data
  //  (otherwise use cards[i-1] === cards[i] to compare array objects).
  //Tested on IE9 and FireFox (multiple version #s from 31 up).
  //Also tested by importing array data from 5MB text file.
  //Quick execution
  cards.sort()
  for (i=1; i<cards.length-1; i++){
    while (cards[i-1][0] == cards[i][0]){
       cards.splice(i,1)
    }
  }

//（设置/注释比代码长）
//卡片是一个二维数组对象
//有一个数组对象，每个第一维索引有4个元素
//var卡=新阵列（）
//卡片[cards.length]=新数组（名称、颜色、成本、类型）
//可以使用关联数组构造，根据需要修改代码。
//我的测试阵列中有60张“卡”
//15张“卡片”每次重复4次
//执行前未对组进行排序
//（在第一个“A”之前，我有4个以“U”开头的组）
//应该与任何维度一起工作，只要第一个维度
//索引控制排序顺序
//排序并删除重复项
//算法：
//同时并排使用相同的名称，删除较高的条目；
//假设具有相同名称的“卡”具有相同的其他数据
//（否则使用卡片[i-1]===卡片[i]来比较阵列对象）。
//在IE9和FireFox上测试（从31岁起有多个版本）。
//还通过从5MB文本文件导入数组数据进行了测试。
//快速执行
卡片分类
对于（i=1；i我经常使用它，因此我创建了一个小原型。只需查找该项目，然后在有匹配项时将其拉出即可

//Prototype to remove object from array, removes first
//matching object only
Array.prototype.remove = function (v) {
    if (this.indexOf(v) != -1) {
        this.splice(this.indexOf(v), 1);
        return true;
    }
    return false;
}

可以称之为：

var arr = [12, 34, 56];
arr.remove(34);

结果将是[12,56]

如果成功删除，则返回布尔值；如果元素不存在，则返回false。
如果您可以访问ES2015函数，并且您正在寻找一种功能更强大的方法，我会选择以下方法：

const people = [
  { id: 1, name: 'serdar' },
  { id: 5, name: 'alex' },
  { id: 300, name: 'brittany' }
];

const idToRemove = 5;

const filteredPeople = people.filter((item) => item.id !== idToRemove);

// [
//   { id: 1, name: 'serdar' },
//   { id: 300, name: 'brittany' }
// [

不过要小心，
filter（）
是非变异的，因此您将获得一个新数组

.

var arr=[{id:1，名称：'serdar'}，{id:2，名称：'alfalfa'}，{id:3，名称：'joe'}]；
var ind=arr.findIndex（函数（元素）{
返回元素。id==2；
})
如果（ind！=-1）{
对边拼接（ind，1）
}
console.log（arr）
var apps=[{id:34，名称：'My App'，另一个：'thing'}，{id:37，名称：'My New App'，另一个：'things'}]

//获取id为37的对象的索引

var removeIndex = apps.map(function(item) { return item.id; }).indexOf(37);

// remove object

apps.splice(removeIndex, 1);

var removeIndex=apps.map（函数（项）{return item.id；}）.indexOf（37）

//删除对象

应用拼接（removeIndex，1）

我们有一个对象数组，我们只想使用id属性删除一个对象

var apps = [
       {id:34,name:'My App',another:'thing'},
       {id:37,name:'My New App',another:'things'
}];

获取id为37的对象的索引

var removeIndex = apps.map(function(item) { return item.id; }).indexOf(37);

// remove object

apps.splice(removeIndex, 1);

最干净、最快捷的方式（ES6）


const应用=[
{id:1，名称：'Jon'}，
{id:2，姓名：'Dave'}，
{id:3，姓名：'Joe'}
]
//删除id为2的项目
const itemToBeRemoved={id:2，名称：'Dave'}
apps.splice（apps.findIndex（a=>a.id===itemToBeRemoved.id），1）
//打印结果
console.log（apps）
关于“
delete
将取消定义偏移量，但不会完全删除”--这并不完全正确，因为
delete
将完全删除元素，如
if（树中的3个）所示
在我的答案中进行测试。唯一的一点是它不会移动其他元素来填充孔，因此长度不会受到影响。因此，如果显示数组，在有孔的位置将得到
未定义的
。。但是，使用
删除
与将元素设置为
未定义的
。这是错误的这里还解释道：@daniel：我表达的不正确，但我的意思是一样的：-）如果可以，我会给你+10分：我知道这句话会在一段时间后出现。。。但是这个功能非常出色，我必须在值得表扬的地方给予表扬！！！谢谢。太好了，正是我需要的，+10冠军。我工作得很好。如果数组有子对象，如何也从子项中查找值？？请帮帮我，这应该是被接受的答案。又好又简单！这是（‘我一直在寻找的’）；我喜欢这个解决方案。这里要添加的一件事是检查索引>-1