Suppression des objets en double avec Underscore pour Javascript

J'ai ce genre de tableau:

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

Je voudrais le filtrer pour avoir:

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

J'ai essayé d'utiliser _.uniq, mais je suppose que parce que ce { "a" : "1" }n'est pas égal à lui-même, cela ne fonctionne pas. Existe-t-il un moyen de fournir un soulignement uniq avec une fonction de substitution égale?

.uniq / .unique accepte un rappel

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

Remarques:

1. Valeur de retour de rappel utilisée pour la comparaison
2. Premier objet de comparaison avec une valeur de retour unique utilisée comme unique
3. underscorejs.org ne démontre aucune utilisation de rappel
4. lodash.com montre l'utilisation

Autre exemple: utiliser le callback pour extraire les marques de voitures, les couleurs d'une liste

Si vous cherchez à supprimer les doublons en fonction d'un identifiant, vous pouvez faire quelque chose comme ceci:

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

Mise en œuvre de la réponse 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" } ]

Quand j'ai un identifiant d'attribut, c'est ma manière préférée de soulignement:

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'utilisation de la librairie unique de soulignement qui suit fonctionne pour moi, je rend la liste unique en fonction de _id, puis renvoie la valeur String de _id:

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

Voici une solution simple, qui utilise une comparaison d'objets approfondie pour vérifier les doublons (sans recourir à la conversion en JSON, ce qui est inefficace et piraté)

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

Il filtre tous les éléments s'ils ont un doublon plus tard dans le tableau - de sorte que le dernier élément en double est conservé.

Le test des utilisations en double _.isEqualqui effectue une comparaison approfondie optimisée entre les deux objets, consultez la documentation isEqual de soulignement pour plus d'informations.

edit: mis à jour pour utiliser _.filterce qui est une approche plus propre

La documentation de lodash 4.6.1 a ceci comme exemple d'égalité de clé d'objet:

_.uniqWith(objects, _.isEqual);

https://lodash.com/docs#uniqWith

Essayez la fonction d'itérateur

Par exemple, vous pouvez retourner le premier élément

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

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

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

})

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

voici ma solution (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

exemple:

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

avec un soulignement, j'ai dû utiliser String () dans la fonction iteratee

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

Je voulais résoudre cette solution simple d'une manière simple d'écrire, avec un peu de peine de frais de calcul ... mais n'est-ce pas une solution triviale avec une définition de variable minimale, n'est-ce pas?

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

Permet de décomposer cela. Commençons par regrouper les éléments du tableau par leur valeur stringifiée

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

grouped ressemble à:

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

Puis attrapons le premier élément de chaque groupe

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

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

Mets le tout ensemble:

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

Vous pouvez le faire en abrégé comme:

_.uniq(foo, 'a')