J'ai besoin de vérifier un tableau JavaScript pour voir s'il y a des valeurs en double. Quelle est la façon la plus simple de procéder? J'ai juste besoin de trouver quelles sont les valeurs dupliquées - je n'ai pas réellement besoin de leurs index ou combien de fois elles sont dupliquées.

Je sais que je peux parcourir le tableau et vérifier toutes les autres valeurs pour une correspondance, mais il semble qu'il devrait y avoir un moyen plus simple.

Question similaire:

• Obtenez toutes les valeurs uniques dans un tableau JavaScript (supprimez les doublons)

Vous pouvez trier le tableau, puis le parcourir et voir si l'index suivant (ou précédent) est le même que l'actuel. En supposant que votre algorithme de tri est bon, il devrait être inférieur à O (n ² ):

const findDuplicates = (arr) => {
  let sorted_arr = arr.slice().sort(); // You can define the comparing function here. 
  // JS by default uses a crappy string compare.
  // (we use slice to clone the array so the
  // original array won't be modified)
  let results = [];
  for (let i = 0; i < sorted_arr.length - 1; i++) {
    if (sorted_arr[i + 1] == sorted_arr[i]) {
      results.push(sorted_arr[i]);
    }
  }
  return results;
}

let duplicatedArray = [9, 9, 111, 2, 3, 4, 4, 5, 7];
console.log(`The duplicates in ${duplicatedArray} are ${findDuplicates(duplicatedArray)}`);

Dans le cas, si vous devez retourner en tant que fonction pour les doublons. C'est pour un type de cas similaire.

Référence: https://stackoverflow.com/a/57532964/8119511

Si vous souhaitez éliminer les doublons, essayez cette excellente solution:

function eliminateDuplicates(arr) {
  var i,
      len = arr.length,
      out = [],
      obj = {};

  for (i = 0; i < len; i++) {
    obj[arr[i]] = 0;
  }
  for (i in obj) {
    out.push(i);
  }
  return out;
}

Source: http://dreaminginjavascript.wordpress.com/2008/08/22/iminating-duplicates/

Voici ma réponse du fil en double (!):

Lors de l'écriture de cette entrée 2014 - tous les exemples étaient des boucles for ou jQuery. Javascript a les outils parfaits pour cela: trier, mapper et réduire.

Rechercher des éléments en double

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

var uniq = names
  .map((name) => {
    return {
      count: 1,
      name: name
    }
  })
  .reduce((a, b) => {
    a[b.name] = (a[b.name] || 0) + b.count
    return a
  }, {})

var duplicates = Object.keys(uniq).filter((a) => uniq[a] > 1)

console.log(duplicates) // [ 'Nancy' ]

Syntaxe plus fonctionnelle:

@ Dmytro-Laptin a souligné que certains codes étaient supprimés. Il s'agit d'une version plus compacte du même code. Utilisation de quelques astuces ES6 et de fonctions d'ordre supérieur:

const names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']

const count = names =>
  names.reduce((a, b) => ({ ...a,
    [b]: (a[b] || 0) + 1
  }), {}) // don't forget to initialize the accumulator

const duplicates = dict =>
  Object.keys(dict).filter((a) => dict[a] > 1)

console.log(count(names)) // { Mike: 1, Matt: 1, Nancy: 2, Adam: 1, Jenny: 1, Carl: 1 }
console.log(duplicates(count(names))) // [ 'Nancy' ]

Rechercher des valeurs en double dans un tableau

Cela devrait être l'un des moyens les plus courts de trouver des valeurs en double dans un tableau. Comme spécifiquement demandé par le PO, cela ne supprime pas les doublons mais les trouve .

var input = [1, 2, 3, 1, 3, 1];

var duplicates = input.reduce(function(acc, el, i, arr) {
  if (arr.indexOf(el) !== i && acc.indexOf(el) < 0) acc.push(el); return acc;
}, []);

document.write(duplicates); // = 1,3 (actual array == [1, 3])

Cela n'a pas besoin de tri ni de cadre tiers. Il n'a pas non plus besoin de boucles manuelles. Il fonctionne avec toutes les valeurs prises en charge par indexOf () (ou pour être plus clair: l' opérateur de comparaison strict ).

En raison de Reduce () et indexOf (), il nécessite au moins IE 9.

Vous pouvez ajouter cette fonction, ou la modifier et l'ajouter au prototype de tableau de Javascript:

Array.prototype.unique = function () {
    var r = new Array();
    o:for(var i = 0, n = this.length; i < n; i++)
    {
        for(var x = 0, y = r.length; x < y; x++)
        {
            if(r[x]==this[i])
            {
                alert('this is a DUPE!');
                continue o;
            }
        }
        r[r.length] = this[i];
    }
    return r;
}

var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,9];
var unique = arr.unique();
alert(unique);

MISE À JOUR: Ce qui suit utilise une stratégie combinée optimisée. Il optimise les recherches de primitives pour bénéficier du temps de recherche de hachage O (1) (l'exécution uniquesur un tableau de primitives est O (n)). Les recherches d'objets sont optimisées en étiquetant les objets avec un identifiant unique lors de l'itération, de sorte que l'identification des objets en double est également O (1) par élément et O (n) pour toute la liste. La seule exception concerne les éléments gelés, mais ceux-ci sont rares et une solution de secours est fournie à l'aide d'un tableau et d'un indexOf.

var unique = function(){
  var hasOwn = {}.hasOwnProperty,
      toString = {}.toString,
      uids = {};

  function uid(){
    var key = Math.random().toString(36).slice(2);
    return key in uids ? uid() : uids[key] = key;
  }

  function unique(array){
    var strings = {}, numbers = {}, others = {},
        tagged = [], failed = [],
        count = 0, i = array.length,
        item, type;

    var id = uid();

    while (i--) {
      item = array[i];
      type = typeof item;
      if (item == null || type !== 'object' && type !== 'function') {
        // primitive
        switch (type) {
          case 'string': strings[item] = true; break;
          case 'number': numbers[item] = true; break;
          default: others[item] = item; break;
        }
      } else {
        // object
        if (!hasOwn.call(item, id)) {
          try {
            item[id] = true;
            tagged[count++] = item;
          } catch (e){
            if (failed.indexOf(item) === -1)
              failed[failed.length] = item;
          }
        }
      }
    }

    // remove the tags
    while (count--)
      delete tagged[count][id];

    tagged = tagged.concat(failed);
    count = tagged.length;

    // append primitives to results
    for (i in strings)
      if (hasOwn.call(strings, i))
        tagged[count++] = i;

    for (i in numbers)
      if (hasOwn.call(numbers, i))
        tagged[count++] = +i;

    for (i in others)
      if (hasOwn.call(others, i))
        tagged[count++] = others[i];

    return tagged;
  }

  return unique;
}();

Si vous avez des collections ES6 disponibles, il existe une version beaucoup plus simple et beaucoup plus rapide. (shim pour IE9 + et autres navigateurs ici: https://github.com/Benvie/ES6-Harmony-Collections-Shim )

function unique(array){
  var seen = new Set;
  return array.filter(function(item){
    if (!seen.has(item)) {
      seen.add(item);
      return true;
    }
  });
}

MISE À JOUR: Short one-liner pour obtenir les doublons:

[1, 2, 2, 4, 3, 4].filter((e, i, a) => a.indexOf(e) !== i) // [2, 4]

Pour obtenir le tableau sans doublons, inversez simplement la condition:

[1, 2, 2, 4, 3, 4].filter((e, i, a) => a.indexOf(e) === i) // [1, 2, 3, 4]

Je n'y pensais tout simplement pas filter()dans mon ancienne réponse ci-dessous;)

Lorsque tout ce dont vous avez besoin est de vérifier qu'il n'y a pas de doublons comme demandé dans cette question, vous pouvez utiliser la every()méthode:

[1, 2, 3].every((e, i, a) => a.indexOf(e) === i) // true

[1, 2, 1].every((e, i, a) => a.indexOf(e) === i) // false

Notez que every()cela ne fonctionne pas pour IE 8 et les versions antérieures.

var a = ["a","a","b","c","c"];

a.filter(function(value,index,self){ return (self.indexOf(value) !== index )})

Cela devrait vous procurer ce que vous voulez, juste les doublons.

function find_duplicates(arr) {
  var len=arr.length,
      out=[],
      counts={};

  for (var i=0;i<len;i++) {
    var item = arr[i];
    counts[item] = counts[item] >= 1 ? counts[item] + 1 : 1;
    if (counts[item] === 2) {
      out.push(item);
    }
  }

  return out;
}

find_duplicates(['one',2,3,4,4,4,5,6,7,7,7,'pig','one']); // -> ['one',4,7] in no particular order.

en utilisant underscore.js

function hasDuplicate(arr){
    return (arr.length != _.uniq(arr).length);
}

ES2015

//          🚩🚩   🚩                 🚩 
var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,22],
    arr2 = [1,2,511,12,50],
    arr3 = [22],
    unique;

// Combine all the arrays to a single one
unique = arr.concat(arr2, arr3)

// create a new (dirty) Array with only the unique items
unique = unique.map((item,i) => unique.includes(item, i+1) ? item : '' )

// Cleanup - remove duplicate & empty items items 
unique = [...new Set(unique)].filter(n => n)

console.log(unique)

Trouvez des valeurs uniques à partir de 3 tableaux (ou plus):

Array.prototype.unique = function () {
    var arr = this.sort(), i; // input must be sorted for this to work
    for( i=arr.length; i--; )
      arr[i] === arr[i-1] && arr.splice(i,1); // remove duplicate item

    return arr;
}

var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,9],
    arr2 = [1,2,511,12,50],
    arr3 = [22],
    // merge arrays & call custom Array Prototype - "unique"
    unique = arr.concat(arr2, arr3).unique();

console.log(unique);  // [22, 50, 12, 511, 2, 1, 9, 5, 8, 7, 3, 6, 4]

Juste un polyfill pour array indexOf pour les anciens navigateurs:

if (!Array.prototype.indexOf){
   Array.prototype.indexOf = function(elt /*, from*/){
     var len = this.length >>> 0;

     var from = Number(arguments[1]) || 0;
     from = (from < 0) ? Math.ceil(from) : Math.floor(from);
     if (from < 0)
        from += len;

     for (; from < len; from++){
        if (from in this && this[from] === elt)
           return from;
     }
     return -1;
  };
}

Solution jQuery utilisant "inArray":

if( $.inArray(this[i], arr) == -1 )

au lieu d'ajouter le Array.prototype.indexOf

Voici la mienne simple et une solution en ligne.

Il recherche d'abord les éléments non uniques, puis rend le tableau trouvé unique avec l'utilisation de Set.

Nous avons donc un tableau de doublons à la fin.

var array = [1, 2, 2, 3, 3, 4, 5, 6, 2, 3, 7, 8, 5, 22, 1, 2, 511, 12, 50, 22];

console.log([...new Set(
  array.filter((value, index, self) => self.indexOf(value) !== index))]
);

Voici ma proposition (ES6):

let a = [1, 2, 3, 4, 2, 2, 4, 1, 5, 6]
let b = [...new Set(a.sort().filter((o, i) => o !== undefined && a[i + 1] !== undefined && o === a[i + 1]))]

// b is now [1, 2, 4]

var a = [324,3,32,5,52,2100,1,20,2,3,3,2,2,2,1,1,1].sort();
a.filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});

ou lorsqu'il est ajouté à la chaîne prototyp de Array

//copy and paste: without error handling
Array.prototype.unique = 
   function(){return this.sort().filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});}

Voir ici: https://gist.github.com/1305056

Manière rapide et élégante utilisant la déstructuration d'objet es6 et réduisez

Il s'exécute en O (n) (1 itération sur le tableau) et ne répète pas les valeurs qui apparaissent plus de 2 fois

const arr = ['hi', 'hi', 'hi', 'bye', 'bye', 'asd']
const {
  dup
} = arr.reduce(
  (acc, curr) => {
    acc.items[curr] = acc.items[curr] ? acc.items[curr] += 1 : 1
    if (acc.items[curr] === 2) acc.dup.push(curr)
    return acc
  }, {
    items: {},
    dup: []
  },
)

console.log(dup)
// ['hi', 'bye']

Voici la solution la plus simple à laquelle j'ai pu penser:

    const arr = [-1, 2, 2, 2, 0, 0, 0, 500, -1, 'a', 'a', 'a']

    const filtered = arr.filter((el, index) => arr.indexOf(el) !== index)
    // => filtered = [ 2, 2, 0, 0, -1, 'a', 'a' ]

    const duplicates = [...new Set(filtered)]

    console.log(duplicates)
    // => [ 2, 0, -1, 'a' ]

C'est ça.

Remarque:

1. Il fonctionne avec tous les nombres, y compris les 0chaînes et les nombres négatifs, par exemple -1- Question connexe: Obtenez toutes les valeurs uniques dans un tableau JavaScript (supprimez les doublons)

2. Le tableau d'origine arrest conservé ( filterrenvoie le nouveau tableau au lieu de modifier l'original)

3. Le filteredtableau contient tous les doublons; il peut également contenir plus d'une même valeur (par exemple, notre tableau filtré est ici [ 2, 2, 0, 0, -1, 'a', 'a' ])

4. Si vous souhaitez obtenir uniquement des valeurs dupliquées (vous ne voulez pas avoir plusieurs doublons avec la même valeur), vous pouvez utiliser [...new Set(filtered)](ES6 a un ensemble d' objets qui ne peut stocker que des valeurs uniques)

J'espère que cela t'aides.

Vanille JS la plus courte :

[1,1,2,2,2,3].filter((v,i,a) => a.indexOf(v) !== i) // [1, 2, 2]

Voici un moyen très léger et simple:

var codes = dc_1.split(',');
var i = codes.length;
while (i--) {
  if (codes.indexOf(codes[i]) != i) {
    codes.splice(i,1);
  }
}

Avec ES6 (ou en utilisant Babel ou Typescipt), vous pouvez simplement faire:

var duplicates = myArray.filter(i => myArray.filter(ii => ii === i).length > 1);

https://es6console.com/j58euhbt/

Code simple avec syntaxe ES6 (retournez un tableau trié de doublons):

let duplicates = a => {d=[]; a.sort((a,b) => a-b).reduce((a,b)=>{a==b&&!d.includes(a)&&d.push(a); return b}); return d};

Comment utiliser:

duplicates([1,2,3,10,10,2,3,3,10]);

bon mot

var arr = [9,1,2,4,3,4,9]
console.log(arr.filter((ele,indx)=>indx!==arr.indexOf(ele))) //get the duplicates
console.log(arr.filter((ele,indx)=>indx===arr.indexOf(ele))) //remove the duplicates

Cette réponse peut également être utile, elle exploite l' reduce opérateur / méthode js pour supprimer les doublons du tableau.

const result = [1, 2, 2, 3, 3, 3, 3].reduce((x, y) => x.includes(y) ? x : [...x, y], []);

console.log(result);

La fonction suivante (une variation de la fonction éliminer les doublons déjà mentionnée) semble faire l'affaire, renvoyant test2,1,7,5 pour l'entrée ["test", "test2", "test2", 1, 1, 1, 2 , 3, 4, 5, 6, 7, 7, 10, 22, 43, 1, 5, 8]

Notez que le problème est plus étrange en JavaScript que dans la plupart des autres langues, car un tableau JavaScript peut contenir à peu près n'importe quoi. Notez que les solutions qui utilisent le tri peuvent avoir besoin de fournir une fonction de tri appropriée - je n'ai pas encore essayé cette route.

Cette implémentation particulière fonctionne pour (au moins) les chaînes et les nombres.

function findDuplicates(arr) {
    var i,
        len=arr.length,
        out=[],
        obj={};

    for (i=0;i<len;i++) {
        if (obj[arr[i]] != null) {
            if (!obj[arr[i]]) {
                out.push(arr[i]);
                obj[arr[i]] = 1;
            }
        } else {
            obj[arr[i]] = 0;            
        }
    }
    return out;
}

ES5 uniquement (c'est-à-dire qu'il a besoin d'un polyfill filter () pour IE8 et inférieur):

var arrayToFilter = [ 4, 5, 5, 5, 2, 1, 3, 1, 1, 2, 1, 3 ];

arrayToFilter.
    sort().
    filter( function(me,i,arr){
       return (i===0) || ( me !== arr[i-1] );
    });

var arr = [2, 1, 2, 2, 4, 4, 2, 5];

function returnDuplicates(arr) {
  return arr.reduce(function(dupes, val, i) {
    if (arr.indexOf(val) !== i && dupes.indexOf(val) === -1) {
      dupes.push(val);
    }
    return dupes;
  }, []);
}

alert(returnDuplicates(arr));

Cette fonction évite l'étape de tri et utilise la méthode Reduce () pour pousser les doublons vers un nouveau tableau s'il n'y existe pas déjà.

C'est probablement l'un des moyens les plus rapides pour supprimer définitivement les doublons d'un tableau 10 fois plus vite que la plupart des fonctions ici. 78 fois plus rapide en safari

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

1. Test: http://jsperf.com/wgu
2. Démo: http://jsfiddle.net/46S7g/
3. Plus: https://stackoverflow.com/a/25082874/2450730

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

EDIT Comme indiqué dans les commentaires, cette fonction retourne un tableau avec des uniques, la question demande cependant de trouver les doublons. dans ce cas, une simple modification de cette fonction permet de pousser les doublons dans un tableau, puis l'utilisation de la fonction précédente toUniquesupprime les doublons des doublons.

function theDuplicates(a,b,c,d){//array,placeholder,placeholder
 b=a.length,d=[];
 while(c=--b)while(c--)a[b]!==a[c]||d.push(a.splice(c,1))
}
var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

toUnique(theDuplicates(array));

Utiliser "comprend" pour tester si l'élément existe déjà.

var arr = [1, 1, 4, 5, 5], darr = [], duplicates = [];

for(var i = 0; i < arr.length; i++){
  if(darr.includes(arr[i]) && !duplicates.includes(arr[i]))
    duplicates.push(arr[i])
  else
    darr.push(arr[i]);
}

console.log(duplicates);

<h3>Array with duplicates</h3>
<p>[1, 1, 4, 5, 5]</p>
<h3>Array with distinct elements</h3>
<p>[1, 4, 5]</p>
<h3>duplicate values are</h3>
<p>[1, 5]</p>

ES6 offre la structure de données Set qui est essentiellement un tableau qui n'accepte pas les doublons. Avec la structure de données Set, il existe un moyen très simple de trouver des doublons dans un tableau (en utilisant une seule boucle).

Voici mon code

function findDuplicate(arr) {
var set = new Set();
var duplicates = new Set();
  for (let i = 0; i< arr.length; i++) {
     var size = set.size;
     set.add(arr[i]);
     if (set.size === size) {
         duplicates.add(arr[i]);
     }
  }
 return duplicates;
}

Je viens de trouver un moyen simple d'y parvenir en utilisant un filtre matriciel

    var list = [9, 9, 111, 2, 3, 4, 4, 5, 7];
    
    // Filter 1: to find all duplicates elements
    var duplicates = list.filter(function(value,index,self) {
       return self.indexOf(value) !== self.lastIndexOf(value) && self.indexOf(value) === index;
    });
    
    console.log(duplicates);

La logique suivante sera plus facile et plus rapide

// @Param:data:Array that is the source 
// @Return : Array that have the duplicate entries
findDuplicates(data: Array<any>): Array<any> {
        return Array.from(new Set(data)).filter((value) => data.indexOf(value) !== data.lastIndexOf(value));
      }

Avantages:

1. Ligne unique :-P
2. Toutes les structures de données intégrées aident à améliorer l'efficacité
3. plus rapide

Description de la logique:

1. Conversion en ensemble pour supprimer tous les doublons
2. Itération à travers les valeurs définies
3. Avec chaque valeur définie, vérifiez dans le tableau source la condition "les valeurs du premier index ne sont pas égales au dernier index" ==> Puis déduit comme doublon sinon il est "unique"

Remarque: les méthodes map () et filter () sont efficaces et plus rapides.