首先，扩展Object.prototype. 相反，将您的功能作为独立功能提供，或者如果您真的想扩展一个全局功能，请将其作为实用程序提供在 上Object，就像已经有Object.keys, Object.assign, Object.is, ... 等。

我在这里提供了几种解决方案：

1. 使用reduce和Object.keys
2. 如（1），结合 Object.assign
3. 使用map和传播语法而不是reduce
4. 使用Object.entries和Object.fromEntries

1. 使用reduce和Object.keys

使用reduce和Object.keys实现所需的过滤器（使用 ES6箭头语法）：

Object.filter = (obj, predicate) => 
    Object.keys(obj)
          .filter( key => predicate(obj[key]) )
          .reduce( (res, key) => (res[key] = obj[key], res), {} );

// Example use:
var scores = {
    John: 2, Sarah: 3, Janet: 1
};
var filtered = Object.filter(scores, score => score > 1); 
console.log(filtered);

请注意，在上面的代码中predicate必须是包含条件（与OP 使用的排除条件相反），以便它符合Array.prototype.filter工作原理。

2.如（1），结合 Object.assign

在上述解决方案中，逗号运算符用于reduce返回变异res对象的部分。这当然可以写成两个语句而不是一个表达式，但后者更简洁。要在没有逗号运算符的情况下执行此操作，您可以Object.assign改用它，它确实返回变异的对象：

Object.filter = (obj, predicate) => 
    Object.keys(obj)
          .filter( key => predicate(obj[key]) )
          .reduce( (res, key) => Object.assign(res, { [key]: obj[key] }), {} );

// Example use:
var scores = {
    John: 2, Sarah: 3, Janet: 1
};
var filtered = Object.filter(scores, score => score > 1); 
console.log(filtered);

3. 使用map和传播语法代替reduce

在这里，我们将Object.assign调用移出循环，因此它只进行一次，并将各个键作为单独的参数传递给它（使用扩展语法）：

Object.filter = (obj, predicate) => 
    Object.assign(...Object.keys(obj)
                    .filter( key => predicate(obj[key]) )
                    .map( key => ({ [key]: obj[key] }) ) );

// Example use:
var scores = {
    John: 2, Sarah: 3, Janet: 1
};
var filtered = Object.filter(scores, score => score > 1); 
console.log(filtered);

4. 使用Object.entries和Object.fromEntries

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

它导致了这种“单行”方法Object：

Object.filter = (obj, predicate) => 
                  Object.fromEntries(Object.entries(obj).filter(predicate));

// Example use:
var scores = {
    John: 2, Sarah: 3, Janet: 1
};

var filtered = Object.filter(scores, ([name, score]) => score > 1); 
console.log(filtered);

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

永远不要扩展Object.prototype。

你的代码会发生可怕的事情。事情会破裂。您正在扩展所有对象类型，包括对象文字。

这是您可以尝试的快速示例：

    // Extend Object.prototype
Object.prototype.extended = "I'm everywhere!";

    // See the result
alert( {}.extended );          // "I'm everywhere!"
alert( [].extended );          // "I'm everywhere!"
alert( new Date().extended );  // "I'm everywhere!"
alert( 3..extended );          // "I'm everywhere!"
alert( true.extended );        // "I'm everywhere!"
alert( "here?".extended );     // "I'm everywhere!"

而是创建一个传递对象的函数。

Object.filter = function( obj, predicate) {
    let result = {}, key;

    for (key in obj) {
        if (obj.hasOwnProperty(key) && !predicate(obj[key])) {
            result[key] = obj[key];
        }
    }

    return result;
};

从 2020 年开始在 Vanilla JS 中的解决方案。

let romNumbers={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}

您可以romNumbers按键过滤对象：

const filteredByKey = Object.fromEntries(
    Object.entries(romNumbers).filter(([key, value]) => key === 'I') )
// filteredByKey = {I: 1} 

或romNumbers按值过滤对象：

 const filteredByValue = Object.fromEntries(
    Object.entries(romNumbers).filter(([key, value]) => value === 5) )
 // filteredByValue = {V: 5} 

如果您愿意使用下划线或lodash，则可以使用pick（或相反的omit）。

下划线文档中的示例：

_.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}

ES6方法...

想象一下你有下面这个对象：

const developers = {
  1: {
   id: 1,
   name: "Brendan", 
   family: "Eich"
  },
  2: {
   id: 2,
   name: "John", 
   family: "Resig"
  },  
  3: {
   id: 3,
   name: "Alireza", 
   family: "Dezfoolian"
 }
};

创建一个函数：

const filterObject = (obj, filter, filterValue) => 
   Object.keys(obj).reduce((acc, val) => 
   (obj[val][filter] === filterValue ? acc : {
       ...acc,
       [val]: obj[val]
   }                                        
), {});

并称之为：

filterObject(developers, "name", "Alireza");

并将返回：

{
  1: {
  id: 1,
  name: "Brendan", 
  family: "Eich"
  },
  2: {
   id: 2,
   name: "John", 
   family: "Resig"
  }
}