En Javascript, comment vérifier si un tableau a des valeurs dupliquées ?

Question

Duplicata possible :
La façon la plus simple de trouver des valeurs dupliquées dans un tableau javascript

Comment vérifier si un tableau a des valeurs dupliquées ?

Si certains éléments du tableau sont identiques, il faut renvoyer true. Sinon, il renvoie false.

['hello','goodbye','hey'] //return false because no duplicates exist
['hello','goodbye','hello'] // return true because duplicates exist

Notez que je ne me soucie pas de trouver les doublons, je veux seulement un résultat booléen pour savoir si les tableaux contiennent des doublons.

Answer 1

Si vous avez un environnement ES2015 (à ce jour : io.js, IE11, Chrome, Firefox, WebKit nightly), alors ce qui suit fonctionnera, et sera rapide (c'est-à-dire O(n)) :

function hasDuplicates(array) {
    return (new Set(array)).size !== array.length;
}

---

Si vous n'avez besoin que de valeurs de type chaîne de caractères dans le tableau, la procédure suivante fonctionnera :

function hasDuplicates(array) {
    var valuesSoFar = Object.create(null);
    for (var i = 0; i < array.length; ++i) {
        var value = array[i];
        if (value in valuesSoFar) {
            return true;
        }
        valuesSoFar[value] = true;
    }
    return false;
}

Nous utilisons une "table de hachage" valuesSoFar dont les clés sont les valeurs que nous avons vues dans le tableau jusqu'à présent. Nous effectuons une recherche en utilisant in pour voir si cette valeur a déjà été repérée ; si c'est le cas, nous sortons de la boucle et renvoyons true .

---

Si vous avez besoin d'une fonction qui fonctionne pour des valeurs autres que des chaînes de caractères, la fonction suivante fonctionnera, mais n'est pas aussi performante ; elle est O(n 2 ) au lieu de O(n).

function hasDuplicates(array) {
    var valuesSoFar = [];
    for (var i = 0; i < array.length; ++i) {
        var value = array[i];
        if (valuesSoFar.indexOf(value) !== -1) {
            return true;
        }
        valuesSoFar.push(value);
    }
    return false;
}

La différence réside simplement dans le fait que nous utilisons un tableau au lieu d'une table de hachage pour la fonction valuesSoFar Les "tables de hachage" JavaScript (c'est-à-dire les objets) n'ont que des clés de type chaîne de caractères. Cela signifie que nous perdons le temps de recherche O(1) de in au lieu d'obtenir un temps de recherche O(n) de indexOf .

Answer 2

Vous pouvez utiliser SET pour supprimer les doublons et comparer. Si vous copiez le tableau dans un set, les doublons seront supprimés. Il suffit ensuite de comparer la longueur du tableau à la taille de l'ensemble.

function hasDuplicates(a) {

  const noDups = new Set(a);

  return a.length !== noDups.size;
}

Answer 3

Solutions en une ligne avec ES6

const arr1 = ['hello','goodbye','hey'] 
const arr2 = ['hello','goodbye','hello'] 

const hasDuplicates = (arr) => arr.length !== new Set(arr).size;
console.log(hasDuplicates(arr1)) //return false because no duplicates exist
console.log(hasDuplicates(arr2)) //return true because duplicates exist

const s1 = ['hello','goodbye','hey'].some((e, i, arr) => arr.indexOf(e) !== i)
const s2 = ['hello','goodbye','hello'].some((e, i, arr) => arr.indexOf(e) !== i);

console.log(s1) //return false because no duplicates exist
console.log(s2) //return true because duplicates exist

Answer 4

Une autre approche (également pour les éléments d'objets/de tableaux à l'intérieur du tableau 1 ) pourrait être 2 :

function chkDuplicates(arr,justCheck){
  var len = arr.length, tmp = {}, arrtmp = arr.slice(), dupes = [];
  arrtmp.sort();
  while(len--){
   var val = arrtmp[len];
   if (/nul|nan|infini/i.test(String(val))){
     val = String(val);
    }
    if (tmp[JSON.stringify(val)]){
       if (justCheck) {return true;}
       dupes.push(val);
    }
    tmp[JSON.stringify(val)] = true;
  }
  return justCheck ? false : dupes.length ? dupes : null;
}
//usages
chkDuplicates([1,2,3,4,5],true);                           //=> false
chkDuplicates([1,2,3,4,5,9,10,5,1,2],true);                //=> true
chkDuplicates([{a:1,b:2},1,2,3,4,{a:1,b:2},[1,2,3]],true); //=> true
chkDuplicates([null,1,2,3,4,{a:1,b:2},NaN],true);          //=> false
chkDuplicates([1,2,3,4,5,1,2]);                            //=> [1,2]
chkDuplicates([1,2,3,4,5]);                                //=> null

Voir aussi...

1 a besoin d'un navigateur qui prend en charge JSON, ou d'un navigateur de type Bibliothèque JSON si ce n'est pas le cas.
2 éditer : peut maintenant être utilisée pour une simple vérification ou pour renvoyer un tableau de valeurs dupliquées.

Answer 5

Vous pouvez bénéficier de indexOf et lastIndexOf Si les deux index sont différents, vous avez un doublon.

function containsDuplicates(a) {
  for (let i = 0; i < a.length; i++) {
    if (a.indexOf(a[i]) !== a.lastIndexOf(a[i])) {
      return true
    }
  }
  return false
}