fonction jQuery pour obtenir tous les éléments uniques d'un tableau?

il suffit d'utiliser ce code comme la base d'un simple plugin JQuery.

$.extend({
    distinct : function(anArray) {
       var result = [];
       $.each(anArray, function(i,v){
           if ($.inArray(v, result) == -1) result.push(v);
       });
       return result;
    }
});

utiliser comme suit:

$.distinct([0,1,2,2,3]);

basé sur la réponse de @kennebec, mais fixé pour IE8 et ci-dessous en utilisant jQuery wrappers autour du tableau pour fournir les fonctions manquantes du tableau filter et indexOf :

$.makeArray () wrapper pourrait ne pas être absolument nécessaire, mais vous obtiendrez des résultats étranges si vous omettez ce wrapper et JSON.stringify le résultat contraire.

var a = [1,5,1,6,4,5,2,5,4,3,1,2,6,6,3,3,2,4];

// note: jQuery's filter params are opposite of javascript's native implementation :(
var unique = $.makeArray($(a).filter(function(i,itm){ 
    // note: 'index', not 'indexOf'
    return i == $(a).index(itm);
}));

// unique: [1, 5, 6, 4, 2, 3]

j'utiliserais underscore.js , qui fournit une méthode uniq qui fait ce que vous voulez.

marchez dans le tableau et poussez des articles dans un hachage que vous rencontrez. Faites un renvoi au hachage pour chaque nouvel élément.

notez que cela ne fonctionnera correctement que pour les primitives (chaînes, nombres, null, Non défini, NaN) et quelques objets qui sérialisent vers la même chose (fonctions, chaînes, dates, éventuellement des tableaux selon le contenu). Les hashs de ce type entrent en collision lorsqu'ils sont tous sérialisés à la même chose, p.ex." [object Object] "

Array.prototype.distinct = function(){
   var map = {}, out = [];

   for(var i=0, l=this.length; i<l; i++){
      if(map[this[i]]){ continue; }

      out.push(this[i]);
      map[this[i]] = 1;
   }

   return out;
}

il n'y a pas non plus de raison de ne pas utiliser jQuery.unique. La seule chose que je n'aime pas, c'est qu'elle détruit la commande de votre tableau. Voici le code exact si vous êtes intéressé:

Sizzle.uniqueSort = function(results){
    if ( sortOrder ) {
        hasDuplicate = baseHasDuplicate;
        results.sort(sortOrder);

        if ( hasDuplicate ) {
            for ( var i = 1; i < results.length; i++ ) {
                if ( results[i] === results[i-1] ) {
                    results.splice(i--, 1);
                }
            }
        }
    }

    return results;
};

    // for numbers
    a = [1,3,2,4,5,6,7,8, 1,1,4,5,6]
    $.unique(a)
    [7, 6, 1, 8, 3, 2, 5, 4]

    // for string
    a = ["a", "a", "b"]
    $.unique(a)
    ["b", "a"]

et pour les éléments dom il n'y a pas d'exemple nécessaire ici je suppose parce que vous le savez déjà!

voici le lien jsfiddle de live example: http://jsfiddle.net/3BtMc/4 /

Paul Irish a une " Duck Punching " méthode (voir Exemple 2) qui modifie la $.unique() méthode de jQuery pour retourner des éléments uniques de tout type:

(function($){
    var _old = $.unique;
    $.unique = function(arr){
        // do the default behavior only if we got an array of elements
        if (!!arr[0].nodeType){
            return _old.apply(this,arguments);
        } else {
            // reduce the array to contain no dupes via grep/inArray
            return $.grep(arr,function(v,k){
                return $.inArray(v,arr) === k;
            });
        }
    };
})(jQuery);

c'est la solution de js1568, modifié pour travailler sur un Générique tableau d'objets, comme:

 var genericObject=[
        {genProp:'this is a string',randomInt:10,isBoolean:false},
        {genProp:'this is another string',randomInt:20,isBoolean:false},
        {genProp:'this is a string',randomInt:10,isBoolean:true},
        {genProp:'this is another string',randomInt:30,isBoolean:false},
        {genProp:'this is a string',randomInt:40,isBoolean:true},
        {genProp:'i like strings',randomInt:60,isBoolean:true},
        {genProp:'this is a string',randomInt:70,isBoolean:true},
        {genProp:'this string is unique',randomInt:50,isBoolean:true},
        {genProp:'this is a string',randomInt:50,isBoolean:false},
        {genProp:'i like strings',randomInt:70,isBoolean:false}
    ]

accepte un paramètre supplémentaire appelé propertyName, devinez! :)

  $.extend({
        distinctObj:function(obj,propertyName) {
            var result = [];
            $.each(obj,function(i,v){
                var prop=eval("v."+propertyName);
                if ($.inArray(prop, result) == -1) result.push(prop);
            });
            return result;
        }
    });

ainsi, si vous avez besoin d'extraire une liste de valeurs uniques pour une propriété donnée, par exemple les valeurs utilisées pour la propriété randomInt, utilisez ceci:

$.distinctObj(genericObject,'genProp');

retourne un tableau comme ceci:

["this is a string", "this is another string", "i like strings", "this string is unique"] 

function array_unique(array) {
    var unique = [];
    for ( var i = 0 ; i < array.length ; ++i ) {
        if ( unique.indexOf(array[i]) == -1 )
            unique.push(array[i]);
    }
    return unique;
}

vous pouvez utiliser un plugin jQuery appelé tableau Utilities pour obtenir un tableau d'articles uniques. Cela peut se faire comme ceci:

var distinctArray = $.distinct([1, 2, 2, 3])

distinctArray = [1,2,3]

si quelqu'un utilise knockoutjs try:

ko.utils.arrayGetDistinctValues()

BTW un coup d'oeil à tous les ko.utils.array* des services publics.

simple solution JavaScript moderne si vous n'avez pas besoin de support IE ( Array.from n'est pas supporté dans IE).

vous pouvez utiliser la combinaison de Set et Array.from .

var arr = [1, 1, 11, 2, 4, 2, 5, 3, 1];
var set = new Set(arr);
arr = Array.from(set);

console.log(arr);

l'objet Set permet de stocker des valeurs uniques de tout type, qu'il s'agisse de valeurs primitives ou de références d'objet.

La méthode Array.from() crée une nouvelle instance de tableau à partir d'un objet similaire à un tableau ou itérable.

à partir de jquery 3.0 vous pouvez utiliser $.uniqueSort(ARRAY)

exemple

array = ["1","2","1","2"]
$.uniqueSort(array)
=> ["1", "2"]