Removendo Objetos Duplicados com Sublinhado para Javascript

Eu tenho esse tipo de matriz:

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

Eu gostaria de filtrá-lo para ter:

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

Eu tentei usar _.uniq, mas acho que porque { "a" : "1" }não é igual a si mesmo, não funciona. Existe alguma maneira de fornecer ao sublinhado uniq uma função igual substituída?

.uniq / .unique aceita um retorno de chamada

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 retorno de chamada usado para comparação
2. Primeiro objeto de comparação com valor de retorno exclusivo usado como único
3. underscorejs.org não demonstra uso de retorno de chamada
4. lodash.com mostra o uso

Outro exemplo: usando o retorno de chamada para extrair marcas de carros, cores de uma lista

Se você deseja remover duplicatas com base em um ID, pode fazer algo assim:

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'}]

Implementação da resposta da 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" } ]

Quando tenho um ID de atributo, esta é a minha maneira preferida em sublinhado:

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

Usando sublinhado lib exclusivo a seguir está funcionando para mim, eu estou tornando a lista exclusiva com base em _id e retornando o valor String de _id:

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

Aqui está uma solução simples, que usa uma comparação profunda de objetos para verificar se há duplicatas (sem recorrer à conversão para JSON, que é ineficiente e 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;
});

Ele filtra todos os elementos se eles tiverem uma duplicata posteriormente na matriz - de modo que o último elemento duplicado seja mantido.

Os testes para usos duplicados _.isEqualque executam uma comparação profunda otimizada entre os dois objetos, consulte a documentação isEqual de sublinhado para obter mais informações.

edit: atualizado para usar, _.filterque é uma abordagem mais limpa

Os documentos do lodash 4.6.1 têm isso como exemplo de igualdade de chave de objeto:

_.uniqWith(objects, _.isEqual);

https://lodash.com/docs#uniqWith

Experimente a função do iterador

Por exemplo, você pode retornar o primeiro elemento

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

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

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

})

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

aqui está a minha solução (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

exemplo:

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

com sublinhado, tive que usar String () na função iteratee

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

Eu queria resolver essa solução simples de maneira direta, com um pouco de esforço computacional ... mas não é uma solução trivial com uma definição mínima de variável, é?

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 quebrar isso. Primeiro, vamos agrupar os itens da matriz pelo seu valor estrito

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

grouped parece:

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

Então vamos pegar o primeiro elemento de cada grupo

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

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

Coloque tudo 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]; 
    }
);

Você pode fazer isso de forma abreviada como:

_.uniq(foo, 'a')