Eliminar objetos duplicados con subrayado para Javascript

Tengo este tipo de matriz:

var foo = [ { "a" : "1" }, { "b" : "2" }, { "a" : "1" } ];

Me gustaría filtrarlo para tener:

var bar = [ { "a" : "1" }, { "b" : "2" }];

Intenté usar _.uniq, pero supongo que porque { "a" : "1" }no es igual a sí mismo, no funciona. ¿Hay alguna manera de proporcionar subrayado uniq con una función de anulación igual?

.uniq / .unique acepta una devolución de llamada

var list = [{a:1,b:5},{a:1,c:5},{a:2},{a:3},{a:4},{a:3},{a:2}];

var uniqueList = _.uniq(list, function(item, key, a) { 
    return item.a;
});

// uniqueList = [Object {a=1, b=5}, Object {a=2}, Object {a=3}, Object {a=4}]

Notas:

1. Valor de retorno de devolución de llamada utilizado para comparación
2. Primer objeto de comparación con un valor de retorno único utilizado como único
3. underscorejs.org no demuestra el uso de devolución de llamada
4. lodash.com muestra el uso

Otro ejemplo: usar la devolución de llamada para extraer marcas de automóviles, colores de una lista

Si está buscando eliminar duplicados basados ​​en una identificación, puede hacer algo como esto:

var res = [
  {id: 1, content: 'heeey'},
  {id: 2, content: 'woah'}, 
  {id: 1, content:'foo'},
  {id: 1, content: 'heeey'},
];
var uniques = _.map(_.groupBy(res,function(doc){
  return doc.id;
}),function(grouped){
  return grouped[0];
});

//uniques
//[{id: 1, content: 'heeey'},{id: 2, content: 'woah'}]

Implementación de la respuesta de Shiplu.

var foo = [ { "a" : "1" }, { "b" : "2" }, { "a" : "1" } ];

var x = _.uniq( _.collect( foo, function( x ){
    return JSON.stringify( x );
}));

console.log( x ); // returns [ { "a" : "1" }, { "b" : "2" } ]

Cuando tengo una identificación de atributo, esta es mi forma preferida en guión bajo:

var x = [{i:2}, {i:2, x:42}, {i:4}, {i:3}];
_.chain(x).indexBy("i").values().value();
// > [{i:2, x:42}, {i:4}, {i:3}]

El uso de guiones únicos de subrayado lib funciona para mí, estoy haciendo una lista única basada en _id y luego devolviendo el valor de cadena de _id:

var uniqueEntities = _.uniq(entities, function (item, key, a) {
                                    return item._id.toString();
                                });

Aquí hay una solución simple, que utiliza una comparación profunda de objetos para verificar si hay duplicados (sin recurrir a la conversión a JSON, que es ineficiente y hacky)

var newArr = _.filter(oldArr, function (element, index) {
    // tests if the element has a duplicate in the rest of the array
    for(index += 1; index < oldArr.length; index += 1) {
        if (_.isEqual(element, oldArr[index])) {
            return false;
        }
    }
    return true;
});

Filtra todos los elementos si tienen un duplicado más adelante en la matriz, de modo que se mantenga el último elemento duplicado.

La prueba de un uso duplicado _.isEqualque realiza una comparación profunda optimizada entre los dos objetos, consulte la documentación de subrayado isEqual para obtener más información.

editar: actualizado para usar, _.filterque es un enfoque más limpio

Los documentos de lodash 4.6.1 tienen esto como un ejemplo para la igualdad de clave de objeto:

_.uniqWith(objects, _.isEqual);

https://lodash.com/docs#uniqWith

Prueba la función iteradora

Por ejemplo, puede devolver el primer elemento

x = [['a',1],['b',2],['a',1]]

_.uniq(x,false,function(i){  

   return i[0]   //'a','b'

})

=> [['' a ', 1], [' b ', 2]]

Aquí está mi solución (coffeescript):

_.mixin
  deepUniq: (coll) ->
    result = []
    remove_first_el_duplicates = (coll2) ->

      rest = _.rest(coll2)
      first = _.first(coll2)
      result.push first
      equalsFirst = (el) -> _.isEqual(el,first)

      newColl = _.reject rest, equalsFirst

      unless _.isEmpty newColl
        remove_first_el_duplicates newColl

    remove_first_el_duplicates(coll)
    result

ejemplo:

_.deepUniq([ {a:1,b:12}, [ 2, 1, 2, 1 ], [ 1, 2, 1, 2 ],[ 2, 1, 2, 1 ], {a:1,b:12} ]) 
//=> [ { a: 1, b: 12 }, [ 2, 1, 2, 1 ], [ 1, 2, 1, 2 ] ]

con guión bajo tuve que usar String () en la función iteratee

function isUniq(item) {
    return String(item.user);
}
var myUniqArray = _.uniq(myArray, isUniq);

Quería resolver esta solución simple de una manera sencilla de escribir, con un poco de molestia en los gastos computacionales ... pero ¿no es una solución trivial con una definición mínima variable, verdad?

function uniq(ArrayObjects){
  var out = []
  ArrayObjects.map(obj => {
    if(_.every(out, outobj => !_.isEqual(obj, outobj))) out.push(obj)
  })
  return out
}

var foo = [ { "a" : "1" }, { "b" : "2" }, { "a" : "1" } ];
var bar = _.map(_.groupBy(foo, function (f) { 
        return JSON.stringify(f); 
    }), function (gr) { 
        return gr[0]; 
    }
);

Vamos a romper esto. Primero, agrupemos los elementos de la matriz por su valor en cadena

var grouped = _.groupBy(foo, function (f) { 
    return JSON.stringify(f); 
});

grouped parece:

{
    '{ "a" : "1" }' = [ { "a" : "1" } { "a" : "1" } ],
    '{ "b" : "2" }' = [ { "b" : "2" } ]
}

Luego tomemos el primer elemento de cada grupo

var bar = _.map(grouped, function(gr)
    return gr[0]; 
});

bar parece: [ { "a" : "1" }, { "b" : "2" } ]

Ponlo todo junto:

var foo = [ { "a" : "1" }, { "b" : "2" }, { "a" : "1" } ];
var bar = _.map(_.groupBy(foo, function (f) { 
        return JSON.stringify(f); 
    }), function (gr) { 
        return gr[0]; 
    }
);

Puedes hacerlo en forma abreviada como:

_.uniq(foo, 'a')