Rimozione di oggetti duplicati con trattino basso per Javascript

Ho questo tipo di array:

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

Mi piacerebbe filtrarlo per avere:

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

Ho provato a usare _.uniq, ma immagino che poiché { "a" : "1" }non è uguale a se stesso, non funziona. C'è un modo per fornire il carattere di sottolineatura uniq con una funzione uguale a sovrascrittura?

.uniq / .unique accetta una richiamata

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

Appunti:

1. Valore di ritorno della richiamata utilizzato per il confronto
2. Primo oggetto di confronto con valore restituito univoco utilizzato come unico
3. underscorejs.org non mostra l'utilizzo di callback
4. lodash.com mostra l'utilizzo

Un altro esempio: utilizzo della richiamata per estrarre marche e colori di automobili da un elenco

Se stai cercando di rimuovere i duplicati in base a un ID, potresti fare qualcosa del genere:

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

Attuazione della risposta di 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 ho un ID attributo, questo è il mio modo preferito in underscore:

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

L'utilizzo del carattere di sottolineatura univoco lib che segue funziona per me, sto creando un elenco univoco sulla base di _id, quindi restituisco il valore String di _id:

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

Ecco una soluzione semplice, che utilizza un confronto approfondito degli oggetti per verificare la presenza di duplicati (senza ricorrere alla conversione in JSON, che è inefficiente 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;
});

Filtra tutti gli elementi se hanno un duplicato in un secondo momento nell'array, in modo che venga mantenuto l'ultimo elemento duplicato.

Il test per un duplicato utilizza _.isEqualche esegue un confronto approfondito ottimizzato tra i due oggetti, vedere la documentazione di sottolineatura isEqual per maggiori informazioni.

modifica: aggiornato per utilizzare _.filterche è un approccio più pulito

I documenti di lodash 4.6.1 hanno questo come esempio per l'uguaglianza della chiave dell'oggetto:

_.uniqWith(objects, _.isEqual);

https://lodash.com/docs#uniqWith

Prova la funzione iteratore

Ad esempio puoi restituire il primo elemento

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

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

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

})

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

ecco la mia soluzione (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

esempio:

_.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 il carattere di sottolineatura ho dovuto usare String () nella funzione iteratee

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

Volevo risolvere questa semplice soluzione in un modo diretto di scrivere, con un po 'di dolore per le spese di calcolo ... ma non è una soluzione banale con una definizione minima di variabile, vero?

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

Analizziamo questo. Innanzitutto raggruppiamo gli elementi dell'array in base al loro valore in stringa

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

grouped sembra:

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

Quindi prendiamo il primo elemento da ogni gruppo

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

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

Metterli tutti insieme:

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

Puoi farlo in breve come:

_.uniq(foo, 'a')