Javascript 删除数组中所有对象的属性

我想从数组中的每个对象中删除

bad

属性。有没有比使用

for

循环并从每个对象中删除它更好的方法

var array = [{"bad": "something", "good":"something"},{"bad":"something", "good":"something"},...];

for (var i = 0, len = array.length; i < len; i++) {
  delete array[i].bad;
}

var数组=[{“bad”：“something”，“good”：“something”}，{“bad”：“something”，“good”：“something”}，…]；
对于（变量i=0，len=array.length；i

---

似乎应该有一种方法来使用

原型

，或者其他什么。我不知道。想法？

唯一的其他方式是装饰性的，实际上是循环

例如：

array.forEach(function(v){ delete v.bad });

注:

• 如果你想与IE8兼容，你需要。正如您提到的prototype一样，prototype.js也是

• delete

  是最糟糕的方法之一。使用它通常会破坏应用程序的性能。如果确实要删除某个属性，则无法避免此操作，但通常可以将该属性设置为

  未定义

  ，或者只构建没有该属性的新对象

---

只有当您的对象相似时，才可能使用原型解决方案：

function Cons(g) { this.good = g; }
Cons.prototype.bad = "something common";
var array = [new Cons("something 1"), new Cons("something 2"), …];

但这很简单（而且

O（1）

）：

---

我更喜欢使用map删除属性，然后返回新的数组项

array.map(function(item) { 
    delete item.bad; 
    return item; 
});

如果您使用：

---

使用ES6，您可以解构每个对象以创建一个没有命名属性的新对象：

const newArray = array.map(({dropAttr1, dropAttr2, ...keepAttrs}) => keepAttrs)

var数组=[{“bad”：“something”，“good”：“something”}，{“bad”：“something”，“good”：“something”}]；
var results=array.map（函数（项）{
返回{good:item[“good”]}
});
log（JSON.stringify（results））

我建议使用

对象。在
forEach（）
循环中分配
，以便复制对象并且不影响对象的原始数组

var res = [];
array.forEach(function(item) { 
    var tempItem = Object.assign({}, item);
    delete tempItem.bad; 
    res.push(tempItem);
});
console.log(res);

在我看来，这是最简单的变体

array.map(({good}) => ({good}))

这个问题现在有点老了，但我想提供一个替代解决方案，它不改变源数据，只需要很少的手动操作：

function mapOut(sourceObject, removeKeys = []) {
  const sourceKeys = Object.keys(sourceObject);
  const returnKeys = sourceKeys.filter(k => !removeKeys.includes(k));
  let returnObject = {};
  returnKeys.forEach(k => {
    returnObject[k] = sourceObject[k];
  });
  return returnObject;
}

const array = [
  {"bad": "something", "good":"something"},
  {"bad":"something", "good":"something"},
];

const newArray = array.map(obj => mapOut(obj, [ "bad", ]));

它仍然有点不够完美，但是保持了一定程度的不变性，并且可以灵活地命名要删除的多个属性。（欢迎建议）
我尝试过在不删除Vue.js中的coulmns的情况下装入新对象

let data=this.selectedContactsDto[]

//selectedContactsDto[]=对象以及在我的项目中创建的数组对象列表

控制台日志（数据）；
让newDataObj=data.map（（{groupsList，customFields，firstname，…item}）=>item）；
log（“newDataObj”，newDataObj）

要从对象数组中删除某些键值对，请使用Postgres SQL作为数据库，如以下示例所示：

这是user函数返回user details对象，我们必须从行中删除“api\u secret”密钥：

    function getCurrentUser(req, res, next) { // user function
    var userId = res.locals.userId;
    console.log(userId)
    db.runSQLWithParams("select * from users where id = $1", [userId], function(err, rows) {
      if(err){
        console.log(err)
      }
      var responseObject = {
        _embedded: rows,
      }
      responseObject._embedded[0].api_secret = undefined
      // console.log(api);
      // console.log(responseObject);
      res.json(responseObject);
    }); 
}

上面的函数以JSON响应的形式返回下面的对象

 {
    "_embedded": [
        {
            "id": "0123abd-345gfhgjf-dajd4456kkdj",
            "secret_key: "secret",
            "email": "abcd@email.com",
            "created": "2020-08-18T00:13:16.077Z"
        }
    ]
}

添加此行
responseObject.\u embedded[0].api\u secret=undefined
后，它给出以下结果作为JSON响应：

{
        "_embedded": [
            {
                "id": "0123abd-345gfhgjf-dajd4456kkdj",
                "email": "abcd@email.com",
                "created": "2020-08-18T00:13:16.077Z"
            }
        ]
    }

您可以按照以下步骤操作，更具可读性，而不是因为找不到键而提高期望值：

data.map((datum) => {
  return {
    'id':datum.id,
    'title':datum.login
  }
});

ES6中的最短路径：

array.forEach(e => {delete e.someKey});

那里有很多图书馆。这完全取决于你的数据结构是多么复杂（例如考虑深度嵌套的键）

我们喜欢它，因为它也适用于深度嵌套的层次结构（为api字段参数构建）。下面是一个简单的代码示例


//const objectFields=require（'object-fields'）；
常量数组=[{bad:'something'，good:'something'}，{bad:'something'，good:'something'}]；
const retain=objectFields.container（['good']）；
保留（数组）；
console.log（数组）；
//=>[{good:'something'}，{good:'something'}]
。作为控制台包装{最大高度：100%！重要；顶部：0}
ES6：

这对我很有效

export function removePropertiesFromArrayOfObjects(arr = [], properties = []) {
return arr.map(i => {
    const newItem = {}
    Object.keys(i).map(key => {
        if (properties.includes(key)) { newItem[key] = i[key] }
    })
    return newItem
})

}
没关系，其他方法不能得到任何小于线性O（n）的结果。无论您使用什么，都需要访问所有数组元素Prototype？那会有什么帮助？或者所有这些对象都是同一个构造函数的实例，并且对于
bad
共享一个公共值？@Bergi我想知道它们是指prototypeJS还是
数组
原型，我不确定在循环之前是否应该将Array.length存储在变量中。我相信你会发现，如果你对其进行分析，那就不值得这么痛苦了。@ZackArgyle是的，在一般情况下，没有比循环更快的了。如果允许循环为“假”-也有一行：P
for（var I=0；I
@Esailija取决于。我喜欢使用
forEach
，因为我发现代码更具表现力（而且因为我很久以前就不再担心IE了）。它们都没有以完全不同的方式表达“删除此数组中所有对象的坏属性”
forEach
本身是泛型的，语义上没有意义，就像
for
循环一样。@Esailija我同意。这就是为什么我认为它是“化妆品”。我的回答不清楚吗？很不幸。我将坚持使用for循环，它通常比forEach更快。真的…谁在乎IE8。感谢您的帮助。请注意，在这种特殊情况下，显式
return
语句将不会是必需的
array.forEach（v=>delete v.bad）
您能解释一下您的解决方案吗？Map是JavaScript ES6中的一种新数据结构。附加的链接可能会对您有所帮助。如果你的物品中有很多道具，这个解决方案就不好了。是的！试图提供不同的方法。在您的评论中，您将未使用的数据结构
Map
，与
Array.prototype.Map
，正在使用的数组方法相混淆。应用于初始问题，它可能是
const newArray=Array.Map（{bad，{item}=>item）
这是非常推荐的，因为它不会修改原始数组（不可变操作），这应该是可以接受的答案，因为它返回一个新数组，在
array.forEach(e => {delete e.someKey});

const newArray = array.map(({keepAttr1, keepAttr2}) => ({keepAttr1, newPropName: keepAttr2}))

export function removePropertiesFromArrayOfObjects(arr = [], properties = []) {
return arr.map(i => {
    const newItem = {}
    Object.keys(i).map(key => {
        if (properties.includes(key)) { newItem[key] = i[key] }
    })
    return newItem
})