Javascript – Supprime les éléments uniques de Array

Avec ES6, vous pouvez utiliser une Array#map et compter les valeurs avec Array#forEach .

Utilisez plus tard le Array#filter check et vérifiez le nombre.

Si plus de 1 retourne true (inclure l'élément dans le jeu de résultats), sinon renvoyez false (n'incluez pas l'élément dans le jeu de résultats).

 function getNotUnique(array) { var map = new Map(); array.forEach(a => map.set(a, (map.get(a) || 0) + 1)); return array.filter(a => map.get(a) > 1); } console.log(getNotUnique([1, 2, 2, 4, 4])); console.log(getNotUnique([1, 2, 3] )); 

Ci-dessous est simple et facile à comprendre pour supprimer des éléments uniques du tableau.

 function removeUnique(arr) { var newArr = []; for (var i = 0; i < arr.length; i++) { var count = 0; for (var j = 0; j < arr.length; j++) { if (arr[j] == arr[i]) { count++; } } if (count >= 2) { newArr.push(arr[i]); } } return newArr; } console.log(removeUnique([1, 2, 2, 4, 4])); 

Voici une implémentation (en utilisant https://stackoverflow.com/a/5668029/4202031 )

 function removeUnique(arr) { var counts = {} for(var i = 0; i< arr.length; i++) { var num = arr[i] counts[num] = counts[num] ? counts[num]+1 : 1 } var result = [] for(var key in counts) { if(Object.prototype.hasOwnProperty.call(counts, key) && counts[key] > 1 { result.push(key) } } return result } var arr = [1, 2, 3] var arr2 = [1, 1, 2, 2, 4, 6, 4] console.log(removeUnique(arr)) // [] console.log(removeUnique(arr2)) // [ '1', '2', '4' ] 

Vous pourriez faire quelque chose comme ça (en utilisant strictement les tableaux):

 var arr = [1,2,3,4,4]; var temp = []; var to_keep = []; for(var x = 0; x < arr.length; x++){ if(temp.indexOf(arr[x]) > -1) { if(to_keep.indexOf(arr[x]) == -1) to_keep.push(arr[x]); } else if(temp.indexOf(arr[x]) == -1) temp.push(arr[x]); } for(var y = 0; y < arr.length; y++){ if(to_keep.indexOf(arr[y]) == -1){ arr.splice(y,1); y--; } } // arr = [4,4]; 

 var arr = [1, 2, 2, 4, 4] var dict_with_count = {} for (var i=0; i<arr.length; i++){ dict_with_count[arr[i]] = 0 } for (var i=0; i<arr.length; i++){ dict_with_count[arr[i]] += 1 } var new_list = []; for (key in dict_with_count){ if (dict_with_count[key] > 1){ for (var j=0; j<dict_with_count[key]; j++){ new_list.push(key) } } } console.log(new_list) 

Iterate à travers le tableau, utilisez la valeur en tant qu'indice dans un objet et augmente pour chaque occurrence dans l'original. Ensuite, iterate à travers l'objet et extraire ceux avec des totaux supérieurs à un. Doit fonctionner pour les chaînes et les types numériques.

 function dupsOnly(a) { var T = {}; for (var i = 0; i < a.length; i++) { if (a[i] in T) T[a[i]] += 1; else T[a[i]] = 1; } var D = []; for (var t in T) { if (T[t] > 1) D.push(t); while (T[t] > 1) { T[t] -= 1; D.push(t); } } return D; } 

Cela devrait le faire;

 var arr = [1, 2, 2, 4, 4], unq = arr.map((e,i,a) => a.filter(f => f === e ).length) .reduce((p,c,i) => c === 1 ? p : p.concat(arr[i]) ,[]); console.log(unq); 

C'est une question ancienne, mais la façon standard dans ES6 devrait être d'utiliser un ensemble :

 const unique_values = [...new Set([1, 2, 2, 4, 4])] >>> [1, 2, 4] 

Un ensemble est une structure de données conçue pour contenir uniquement des valeurs uniques et est la norme dans la plupart des langues. Dans l'extrait ci-dessus, j'ai utilisé l' opérateur de propagation pour construire un nouveau tableau à partir du contenu de l'ensemble.

Notez que Set interne utilise l'opérateur === , donc l'application de cette collection pour une collection d'objets ou de tableaux imbriqués ne fonctionnera pas, car ceux-ci sont comparés par référence.

Cependant, une collection de types primitifs fonctionne très bien avec Set .