您还可以执行类似的操作，对条目进行筛选，以找到提供的键并返回值

   let func = function(items){
      let val
      Object.entries(this.items).map(k => {
        if(k[0]===kind){
         val = k[1]
        }
      })
      return val
   }

我的观点是:

function objFilter(obj, filter, nonstrict){
  r = {}
  if (!filter) return {}
  if (typeof filter == 'string') return {[filter]: obj[filter]}
  for (p in obj) {
    if (typeof filter == 'object' &&  nonstrict && obj[p] ==  filter[p]) r[p] = obj[p]
    else if (typeof filter == 'object' && !nonstrict && obj[p] === filter[p]) r[p] = obj[p]
    else if (typeof filter == 'function'){ if (filter(obj[p],p,obj)) r[p] = obj[p]}
    else if (filter.length && filter.includes(p)) r[p] = obj[p]
  }
  return r
}

测试用例:

obj = {a:1, b:2, c:3}

objFilter(obj, 'a') // returns: {a: 1}
objFilter(obj, ['a','b']) // returns: {a: 1, b: 2}
objFilter(obj, {a:1}) // returns: {a: 1}
objFilter(obj, {'a':'1'}, true) // returns: {a: 1}
objFilter(obj, (v,k,o) => v%2===1) // returns: {a: 1, c: 3}

https://gist.github.com/bernardoadc/872d5a174108823159d845cc5baba337

如何:

function filterObj(keys, obj) {
  const newObj = {};
  for (let key in obj) {
    if (keys.includes(key)) {
      newObj[key] = obj[key];
    }
  }
  return newObj;
}

还是……

function filterObj(keys, obj) {
  const newObj = {};
  Object.keys(obj).forEach(key => {
    if (keys.includes(key)) {
      newObj[key] = obj[key];
    }
  });
  return newObj;
}

首先，扩展Object.prototype被认为是不好的做法。相反，将你的特性作为独立的函数提供，或者如果你真的想扩展一个全局函数，将它作为Object上的实用函数提供，就像已经有Object一样。钥匙,对象。分配对象。是,等。

我在这里提供几个解决方案:

使用reduce和object .key 如(1)，结合Object.assign 使用map和spread语法代替reduce 使用对象。entry和Object.fromEntries

1. 使用reduce和object .key

用reduce和Object。键来实现所需的过滤器(使用ES6箭头语法):

对象。Filter = (obj, predicate) => 种(obj) .filter(key => predicate(obj[key])) .reduce ((res,关键)= > (res(例子)= obj(例子),res), {}); //示例: Var分数= { 约翰:2，萨拉:3，珍妮特:1 }; var filtered =对象。Filter (scores, score => score > 1); console.log(过滤);

注意，在上面的代码中，谓词必须是一个包含条件(与OP使用的排除条件相反)，以便与Array.prototype.filter的工作方式一致。

2. 如(1)，结合Object.assign

在上面的解决方案中，逗号操作符用于reduce部分以返回变化后的res对象。这当然可以写成两个语句而不是一个表达式，但后者更简洁。如果不使用逗号操作符，可以使用Object。而是赋值，这将返回突变的对象:

对象。Filter = (obj, predicate) => 种(obj) .filter(key => predicate(obj[key])) .reduce((res, key) =>对象。赋值(res， {[key]: obj[key]})， {}); //示例: Var分数= { 约翰:2，萨拉:3，珍妮特:1 }; var filtered =对象。Filter (scores, score => score > 1); console.log(过滤);

3.使用map和spread语法代替reduce

这里我们移动对象。将赋值调用移出循环，因此只执行一次，并将各个键作为单独的参数传递给它(使用spread语法):

对象。Filter = (obj, predicate) => Object.assign(…种(obj) .filter(key => predicate(obj[key])) .map(key => ({[key]: obj[key]}))); //示例: Var分数= { 约翰:2，萨拉:3，珍妮特:1 }; var filtered =对象。Filter (scores, score => score > 1); console.log(过滤);

4. 使用对象。entry和Object.fromEntries

由于解决方案将对象转换为中间数组，然后将其转换回普通对象，因此使用object会很有用。entry (ES2017)和object . fromentries (ES2019)的相反(即从键/值对数组创建对象)。

它导致Object上的“一行”方法:

对象。Filter = (obj, predicate) => Object.fromEntries (Object.entries (obj) .filter(谓词)); //示例: Var分数= { 约翰:2，萨拉:3，珍妮特:1 }; var filtered =对象。Filter (scores， ([name, score]) => score > 1); console.log(过滤);

断言函数在这里获得一个键/值对作为参数，这有点不同，但在断言函数的逻辑中允许更多的可能性。

如果您愿意使用下划线或lodash，您可以使用pick(或与其相反的省略)。

来自underscore文档的例子:

_.pick({name: 'moe', age: 50, userid: 'moe1'}, 'name', 'age');
// {name: 'moe', age: 50}

或者使用回调(对于lodash，使用pickBy):

_.pick({name: 'moe', age: 50, userid: 'moe1'}, function(value, key, object) {
  return _.isNumber(value);
});
// {age: 50}

    var foo = {
    bar: "Yes",
    pipe: "No"
};

const ret =  Object.entries(foo).filter(([key, value])=> value === 'Yes');

https://masteringjs.io/tutorials/fundamentals/filter-object