JavaScript: filter () para objetos

ECMAScript 5 tiene el filter()prototipo para los Arraytipos, pero no para los Objecttipos, si lo entiendo correctamente.

¿Cómo implementaría un filter()for Objects en JavaScript?

Digamos que tengo este objeto:

var foo = {
    bar: "Yes"
};

Y quiero escribir un filter()que funcione en Objects:

Object.prototype.filter = function(predicate) {
    var result = {};

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

    return result;
};

Esto funciona cuando lo uso en la siguiente demostración, pero cuando lo agrego a mi sitio que usa jQuery 1.5 y jQuery UI 1.8.9, obtengo errores de JavaScript en FireBug.

Object.prototype.filter = function(predicate) {
  var result = {};
  for (key in this) {
    if (this.hasOwnProperty(key) && !predicate(this[key])) {
      console.log("copying");
      result[key] = this[key];
    }
  }
  return result;
};

var foo = {
  bar: "Yes",
  moo: undefined
};

foo = foo.filter(function(property) {
  return typeof property === "undefined";
});

document.getElementById('disp').innerHTML = JSON.stringify(foo, undefined, '  ');
console.log(foo);

#disp {
  white-space: pre;
  font-family: monospace
}

<div id="disp"></div>

Nunca se extienda Object.prototype.

Cosas horribles sucederán con su código. Las cosas se romperán. Estás extendiendo todos los tipos de objetos, incluidos los literales de objetos.

Aquí hay un ejemplo rápido que puedes probar:

    // 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!"

En su lugar, cree una función en la que pase el objeto.

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;
};

En primer lugar, se considera una mala práctica extenderObject.prototype . En su lugar, proporcionar a su función como función de utilidad en Object, al igual que ya existen Object.keys, Object.assign, Object.is, ... etc.

Proporciono aquí varias soluciones:

1. Usando reduceyObject.keys
2. Como (1), en combinación con Object.assign
3. Uso mapy sintaxis extendida en lugar dereduce
4. Usando Object.entriesyObject.fromEntries

1. Usando reduceyObject.keys

Con reducey Object.keyspara implementar el filtro deseado (usando la sintaxis de flecha 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);

Tenga en cuenta que en el código anterior predicatedebe ser una condición de inclusión (contrario a la condición de exclusión que utilizó el OP), de modo que esté en línea con el Array.prototype.filterfuncionamiento.

2. Como (1), en combinación con Object.assign

En la solución anterior, el operador de coma se usa en la reduceparte para devolver el resobjeto mutado . Por supuesto, esto podría escribirse como dos declaraciones en lugar de una sola expresión, pero esta última es más concisa. Para hacerlo sin el operador de coma, puede usar Object.assignen su lugar, lo que devuelve el objeto mutado:

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. Uso mapy sintaxis extendida en lugar dereduce

Aquí movemos la Object.assignllamada fuera del ciclo, por lo que solo se realiza una vez, y le pasamos las teclas individuales como argumentos separados (usando la sintaxis de propagación ):

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. Usando Object.entriesyObject.fromEntries

A medida que la solución traduce el objeto a una matriz intermedia y luego la convierte de nuevo en un objeto plano, sería útil utilizar Object.entries(ES2017) y lo contrario (es decir, crear un objeto a partir de una matriz de pares clave / valor ) con Object.fromEntries( ES2019).

Conduce a este método "one-liner" en 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);

La función de predicado obtiene un par clave / valor como argumento aquí, que es un poco diferente, pero permite más posibilidades en la lógica de la función de predicado.

Si está dispuesto a usar guiones bajos o lodash , puede usar pick(o su opuesto omit).

Ejemplos de documentos de subrayado:

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

O con una devolución de llamada (para lodash , use pickBy ):

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

Enfoque ES6 ...

Imagina que tienes este objeto a continuación:

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

Crea una función:

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

Y llámalo:

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

y va a volver :

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

Como Patrick ya dijo, esta es una mala idea, ya que casi con seguridad romperá cualquier código de terceros que pueda desear usar.

Todas las bibliotecas, como jquery o prototype, se romperán si extiende Object.prototype, la razón es que la iteración perezosa sobre los objetos (sin hasOwnPropertyverificaciones) se romperá, ya que las funciones que agregue serán parte de la iteración.

Qué tal si:

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

O...

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

Dado

object = {firstname: 'abd', lastname:'tm', age:16, school:'insat'};

keys = ['firstname', 'age'];

luego :

keys.reduce((result, key) => ({ ...result, [key]: object[key] }), {});
// {firstname:'abd', age: 16}

// Helper
function filter(object, ...keys) {
  return keys.reduce((result, key) => ({ ...result, [key]: object[key] }), {});
  
};

//Example
const person = {firstname: 'abd', lastname:'tm', age:16, school:'insat'};

// Expected to pick only firstname and age keys
console.log(
  filter(person, 'firstname', 'age')
)

He creado un Object.filter() que no solo se filtra por una función, sino que también acepta una serie de claves para incluir. El tercer parámetro opcional le permitirá invertir el filtro.

Dado:

var foo = {
    x: 1,
    y: 0,
    z: -1,
    a: 'Hello',
    b: 'World'
}

Formación:

Object.filter(foo, ['z', 'a', 'b'], true);

Función:

Object.filter(foo, function (key, value) {
    return Ext.isString(value);
});

Código

Descargo de responsabilidad : elegí usar Ext JS core por brevedad. No sentí que fuera necesario escribir verificadores de tipos para los tipos de objetos ya que no era parte de la pregunta.

// Helper function
function print(obj) {
    document.getElementById('disp').innerHTML += JSON.stringify(obj, undefined, '  ') + '<br />';
    console.log(obj);
}

Object.filter = function (obj, ignore, invert) {
    let result = {}; // Returns a filtered copy of the original list
    if (ignore === undefined) {
        return obj;   
    }
    invert = invert || false;
    let not = function(condition, yes) { return yes ? !condition : condition; };
    let isArray = Ext.isArray(ignore);
    for (var key in obj) {
        if (obj.hasOwnProperty(key) &&
                !(isArray && not(!Ext.Array.contains(ignore, key), invert)) &&
                !(!isArray && not(!ignore.call(undefined, key, obj[key]), invert))) {
            result[key] = obj[key];
        }
    }
    return result;
};

let foo = {
    x: 1,
    y: 0,
    z: -1,
    a: 'Hello',
    b: 'World'
};

print(Object.filter(foo, ['z', 'a', 'b'], true));
print(Object.filter(foo, (key, value) => Ext.isString(value)));

#disp {
    white-space: pre;
    font-family: monospace
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/extjs/4.2.1/builds/ext-core.min.js"></script>
<div id="disp"></div>

Mi solución obstinada:

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
}

Casos de prueba:

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

Solución en Vanilla JS del año 2020.

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

Puede filtrar romNumbersobjetos por clave:

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

O filtrar romNumbersobjeto por valor:

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

Si desea mutar el mismo objeto en lugar de crear uno nuevo.

El siguiente ejemplo eliminará todos los 0 o valores vacíos:

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);

Como todos decían, no te metas con el prototipo. En cambio, simplemente escriba una función para hacerlo. Aquí está mi versión con lodash:

import each from 'lodash/each';
import get from 'lodash/get';

const myFilteredResults = results => {
  const filteredResults = [];

  each(results, obj => {
    // filter by whatever logic you want.

    // sample example
    const someBoolean = get(obj, 'some_boolean', '');

    if (someBoolean) {
      filteredResults.push(obj);
    }
  });

  return filteredResults;
};

Lo uso cuando lo necesito:

const filterObject = (obj, condition) => {
    const filteredObj = {};
    Object.keys(obj).map(key => {
      if (condition(key)) {
        dataFiltered[key] = obj[key];
      }
    });
  return filteredObj;
}

En estos casos, uso el jquery $ .map, que puede manejar objetos. Como se menciona en otras respuestas, no es una buena práctica cambiar los prototipos nativos ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain#Bad_practice_Extension_of_native_prototypes )

A continuación se muestra un ejemplo de filtrado simplemente marcando alguna propiedad de su objeto. Devuelve el propio objeto si su condición es verdadera o devuelve undefinedsi no. La undefinedpropiedad hará que ese registro desaparezca de su lista de objetos;

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