javascript - tutorial - ¿Cómo uso el método includes en lodash para verificar si un objeto está en la colección?

lodash vs underscore

Question

lodash me permite verificar membresía de tipos de datos básicos con includes :

_.includes([1, 2, 3], 2)
> true

Pero lo siguiente no funciona:

_.includes([{"a": 1}, {"b": 2}], {"b": 2})
> false

Esto me confunde porque los siguientes métodos que buscan a través de una colección parecen funcionar bien:

_.where([{"a": 1}, {"b": 2}], {"b": 2})
> {"b": 2}
_.find([{"a": 1}, {"b": 2}], {"b": 2})
> {"b": 2}

¿Qué estoy haciendo mal? ¿Cómo verifico la membresía de un objeto en una colección con includes ?

editar: la pregunta fue originalmente para lodash versión 2.4.1, actualizada para lodash 4.0.0

Answer 1

Complementando la respuesta por pswg , aquí hay otras tres maneras de lograr esto usando lodash 4.17.5 , sin usar _.includes() :

Supongamos que desea agregar una entry objeto a una matriz de numbers de objetos, solo si la entry ya no existe.

let numbers = [
    { to: 1, from: 2 },
    { to: 3, from: 4 },
    { to: 5, from: 6 },
    { to: 7, from: 8 },
    { to: 1, from: 2 } // intentionally added duplicate
];

let entry = { to: 1, from: 2 };

/* 
 * 1. This will return the *index of the first* element that matches:
 */
_.findIndex(numbers, (o) => { return _.isMatch(o, entry) });
// output: 0


/* 
 * 2. This will return the entry that matches. Even if the entry exists
 *    multiple time, it is only returned once.
 */
_.find(numbers, (o) => { return _.isMatch(o, entry) });
// output: {to: 1, from: 2}


/* 
 * 3. This will return an array of objects containing all the matches.
 *    If an entry exists multiple times, if is returned multiple times.
 */
_.filter(numbers, _.matches(entry));
// output: [{to: 1, from: 2}, {to: 1, from: 2}]

Si desea devolver un Boolean , en el primer caso, puede verificar el índice que se está devolviendo:

_.findIndex(numbers, (o) => { return _.isMatch(o, entry) }) > -1;
// output: true

Answer 2

El método includes (anteriormente llamado contains e include ) compara objetos por referencia (o más precisamente, con === ). Debido a que los dos literales objeto de {"b": 2} en su ejemplo representan instancias diferentes , no son iguales. Darse cuenta:

({"b": 2} === {"b": 2})
> false

Sin embargo, esto funcionará porque solo hay una instancia de {"b": 2} :

var a = {"a": 1}, b = {"b": 2};
_.includes([a, b], b);
> true

Por otro lado, where (obsoleto en v4) y los métodos de find comparan objetos por sus propiedades, por lo que no requieren igualdad de referencia. Como alternativa a includes , es posible que desee probar some (también con alias como any ):

_.some([{"a": 1}, {"b": 2}], {"b": 2})
> true