另一种使用数组的解决方案。在允许的键上减少方法:

const raw = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const allowed = ['item1', 'item3'];

const filtered = allowed.reduce((obj, key) => { 
  obj[key] = raw[key]; 
  return obj 
}, {})

console.log(filtered);

特别是对于较大的源对象(在本例中为原始对象)，这是有意义的。迭代不会使用源的所有条目执行，而只使用您想要过滤的键，因此更短/更快…

演示在这小提琴…

但我必须说，我也喜欢这个答案中的解决方案使用object。fromentries数组。filter和Array.includes:

const object = object . fromentries ( Object.entries(生)。Filter (([key, value]) => allowed.includes(key)) ）;

演示在这小提琴…

没有什么之前没有说过的，但是把一些答案结合到ES6的一般答案中:

Const raw = { Item1: {key: 'sdfd'， value: 'sdfd'}， Item2: {key: 'sdfd'， value: 'sdfd'}， Item3:{键:'sdfd'，值:'sdfd'} }; const filteredKeys = ['item1'， 'item3']; const filtered = filteredKeys .reduce((obj, key) =>({…Obj， [key]: raw[key]})， {}); console.log(过滤);

这个函数将根据键列表筛选对象，它比前面的答案更有效，因为它不需要使用Array。在调用reduce之前进行筛选。所以它是O(n)而不是O(n +过滤)

function filterObjectByKeys (object, keys) {
  return Object.keys(object).reduce((accum, key) => {
    if (keys.includes(key)) {
      return { ...accum, [key]: object[key] }
    } else {
      return accum
    }
  }, {})
}

如果你有一个允许值的列表，你可以很容易地将它们保留在一个对象中:

Const raw = { Item1: {key: 'sdfd'， value:'sdfd'}， Item2: {key: 'sdfd'， value:'sdfd'}， Item3:{键:'sdfd'，值:'sdfd'} }; Const allowed = ['item1'， 'item3']; const filtered = Object.keys(raw) .filter(key => allowed.includes(key)) .reduce((obj, key) => { Obj [key] = raw[key]; 返回obj; }, {}); console.log(过滤);

这个用途:

对象。键来列出原始(原始数据)中的所有属性 Array.prototype.filter选择允许列表中出现的键，使用 Array.prototype.includes以确保它们存在 reduce构建一个只包含允许属性的新对象。

这将使用允许的属性创建一个浅拷贝(但不会复制属性本身)。

你也可以使用对象扩展操作符来创建一系列对象而不改变它们(感谢rjerue提到了这一点):

Const raw = { Item1: {key: 'sdfd'， value:'sdfd'}， Item2: {key: 'sdfd'， value:'sdfd'}， Item3:{键:'sdfd'，值:'sdfd'} }; Const allowed = ['item1'， 'item3']; const filtered = Object.keys(raw) .filter(key => allowed.includes(key)) .reduce((obj, key) => { 返回{ obj, (例子):生(例子) }; }, {}); console.log(过滤);

出于琐事的目的，如果你想从原始数据中删除不需要的字段(我不建议这样做，因为它涉及一些丑陋的突变)，你可以像这样反转includes检查:

Const raw = { Item1: {key: 'sdfd'， value:'sdfd'}， Item2: {key: 'sdfd'， value:'sdfd'}， Item3:{键:'sdfd'，值:'sdfd'} }; Const allowed = ['item1'， 'item3']; 种(生) .filter(key => !allowed.includes(key)) .forEach(key => delete raw[key]); console.log(生);

我使用这个示例是为了展示一个基于突变的解决方案，但我不建议使用它。

好吧，这一行怎么样

    const raw = {
      item1: { key: 'sdfd', value: 'sdfd' },
      item2: { key: 'sdfd', value: 'sdfd' },
      item3: { key: 'sdfd', value: 'sdfd' }
    };

    const filteredKeys = ['item1', 'item3'];

    const filtered = Object.assign({}, ...filteredKeys.map(key=> ({[key]:raw[key]})));

您可以删除对象上的特定属性

items={
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
}

// Example 1
var key = "item2";
delete items[key]; 

// Example 2
delete items["item2"];

// Example 3
delete items.item2;