如果您希望改变相同的对象，而不是创建一个新的对象。

下面的例子将删除所有0或空值:

const sev = { a: 1, b: 0, c: 3 };
const deleteKeysBy = (obj, predicate) =>
  Object.keys(obj)
    .forEach( (key) => {
      if (predicate(obj[key])) {
        delete(obj[key]);
      }
    });

deleteKeysBy(sev, val => !val);

永远不要扩展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;
};

如果你的对象中有Symbol属性，那也应该被过滤，你不能使用:object。键对象。Object.fromEntries，…因为:

符号键是不可枚举的!

你可以使用Reflect。reduce中的ownKeys和filter key

Reflect.ownKeys(o).reduce((a, k) => allow.includes(k) && {...a, [k]: o[k]} || a, {});

(打开DevTools输出日志- Stackoverflow界面上不记录符号)

const bKey =符号('b_k'); Const o = { 一个 : 1, [bKey ]: ' b”, C: [1,3]， [Symbol.for (' d ')]: ' d ' }; const allow = ['a'， bKey, Symbol.for('d')]; const z1 = Reflect.ownKeys(o)。Reduce ((a, k) => allow.includes(k) &&{…A， [k]: o[k]} || A， {}); console.log (z1);// {a: 1，符号(b_k): "b"，符号(d): "d"} console.log(bKey in z1) // true console.log(Symbol.for('d') in z1) // true

这个等于这个

const z2 = Reflect.ownKeys(o).reduce((a, k) => allow.includes(k) && Object.assign(a, {[k]: o[k]}) || a, {});
const z3 = Reflect.ownKeys(o).reduce((a, k) => allow.includes(k) && Object.defineProperty(a, k, {value: o[k]}) || a, {});

console.log(z2); // {a: 1, Symbol(b_k): "b", Symbol(d): "d"}
console.log(z3); // {a: 1, Symbol(b_k): "b", Symbol(d): "d"}

在filter()函数中，可以传递一个可选的目标对象

const filter = (o, allow, t = {}) => Reflect.ownKeys(o).reduce(
    (a, k) => allow.includes(k) && {...a, [k]: o[k]} || a, 
    t
);

console.log(filter(o, allow));           // {a: 1, Symbol(b_k): "b", Symbol(d): "d"}
console.log(filter(o, allow, {e: 'e'})); // {a: 1, e: "e", Symbol(b_k): "b", Symbol(d): "d"}

如果您希望改变相同的对象，而不是创建一个新的对象。

下面的例子将删除所有0或空值:

const sev = { a: 1, b: 0, c: 3 };
const deleteKeysBy = (obj, predicate) =>
  Object.keys(obj)
    .forEach( (key) => {
      if (predicate(obj[key])) {
        delete(obj[key]);
      }
    });

deleteKeysBy(sev, val => !val);

正如patrick已经说过的，这是一个坏主意，因为它几乎肯定会破坏任何第三方代码，你可能希望使用。

所有的库，如jquery或prototype将中断如果你扩展Object。原型，原因是在对象上的惰性迭代(没有hasOwnProperty检查)将打破，因为你添加的函数将是迭代的一部分。

在这些情况下，我使用jquery $。映射，它可以处理对象。正如在其他回答中提到的，更改本地原型并不是一个好的实践(https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain#Bad_practice_Extension_of_native_prototypes)

下面是一个仅通过检查对象的某些属性进行过滤的示例。如果你的条件为真，它返回自己的对象，否则返回undefined。undefined属性将使该记录从对象列表中消失;

$.map(yourObject, (el, index)=>{
    return el.yourProperty ? el : undefined;
});