J'ai un tableau de nombres dont je dois m'assurer qu'ils sont uniques. J'ai trouvé l'extrait de code ci-dessous sur Internet et cela fonctionne très bien jusqu'à ce que le tableau contienne un zéro. J'ai trouvé cet autre script ici sur Stack Overflow qui lui ressemble presque exactement, mais il n'échoue pas.

Donc, pour m'aider à apprendre, quelqu'un peut-il m'aider à déterminer où le script prototype va mal?

Array.prototype.getUnique = function() {
 var o = {}, a = [], i, e;
 for (i = 0; e = this[i]; i++) {o[e] = 1};
 for (e in o) {a.push (e)};
 return a;
}

Plus de réponses à la question en double:

• Supprimer les valeurs en double du tableau JS

Question similaire:

• Récupère toutes les valeurs non uniques (ex: doublon / plusieurs occurrences) dans un tableau

Avec JavaScript 1.6 / ECMAScript 5, vous pouvez utiliser la filterméthode native d'un tableau de la manière suivante pour obtenir un tableau avec des valeurs uniques:

function onlyUnique(value, index, self) { 
    return self.indexOf(value) === index;
}

// usage example:
var a = ['a', 1, 'a', 2, '1'];
var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

La méthode native filterparcourra le tableau et ne laissera que les entrées qui passent la fonction de rappel donnée onlyUnique.

onlyUniquevérifie si la valeur donnée est la première survenue. Sinon, il doit s'agir d'un doublon et ne sera pas copié.

Cette solution fonctionne sans bibliothèque supplémentaire comme jQuery ou prototype.js.

Cela fonctionne également pour les tableaux avec des types de valeurs mixtes.

Pour les anciens navigateurs (<ie9), qui ne prennent pas en charge les méthodes natives filteret indexOfvous pouvez trouver des solutions dans la documentation MDN pour filter et indexOf .

Si vous souhaitez conserver la dernière occurrence d'une valeur, remplacez simplement indexOfpar lastIndexOf.

Avec ES6, cela pourrait être raccourci:

// usage example:
var myArray = ['a', 1, 'a', 2, '1'];
var unique = myArray.filter((v, i, a) => a.indexOf(v) === i); 

// unique is ['a', 1, 2, '1']

Merci à Camilo Martin pour un indice en commentaire.

ES6 possède un objet natif Setpour stocker des valeurs uniques. Pour obtenir un tableau avec des valeurs uniques, vous pouvez maintenant faire ceci:

var myArray = ['a', 1, 'a', 2, '1'];

let unique = [...new Set(myArray)]; 

// unique is ['a', 1, 2, '1']

Le constructeur de Setprend un objet itérable, comme Array, et l'opérateur de propagation ...transforme l'ensemble en un tableau. Merci à Lukas Liese pour un indice en commentaire.

Réponse mise à jour pour ES6 / ES2015 : à l'aide de l' ensemble , la solution unifilaire est:

var items = [4,5,4,6,3,4,5,2,23,1,4,4,4]
var uniqueItems = Array.from(new Set(items))

Qui revient

[4, 5, 6, 3, 2, 23, 1]

Comme suggéré par le_m , cela peut également être raccourci à l'aide de l' opérateur d'étalement , comme

var uniqueItems = [...new Set(items)]

Je me rends compte que cette question a déjà plus de 30 réponses. Mais j'ai d'abord lu toutes les réponses existantes et fait mes propres recherches.

J'ai divisé toutes les réponses en 4 solutions possibles:

1. Utilisez la nouvelle fonctionnalité ES6: [...new Set( [1, 1, 2] )];
2. Utiliser un objet { }pour éviter les doublons
3. Utiliser un tableau d'assistance [ ]
4. Utilisation filter + indexOf

Voici des exemples de codes trouvés dans les réponses:

Utilisez la nouvelle fonctionnalité ES6: [...new Set( [1, 1, 2] )];

function uniqueArray0(array) {
  var result = Array.from(new Set(array));
  return result    
}

Utiliser un objet { }pour éviter les doublons

function uniqueArray1( ar ) {
  var j = {};

  ar.forEach( function(v) {
    j[v+ '::' + typeof v] = v;
  });

  return Object.keys(j).map(function(v){
    return j[v];
  });
} 

Utiliser un tableau d'assistance [ ]

function uniqueArray2(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

Utilisation filter + indexOf

function uniqueArray3(a) {
  function onlyUnique(value, index, self) { 
      return self.indexOf(value) === index;
  }

  // usage
  var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

  return unique;
}

Et je me suis demandé laquelle est la plus rapide. J'ai créé un exemple de feuille Google pour tester les fonctions. Remarque: ECMA 6 n'est pas disponible dans Google Sheets, je ne peux donc pas le tester.

Voici le résultat des tests:

Je m'attendais à voir que le code utilisant l'objet { }gagnera parce qu'il utilise du hachage. Je suis donc heureux que les tests aient montré les meilleurs résultats pour cet algorithme dans Chrome et IE. Merci à @rab pour le code .

Vous pouvez également utiliser underscore.js .

console.log(_.uniq([1, 2, 1, 3, 1, 4]));

<script src="http://underscorejs.org/underscore-min.js"></script>

qui retournera:

[1, 2, 3, 4]

One Liner, Pure JavaScript

Avec la syntaxe ES6

list = list.filter((x, i, a) => a.indexOf(x) == i)

x --> item in array
i --> index of item
a --> array reference, (in this case "list")

Avec la syntaxe ES5

list = list.filter(function (x, i, a) { 
    return a.indexOf(x) == i; 
});

Compatibilité du navigateur : IE9 +

J'ai depuis trouvé une belle méthode qui utilise jQuery

arr = $.grep(arr, function(v, k){
    return $.inArray(v ,arr) === k;
});

Remarque: Ce code a été tiré du poste de frappe de canard de Paul Irish - j'ai oublié de donner le crédit: P

Solution la plus courte avec ES6: [...new Set( [1, 1, 2] )];

Ou si vous souhaitez modifier le prototype Array (comme dans la question d'origine):

Array.prototype.getUnique = function() {
    return [...new Set( [this] )];
};

EcmaScript 6 n'est implémenté que partiellement dans les navigateurs modernes pour le moment (août 2015), mais Babel est devenu très populaire pour repasser ES6 (et même ES7) vers ES5. De cette façon, vous pouvez écrire du code ES6 aujourd'hui!

Si vous vous demandez ce que cela ...signifie, cela s'appelle l' opérateur de propagation . D'après MDN : «L'opérateur d'étalement permet de développer une expression dans des endroits où plusieurs arguments (pour les appels de fonction) ou plusieurs éléments (pour les littéraux de tableau) sont attendus». Parce qu'un ensemble est un itérable (et ne peut avoir que des valeurs uniques), l'opérateur de propagation étendra l'ensemble pour remplir le tableau.

Ressources pour apprendre ES6:

• Explorer ES6 par le Dr Axel Rauschmayer
• Recherchez «ES6» dans les newsletters hebdomadaires de JS
• ES6 en profondeur des articles du blog Mozilla Hacks

Solution la plus simple:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log([...new Set(arr)]);

Ou:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log(Array.from(new Set(arr)));

La façon la plus simple et la plus rapide (dans Chrome) de procéder:

Array.prototype.unique = function() {
    var a = [];
    for (var i=0, l=this.length; i<l; i++)
        if (a.indexOf(this[i]) === -1)
            a.push(this[i]);
    return a;
}

Parcoure simplement chaque élément du tableau, teste si cet élément est déjà dans la liste, et si ce n'est pas le cas, poussez vers le tableau qui est retourné.

Selon jsPerf, cette fonction est la plus rapide de celles que j'ai pu trouver n'importe où - n'hésitez pas à ajouter la vôtre.

La version non prototype:

function uniques(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

Tri

Lorsque vous devez également trier le tableau, ce qui suit est le plus rapide:

Array.prototype.sortUnique = function() {
    this.sort();
    var last_i;
    for (var i=0;i<this.length;i++)
        if ((last_i = this.lastIndexOf(this[i])) !== i)
            this.splice(i+1, last_i-i);
    return this;
}

ou non prototype:

function sortUnique(arr) {
    arr.sort();
    var last_i;
    for (var i=0;i<arr.length;i++)
        if ((last_i = arr.lastIndexOf(arr[i])) !== i)
            arr.splice(i+1, last_i-i);
    return arr;
}

C'est également plus rapide que la méthode ci-dessus dans la plupart des navigateurs non-chrome.

PERFORMANCE UNIQUEMENT! ce code est probablement 10 fois plus rapide que tous les codes ici * fonctionne sur tous les navigateurs et a également l'impact mémoire le plus faible .... et plus

si vous n'avez pas besoin de réutiliser l'ancien tableau; btw effectuer les autres opérations nécessaires avant de le convertir en unique ici est probablement le moyen le plus rapide de le faire, également très court.

var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

alors vous pouvez essayer ceci

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 1];

function toUnique(a, b, c) { //array,placeholder,placeholder
  b = a.length;
  while (c = --b)
    while (c--) a[b] !== a[c] || a.splice(c, 1);
  return a // not needed ;)
}
console.log(toUnique(array));
//[3, 4, 5, 6, 7, 8, 9, 0, 2, 1]

Je suis venu avec cette fonction en lisant cet article ...

http://www.shamasis.net/2009/09/fast-algorithm-to-find-unique-items-in-javascript-array/

Je n'aime pas la boucle for. il a de nombreux paramètres.j'aime la boucle while--. while est la boucle la plus rapide de tous les navigateurs, à l'exception de celle que nous aimons tous tellement ... chrome.

de toute façon j'ai écrit la première fonction qui utilise while.Et oui c'est un peu plus rapide que la fonction trouvée dans l'article.mais pas assez.unique2()

prochaine étape, utilisez js moderne. Object.keys j'ai remplacé l'autre pour la boucle par les Object.keys de js1.7 ... un peu plus rapide et plus court (en chrome 2x plus rapide);). Pas assez!. unique3().

à ce stade, je pensais à ce dont j'avais vraiment besoin dans MA fonction unique. je n'ai pas besoin de l'ancien tableau, je veux une fonction rapide. j'ai donc utilisé 2 while boucles + épissure.unique4()

Inutile de dire que j'ai été impressionné.

chrome: les 150 000 opérations par seconde habituelles sont passées à 1 800 000 opérations par seconde.

soit: 80 000 op / s vs 3 500 000 op / s

ios: 18 000 op / s contre 170 000 op / s

safari: 80 000 op / s vs 6 000 000 op / s

Preuve http://jsperf.com/wgu ou mieux utiliser console.time ... microtime ... peu importe

unique5() est juste pour vous montrer ce qui se passe si vous souhaitez conserver l'ancien tableau.

Ne l'utilisez pas Array.prototypesi vous ne savez pas ce que vous faites. je viens de faire beaucoup de copie et de passé. À utiliser Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})si vous souhaitez créer un prototype natif.exemple : https://stackoverflow.com/a/20463021/2450730

Démo http://jsfiddle.net/46S7g/

REMARQUE: votre ancienne baie est détruite / devient unique après cette opération.

si vous ne pouvez pas lire le code ci-dessus demandez, lisez un livre javascript ou voici quelques explications sur le code plus court. https://stackoverflow.com/a/21353032/2450730

certains utilisent indexOf ... ne pas ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

pour les tableaux vides

!array.length||toUnique(array); 

Beaucoup de réponses ici peuvent ne pas être utiles aux débutants. Si la déduplication d'un tableau est difficile, connaîtront-ils vraiment la chaîne du prototype, ou même jQuery?

Dans les navigateurs modernes, une solution propre et simple consiste à stocker des données dans un ensemble , conçu pour être une liste de valeurs uniques.

const cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
const uniqueCars = Array.from(new Set(cars));

Le Array.fromest utile pour reconvertir l'ensemble en tableau afin que vous ayez un accès facile à toutes les méthodes (fonctionnalités) impressionnantes dont disposent les tableaux. Il existe également d' autres façons de faire la même chose. Mais vous n'aurez peut-être pas besoin Array.fromdu tout, car les ensembles ont de nombreuses fonctionnalités utiles comme forEach .

Si vous devez prendre en charge l'ancien Internet Explorer et ne pouvez donc pas utiliser Set, une technique simple consiste à copier des éléments dans un nouveau tableau tout en vérifiant au préalable s'ils sont déjà dans le nouveau tableau.

// Create a list of cars, with duplicates.
var cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
// Create a list of unique cars, to put a car in if we haven't already.
var uniqueCars = [];

// Go through each car, one at a time.
cars.forEach(function (car) {
    // The code within the following block runs only if the
    // current car does NOT exist in the uniqueCars list
    // - a.k.a. prevent duplicates
    if (uniqueCars.indexOf(car) === -1) {
        // Since we now know we haven't seen this car before,
        // copy it to the end of the uniqueCars list.
        uniqueCars.push(car);
    }
});

Pour le rendre instantanément réutilisable, mettons-le dans une fonction.

function deduplicate(data) {
    if (data.length > 0) {
        var result = [];

        data.forEach(function (elem) {
            if (result.indexOf(elem) === -1) {
                result.push(elem);
            }
        });

        return result;
    }
}

Donc, pour nous débarrasser des doublons, nous le ferions maintenant.

var uniqueCars = deduplicate(cars);

La deduplicate(cars)partie devient la chose que nous avons appelé résultat lorsque la fonction de finalise de.

Passez-lui simplement le nom du tableau que vous aimez.

["Defects", "Total", "Days", "City", "Defects"].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

[0,1,2,0,3,2,1,5].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

Nous pouvons le faire en utilisant des ensembles ES6:

var duplicatedArray = [1, 2, 3, 4, 5, 1, 1, 1, 2, 3, 4];
var uniqueArray = Array.from(new Set(duplicatedArray));

console.log(uniqueArray);

// La sortie sera

uniqueArray = [1,2,3,4,5];

Ce prototype getUniquen'est pas totalement correct, car si j'ai un tableau comme: ["1",1,2,3,4,1,"foo"]il retournera ["1","2","3","4"]et "1"est une chaîne et 1est un entier; ils sont différents.

Voici une bonne solution:

Array.prototype.unique = function(a){
    return function(){ return this.filter(a) }
}(function(a,b,c){ return c.indexOf(a,b+1) < 0 });

en utilisant:

var foo;
foo = ["1",1,2,3,4,1,"foo"];
foo.unique();

Ce qui précède produira ["1",2,3,4,1,"foo"].

Sans étendre Array.prototype (on dit que c'est une mauvaise pratique) ou utiliser jquery / underscore, vous pouvez simplement filterle tableau.

En gardant la dernière occurrence:

    function arrayLastUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps last occurrence
            return c.indexOf(a, b + 1) < 0;
        });
    },

ou première occurrence:

    function arrayFirstUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps first occurrence
            return c.indexOf(a) === b;
        });
    },

Eh bien, c'est seulement javascript ECMAScript 5+, ce qui signifie seulement IE9 +, mais c'est bien pour un développement en HTML / JS natif (Windows Store App, Firefox OS, Sencha, Phonegap, Titanium, ...).

la magie

a.filter(e=>!(t[e]=e in t)) 

O (n) performance ; nous supposons que votre tableau est dans aet t={}. Explication ici (+ Impr . Jeppe )

let t={}, unique= a=> a.filter(e=>!(t[e]=e in t));

// "stand-alone" version working with global t:
// a1.filter((t={},e=>!(t[e]=e in t)));

// Test data
let a1 = [5,6,0,4,9,2,3,5,0,3,4,1,5,4,9];
let a2 = [[2, 17], [2, 17], [2, 17], [1, 12], [5, 9], [1, 12], [6, 2], [1, 12]];
let a3 = ['Mike', 'Adam','Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl'];

// Results
console.log(JSON.stringify( unique(a1) ))
console.log(JSON.stringify( unique(a2) ))
console.log(JSON.stringify( unique(a3) ))

[...new Set(duplicates)]

C'est le plus simple et référencé à partir de MDN Web Docs .

const numbers = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]
console.log([...new Set(numbers)]) // [2, 3, 4, 5, 6, 7, 32]

Si vous utilisez le framework Prototype, il n'est pas nécessaire de faire des boucles 'for', vous pouvez utiliser http://www.prototypejs.org/api/array/uniq comme ceci:

var a = Array.uniq();  

Ce qui produira un tableau en double sans doublons. Je suis tombé sur votre question en cherchant une méthode pour compter les enregistrements de tableaux distincts donc après

uniq ()

j'ai utilisé

Taille()

et il y avait mon résultat simple. ps Désolé si j'ai mal écrit quelque chose

modifier: si vous voulez échapper aux enregistrements non définis, vous pouvez ajouter

compact()

avant, comme ça:

var a = Array.compact().uniq();  

Maintenant, en utilisant des ensembles, vous pouvez supprimer les doublons et les reconvertir en tableau.

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];

console.log([...new Set(names)])

Une autre solution consiste à utiliser le tri et le filtrage

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];
var namesSorted = names.sort();
const result = namesSorted.filter((e, i) => namesSorted[i] != namesSorted[i+1]);
console.log(result);

C'est parce que 0c'est une valeur fausse en JavaScript.

this[i] sera falsifié si la valeur du tableau est 0 ou toute autre valeur falsifiée.

Array.prototype.getUnique = function() {
    var o = {}, a = []
    for (var i = 0; i < this.length; i++) o[this[i]] = 1
    for (var e in o) a.push(e)
    return a
}

J'ai eu un problème légèrement différent où j'avais besoin de supprimer des objets avec des propriétés d'ID en double d'un tableau. cela a fonctionné.

let objArr = [{
  id: '123'
}, {
  id: '123'
}, {
  id: '456'
}];

objArr = objArr.reduce((acc, cur) => [
  ...acc.filter((obj) => obj.id !== cur.id), cur
], []);

console.log(objArr);

La réponse la plus simple est:

const array = [1, 1, 2, 2, 3, 5, 5, 2];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // [1, 2, 3, 5]

Je ne sais pas pourquoi Gabriel Silveira a écrit la fonction de cette façon, mais une forme plus simple qui fonctionne aussi bien pour moi et sans la minification est:

Array.prototype.unique = function() {
  return this.filter(function(value, index, array) {
    return array.indexOf(value, index + 1) < 0;
  });
};

ou en CoffeeScript:

Array.prototype.unique = ->
  this.filter( (value, index, array) ->
    array.indexOf(value, index + 1) < 0
  )

Si vous êtes d'accord avec des dépendances supplémentaires, ou si vous avez déjà l'une des bibliothèques dans votre base de code, vous pouvez supprimer les doublons d'un tableau en place à l'aide de LoDash (ou Underscore).

Usage

Si vous ne l'avez pas déjà dans votre base de code, installez-le à l'aide de npm:

npm install lodash

Ensuite, utilisez-le comme suit:

import _ from 'lodash';
let idArray = _.uniq ([
    1,
    2,
    3,
    3,
    3
]);
console.dir(idArray);

En dehors:

[ 1, 2, 3 ]

On y a beaucoup répondu, mais cela n'a pas répondu à mon besoin particulier.

De nombreuses réponses sont comme ceci:

a.filter((item, pos, self) => self.indexOf(item) === pos);

Mais cela ne fonctionne pas pour les tableaux d'objets complexes.

Disons que nous avons un tableau comme celui-ci:

const a = [
 { age: 4, name: 'fluffy' },
 { age: 5, name: 'spot' },
 { age: 2, name: 'fluffy' },
 { age: 3, name: 'toby' },
];

Si nous voulons que les objets avec des noms uniques, nous devons utiliser à la array.prototype.findIndexplace de array.prototype.indexOf:

a.filter((item, pos, self) => self.findIndex(v => v.name === item.name) === pos);

De Shamasis Bhattacharya blog de (O (2n) la complexité du temps):

Array.prototype.unique = function() {
    var o = {}, i, l = this.length, r = [];
    for(i=0; i<l;i+=1) o[this[i]] = this[i];
    for(i in o) r.push(o[i]);
    return r;
};

Du blog de Paul Irish : amélioration sur JQuery .unique():

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

// in use..
var arr = ['first',7,true,2,7,true,'last','last'];
$.unique(arr); // ["first", 7, true, 2, "last"]

var arr = [1,2,3,4,5,4,3,2,1];
$.unique(arr); // [1, 2, 3, 4, 5]

Trouver des valeurs de tableau uniques dans une méthode simple

function arrUnique(a){
  var t = [];
  for(var x = 0; x < a.length; x++){
    if(t.indexOf(a[x]) == -1)t.push(a[x]);
  }
  return t;
}
arrUnique([1,4,2,7,1,5,9,2,4,7,2]) // [1, 4, 2, 7, 5, 9]

Il semble que nous ayons perdu la réponse de Rafael , qui a été la réponse acceptée pendant quelques années. C'était (au moins en 2017) la solution la plus performante si vous n'avez pas de tableau de type mixte :

Array.prototype.getUnique = function(){
    var u = {}, a = [];
    for (var i = 0, l = this.length; i < l; ++i) {
        if (u.hasOwnProperty(this[i])) {
            continue;
        }
        a.push(this[i]);
        u[this[i]] = 1;
    }
return a;
}

Si vous n'avez un tableau de type mixte, vous pouvez sérialiser la clé de hachage:

Array.prototype.getUnique = function() {
    var hash = {}, result = [], key; 
    for ( var i = 0, l = this.length; i < l; ++i ) {
        key = JSON.stringify(this[i]);
        if ( !hash.hasOwnProperty(key) ) {
            hash[key] = true;
            result.push(this[i]);
        }
    }
    return result;
}

Pour résoudre le problème dans l'autre sens, il peut être utile de ne pas avoir de doublon pendant le chargement de votre tableau, comme le ferait l'objet Set, mais il n'est pas encore disponible dans tous les navigateurs. Il économise de la mémoire et est plus efficace si vous avez besoin de regarder son contenu plusieurs fois.

Array.prototype.add = function (elem) {
   if (this.indexOf(elem) == -1) {
      this.push(elem);
   }
}

Échantillon:

set = [];
[1,3,4,1,2,1,3,3,4,1].forEach(function(x) { set.add(x); });

Vous donne set = [1,3,4,2]