Obtenir toutes les valeurs non uniques (à savoir: dupliquer/plusieurs occurrences) dans un tableau
J'ai besoin de vérifier un tableau JavaScript pour voir s'il existe des valeurs en double. Quelle est la façon la plus simple de faire cela? J'ai juste besoin de trouver quelles sont les valeurs dupliquées - je n'ai pas réellement besoin de leurs index ni combien de fois elles sont dupliquées.
Je sais que je peux parcourir le tableau et vérifier toutes les autres valeurs d'une correspondance, mais il semble qu'il devrait y avoir un moyen plus simple. Des idées? Merci!
Question similaire:
Vous pouvez trier le tableau, le parcourir et voir si l'index suivant (ou précédent) est identique à l'index actuel. En supposant que votre algorithme de tri soit bon, il devrait être inférieur à O (n2):
var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7];
var 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)
var results = [];
for (var i = 0; i < sorted_arr.length - 1; i++) {
if (sorted_arr[i + 1] == sorted_arr[i]) {
results.Push(sorted_arr[i]);
}
}
console.log(results);Si vous voulez é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 de discussion en double (!):
J'en ai assez de voir tous les mauvais exemples avec des boucles for-loop ou jQuery Javascript dispose des outils parfaits pour cela: trier, cartographier et réduire.
Trouver des objets 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 signalé que du code était supprimé. Ceci est une version plus compacte du même code. Utilisation de quelques astuces de l'ES6 et de fonctions d'ordre supérieur:
const names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']
const count = names =>
names.reduce((a, b) =>
Object.assign(a, {[b]: (a[b] || 0) + 1}), {})
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' ]
Utilisation de Function.prototype.bind:
// prep
const arr = Array.from('Learn more javascript dude');
const counter = (prev, next) => Object.assign(prev, { [next] : (prev[next] || 0) + 1 });
const singles = function(key){ return this[key] === 1 };
const multiples = function(key){ return this[key] > 1 };
// work
const counted = arr.reduce(counter, {});
const filtered = Object.keys(counted).filter(multiples.bind(counted));
//[ "e", "a", "r", " ", "d" ]
console.log(filtered);
Trouver des valeurs en double dans un tableau
Cela devrait être l’un des moyens les plus rapides de rechercher des valeurs en double dans un tableau. Comme demandé spécifiquement par l'OP, 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 ne nécessite pas de tri ou de tout cadre tiers. Il n'a pas non plus besoin de boucles manuelles. Cela fonctionne avec chaque valeur indexOf () (ou pour être plus clair: le opérateur de comparaison stricte ) prend en charge.
En raison de réduire () _ et indexOf () , il faut au moins IE 9.
Vous pouvez ajouter cette fonction ou la modifier et l'ajouter au prototype Array 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 tirer parti du temps de recherche hash O(1) (l'exécution de unique sur un tableau de primitives vaut O (n)). Les recherches d'objet sont optimisées en balisant les objets avec un identifiant unique tout en effectuant une itération. L'identification des objets en double est donc également O(1) par élément et O(n) pour toute la liste. La seule exception concerne les éléments gelés, mais ils sont rares et une solution de secours est fournie à l'aide d'un tableau et d'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 nettement plus rapide. (shim pour IE9 + et les 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;
}
});
}
Cela devrait vous donner 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.
var a = ["a","a","b","c","c"];
a.filter(function(value,index,self){ return (self.indexOf(value) !== index )})
en utilisant underscore.js
function hasDuplicate(arr){
return (arr.length != _.uniq(arr).length);
}
Lorsque tout ce dont vous avez besoin est de vérifier qu’il n’ya pas de doublons comme demandé dans cette question vous pouvez utiliser la méthode every():
[1, 2, 3].every(function(elem, i, array){return array.lastIndexOf(elem) === i}) // true
[1, 2, 1].every(function(elem, i, array){return array.lastIndexOf(elem) === i}) // false
Notez que every() ne fonctionne pas pour IE 8 et inférieur.
J'utilise lastIndexOf() car il pourrait être plus efficace que indexOf() si les rappels de fonction effectués par every() sont effectués dans l'ordre d'index, mais cela n'est pas prouvé.
Dans CoffeeScript, j'utilise ceci:
Array::duplicates = -> not @every((elem, i, array) -> array.lastIndexOf(elem) is i)
[1, 2, 3].duplicates() // false
[1, 2, 1].duplicates() // true
Voici ma solution simple et une ligne.
Il recherche d'abord les éléments non uniques, puis rend le tableau trouvé unique en utilisant 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))]
);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],
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 )
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);au lieu d'ajouter le 'Array.prototype.indexOf'
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 quand ajouté à la prototyp.chain 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
Code simple avec la syntaxe ES6 (retourne un tableau trié des 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]);
Avec ES6 (ou en utilisant Babel ou Typescipt), vous pouvez simplement faire:
var duplicates = myArray.filter(i => myArray.filter(ii => ii === i).length > 1);
Manière rapide et élégante en utilisant es6 déstructurer et réduire les objets
Il s'exécute dans 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']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 reduction () pour envoyer les doublons vers un nouveau tableau s’il n’existait pas déjà.
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]
Voici un moyen très léger et facile:
var codes = dc_1.split(',');
var i = codes.length;
while (i--) {
if (codes.indexOf(codes[i]) != i) {
codes.splice(i,1);
}
}
Utilisation de "includes" 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>Je viens de trouver un moyen simple d'y parvenir en utilisant un filtre Array
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 fonction suivante (une variante de la fonction éliminerDuplicates 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 utilisant le tri peuvent nécessiter une fonction de tri appropriée. Je n'ai pas encore essayé cette route.
Cette implémentation particulière fonctionne pour (au moins) des chaînes et des 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;
}
ES6 propose la structure de données Set, qui est en principe un tableau qui n'accepte pas les doublons . Avec la structure de données Set, il est très facile de rechercher 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 préfère la manière fonctionnelle de faire ceci.
function removeDuplicates(links) {
return _.reduce(links, function(list, elem) {
if (list.indexOf(elem) == -1) {
list.Push(elem);
}
return list;
}, []);
}
Ceci utilise un trait de soulignement, mais Array a aussi une fonction reduce
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 duplicatesJe pense que le ci-dessous est le moyen le plus simple et le plus rapide O(n) pour accomplir exactement ce que vous avez demandé:
function getDuplicates( arr ) {
var i, value;
var all = {};
var duplicates = [];
for( i=0; i<arr.length; i++ ) {
value = arr[i];
if( all[value] ) {
duplicates.Push( value );
all[value] = false;
} else if( typeof all[value] == "undefined" ) {
all[value] = true;
}
}
return duplicates;
}
Ou pour ES5 ou supérieur:
function getDuplicates( arr ) {
var all = {};
return arr.reduce(function( duplicates, value ) {
if( all[value] ) {
duplicates.Push(value);
all[value] = false;
} else if( typeof all[value] == "undefined" ) {
all[value] = true;
}
return duplicates;
}, []);
}
C’est probablement l’un des moyens les plus rapides d’éliminer définitivement les doublons d’un tableau 10 fois plus rapide que la plupart des fonctions fournies ici.
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);
- Test: http://jsperf.com/wgu
- Démo: http://jsfiddle.net/46S7g/
- Plus: https://stackoverflow.com/a/25082874/2450730
si vous ne pouvez pas lire le code ci-dessus, lisez un livre javascript ou des explications sur un code plus court. https://stackoverflow.com/a/21353032/2450730
EDIT Comme indiqué dans les commentaires, cette fonction renvoie un tableau contenant des éléments uniques. Cependant, la question demande de rechercher les doublons. dans ce cas, une simple modification de cette fonction permet d'insérer les doublons dans un tableau, puis d'utiliser la fonction précédente toUnique pour supprimer les 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));
Je me sens comme la solution la plus simple serait simplement d'utiliser indexOf
exemple complet de pousser uniquement des éléments uniques à un tableau.
var arr = ['a','b','c','d','a','b','c','d'];
var newA = [];
for(var i = 0; i < arr.length; i++){
if(newA.indexOf(arr[i]) === -1){
newA.Push(arr[i]);
}
}
Je n'ai pas aimé la plupart des réponses.
Pourquoi? Trop compliqué, trop de code, du code inefficace et beaucoup ne répondent pas à la question qui consiste à trouver les doublons (et non à donner un tableau sans les doublons).
La fonction suivante renvoie tous les doublons:
function GetDuplicates(arr) {
var i, out=[], obj={};
for (i=0; i < arr.length; i++)
obj[arr[i]] == undefined ? obj[arr[i]] ++ : out.Push(arr[i]);
return out;
}
Parce que la plupart du temps, il est inutile de renvoyer TOUS les doublons, mais simplement de savoir quelles sont les valeurs en double. Dans ce cas, vous renvoyez un tableau avec des doublons uniques ;-)
function GetDuplicates(arr) {
var i, out=[], obj={};
for (i=0; i < arr.length; i++)
obj[arr[i]] == undefined ? obj[arr[i]] ++ : out.Push(arr[i]);
return GetUnique(out);
}
function GetUnique(arr) {
return $.grep(arr, function(elem, index) {
return index == $.inArray(elem, arr);
});
}
Peut-être que quelqu'un d'autre pense la même chose.
var input = ['a', 'b', 'a', 'c', 'c'],
duplicates = [],
i, j;
for (i = 0, j = input.length; i < j; i++) {
if (duplicates.indexOf(input[i]) === -1 && input.indexOf(input[i], i+1) !== -1) {
duplicates.Push(input[i]);
}
}
console.log(duplicates);
Résoudre ce qui précède en O(n) complexité temporelle (sans tri).
var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7];
var obj={};
for(var i=0;i<arr.length;i++){
if(!obj[arr[i]]){
obj[arr[i]]=1;
} else {
obj[arr[i]]=obj[arr[i]]+1;
}
}
var result=[]
for(var key in obj){
if(obj[key]>1){
result.Push(Number(key)) // change this to result.Push(key) to find duplicate strings in an array
}
}
console.log(result)
Juste pour ajouter une théorie à ce qui précède.
La recherche de doublons a une limite inférieure égale à O (n * log (n) dans le modèle de comparaison. SO en théorie, vous ne pouvez pas faire mieux que de trier d'abord puis de parcourir la liste En éliminant séquentiellement tous les doublons trouvés.
Si vous voulez trouver les doublons en linéaire (O (n)) attendu time, vous pouvez Hacher chaque élément de la liste; en cas de collision, supprimez/étiquetez-le comme un doublon, et continuez.
function GetDuplicates(arr) {
var i = 0, m = [];
return arr.filter(function (n) {
return !m[n] * ~arr.indexOf(n, m[n] = ++i);
});
}
Suivre la logique 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:
- Une seule ligne :-P
- Toute la structure de données intégrée aidant à améliorer l'efficacité
- Plus rapide
Description de la logique:
- Conversion en jeu pour supprimer tous les doublons
- Itérer parmi les valeurs définies
- Avec chaque valeur définie, vérifiez dans le tableau source la condition "les valeurs du premier index ne sont pas égales au dernier" ==> Ensuite, elles sont déduites en double, sinon elles sont "uniques"
Remarque: les méthodes map () et filter () sont efficaces et plus rapides.
En modifiant la solution de @ RaphaelMontanaro et en empruntant le blog de @ Nosredna, voici ce que vous pouvez faire si vous souhaitez simplement identifier les éléments en double de votre tableau.
function identifyDuplicatesFromArray(arr) {
var i;
var len = arr.length;
var obj = {};
var duplicates = [];
for (i = 0; i < len; i++) {
if (!obj[arr[i]]) {
obj[arr[i]] = {};
}
else
{
duplicates.Push(arr[i]);
}
}
return duplicates;
}
Merci pour la solution élégante, @Nosredna!
ES5 uniquement (c’est-à-dire qu’il nécessite 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] );
});
C’est le moyen le plus efficace auquel je puisse penser car n’inclut pas Array.indexOf() ni Array.lastIndexOf() qui ont une complexité de O(n) et utiliser à l’intérieur de toute boucle de complexité O(n) rendra la complexité complète O n ^ 2).
Ma première boucle a une complexité de O(n/2) ou O((n/2) + 1), car la complexité de la recherche dans le hachage est O (1). La deuxième boucle la plus complexe lorsqu'il n'y a pas de doublons dans un tableau est O(n) et la complexité maximale lorsque tous les éléments ont un doublon est O (n/2).
function duplicates(arr) {
let duplicates = [],
d = {},
i = 0,
j = arr.length - 1;
// Complexity O(n/2)
while (i <= j) {
if (i === j)
d[arr[i]] ? d[arr[i]] += 1 : d[arr[i]] = 1; // Complexity O(1)
else {
d[arr[i]] ? d[arr[i]] += 1 : d[arr[i]] = 1; // Complexity O(1)
d[arr[j]] ? d[arr[j]] += 1 : d[arr[j]] = 1; // Complexity O(1)
}
++i;
--j;
}
// Worst complexity O(n), best complexity O(n/2)
for (let k in d) {
if (d[k] > 1)
duplicates.Push(k);
}
return duplicates;
}
console.log(duplicates([5,6,4,9,2,3,5,3,4,1,5,4,9]));
console.log(duplicates([2,3,4,5,4,3,4]));
console.log(duplicates([4,5,2,9]));
console.log(duplicates([4,5,2,9,2,5,9,4]));
C’est l’une des solutions simples au ES5 à laquelle je pouvais penser -
function duplicates(arr) {
var duplicatesArr = [],
uniqueObj = {};
for (var i = 0; i < arr.length; i++) {
if( uniqueObj.hasOwnProperty(arr[i]) && duplicatesArr.indexOf( arr[i] ) === -1) {
duplicatesArr.Push( arr[i] );
}
else {
uniqueObj[ arr[i] ] = true;
}
}
return duplicatesArr;
}
/* Input Arr: [1,1,2,2,2,1,3,4,5,3] */
/* OutPut Arr: [1,2,3] */
Encore une autre façon en utilisant le trait de soulignement. Numbers est le tableau source et les doublons ont des valeurs en double possibles.
var itemcounts = _.countBy(numbers, function (n) { return n; });
var dupes = _.reduce(itemcounts, function (memo, item, idx) {
if (item > 1)
memo.Push(idx);
return memo;
}, []);
- Imprimer les doublons
var arr = [1,2,3,4,13,2,3,4,3,4];
// non_unique Printing
function nonUnique(arr){
var result = [];
for(var i =0;i<arr.length;i++){
if(arr.indexOf(arr[i],i+1) > -1){
result.Push(arr[i]);
}
}
console.log(result);
}nonUnique(arr);
// unique Printing
function uniqueDuplicateVal(arr){
var result = [];
for(var i =0;i<arr.length;i++){
if(arr.indexOf(arr[i],i+1) > -1){
if(result.indexOf(arr[i]) === -1]){
result.Push(arr[i]);
}
}
}
}
uniqueDuplicateVal(arr)//find duplicates:
//sort, then reduce - concat values equal previous element, skip others
//input
var a = [1, 2, 3, 1, 2, 1, 2]
//short version:
var duplicates = a.sort().reduce((d, v, i, a) => i && v === a[i - 1] ? d.concat(v) : d, [])
console.log(duplicates); //[1, 1, 2, 2]
//readable version:
var duplicates = a.sort().reduce((output, element, index, input) => {
if ((index > 0) && (element === input[index - 1]))
return output.concat(element)
return output
}, [])
console.log(duplicates); //[1, 1, 2, 2]Le moyen le plus rapide de résoudre est en fait avec un drapeau
var values = [4,2,3,1,4]
// solution
const checkDuplicate = list => {
var hasDuplicate = false;
list.sort().sort((a, b) => {
if (a === b) hasDuplicate = true
})
return hasDuplicate
}
console.log(checkDuplicate(values))Cela devrait être l’un des moyens les plus courts et les plus simples de rechercher des valeurs en double dans un tableau.
var arr = [1,2,3,4,5,6,7,8,1,2,3,4,5,3,3,4];
var data = arr.filter(function(item,index,arr){
return arr.indexOf(item) != arr.lastIndexOf(item) && arr.indexOf(item) == index;
})
console.log(data );Semblable à quelques autres réponses, mais j'ai utilisé forEach() pour le rendre un peu plus joli
function find_duplicates(data) {
var track = {};
var duplicates = [];
data.forEach(function (item) {
!track[item] ? track[item] = true : duplicates.Push(item);
});
return duplicates;
}
Si une valeur est dupliquée plus d'une fois, tous ses doublons sont renvoyés, comme ceci:
find_duplicates(['foo', 'foo', 'bar', 'bar', 'bar']);
// returns ['foo', 'bar', 'bar']
C'est peut-être ce que vous voulez, sinon vous devez suivre avec un filtrage "unique".
Ceci peut également être résolu en utilisant Set().
Une valeur de l'ensemble ne peut apparaître qu'une seule fois; il est unique dans la collection de l'ensemble.
Array.prototype.hasDuplicates = function () {
if (arr.length !== (new Set(arr).size)) {
return true;
}
return false;
}
Plus d'informations sur les ensembles: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
Remarque: les ensembles ne sont pas totalement pris en charge dans IE.
Ici, nous produisons les doublons une seule fois par dupe.
var arr = [9, 9, 9, 9, 111, 2, 3, 4, 4, 5, 7];
arr.sort();
var results = [];
for (var i = 0; i < arr.length - 1; i++) {
if (arr[i + 1] == arr[i]) {
results.Push(arr[i]);
}
}
results = Array.from(new Set(results))
console.log(results);Voici comment je l'ai implémenté avec map. Il devrait fonctionner dans le temps O(n) et devrait être facile à retenir.
var first_array=[1,1,2,3,4,4,5,6];
var find_dup=new Map;
for (const iterator of first_array) {
// if present value++
if(find_dup.has(iterator)){
find_dup.set(iterator,find_dup.get(iterator)+1);
}else{
// else add it
find_dup.set(iterator,1);
}
}
console.log(find_dup.get(2));Ensuite, vous pouvez find_dup.get(key) pour savoir s’il existe des doublons (il faut donner> 1).
La magie
a.filter(( t={}, e=>!(1-(t[e]=++t[e]|0)) ))
O(n) performance; nous supposons que votre tableau est dans a et qu'il contient des éléments pouvant être transtypés .toString() de manière unique (ce qui est fait implicitement par JS dans t[e]) , "aa"], matricesNum = [[1,2,3], [43,2,3], [1,2,3]]. Explication ici , valeurs uniques ici
var a1 = [[2, 17], [2, 17], [2, 17], [1, 12], [5, 9], [1, 12], [6, 2], [1, 12]];
var a2 = ['Mike', 'Adam','Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl'];
var a3 = [5,6,4,9,2,3,5,3,4,1,5,4,9];
let nd = (a) => a.filter((t={},e=>!(1-(t[e]=++t[e]|0))))
// Print
let c= x => console.log(JSON.stringify(x));
c( nd(a1) );
c( nd(a2) );
c( nd(a3) );voici un petit extrait simple pour trouver des valeurs uniques et dupliquées avec un tri et deux boucles.
var _unique = function (arr) {
var h = [], t = [];
arr.forEach(function (n) {
if (h.indexOf(n) == -1)
h.Push(n);
else t.Push(n);
});
return [h, t];
}
var result = _unique(["test",1,4,2,34,6,21,3,4,"test","prince","th",34]);
console.log("Has duplicate values : " + (result[1].length > 0)) //and you can check count of duplicate values
console.log(result[0]) //unique values
console.log(result[1]) //duplicate valuesLe moyen le plus simple pour extraire des doublons/valeurs répétées d'un tableau/d'une chaîne:
function getDuplicates (param) {
var duplicates = {}
for (var i = 0; i < param.length; i ++) {
var char = param[i]
if(duplicates[char]) {
duplicates[char] ++
} else {
duplicates[char] = 1
}
}
return duplicates
}
getDuplicates("aeiouaeiou")
**OR**
getDuplicates(["a","e","i","o","u","a","e"])
**OR**
getDuplicates([1,2,3,4,5,1,1,2,3])
Renvoie les doublons et préserve le type de données.
Avec O(4n) performances
const dupes = arr => {
const map = arr.reduce((map, curr) => {
return (map.set(curr, (map.get(curr) || 0) + 1), map)
}, new Map());
return Array.from(map).filter(([key, val])=> val > 1).map(([key, val]) => key)
}
Avec O(2n) performances
const dupes = arr => {
const map = arr.reduce((map, curr) => {
return (map.set(curr, (map.get(curr) || 0) + 1), map)
}, new Map());
const dupes_ = [];
for (let [key, val] of map.entries()) {
if (val > 1) dupes_.Push(key);
}
return dupes_;
}
En voici un implémenté en utilisant sort () et JSON.stringify ()
https://Gist.github.com/korczis/7598657
function removeDuplicates(vals) {
var res = [];
var tmp = vals.sort();
for (var i = 0; i < tmp.length; i++) {
res.Push(tmp[i]);
while (JSON.stringify(tmp[i]) == JSON.stringify(tmp[i + 1])) {
i++;
}
}
return res;
}
console.log(removeDuplicates([1,2,3,4,5,4,3,3,2,1,]));
La bibliothèque de prototypes a une fonction uniq qui renvoie le tableau sans les dupes Ce n'est que la moitié du travail cependant.
Vous pouvez utiliser la construction suivante:
var arr = [1,2,3,4,5,6,7,8,9,0,5];
var duplicate = arr.filter(function(item, i, arr) {
return -1 !== arr.indexOf(item, i + 1);
})
http://jsfiddle.net/vol7ron/gfJ28/
var arr = ['hello','goodbye','foo','hello','foo','bar',1,2,3,4,5,6,7,8,9,0,1,2,3];
var hash = [];
// build hash
for (var n=arr.length; n--; ){
if (typeof hash[arr[n]] === 'undefined') hash[arr[n]] = [];
hash[arr[n]].Push(n);
}
// work with compiled hash (not necessary)
var duplicates = [];
for (var key in hash){
if (hash.hasOwnProperty(key) && hash[key].length > 1){
duplicates.Push(key);
}
}
alert(duplicates);
Le résultat sera le tableau
hash, qui contiendra un ensemble unique de valeurs et la position de ces valeurs. Donc, s'il y a 2 postes ou plus, nous pouvons déterminer que la valeur a un doublon. Ainsi, chaque lieuhash[<value>].length > 1, signifie un doublon.hash['hello']retournera[0,3]car 'hello' a été trouvé dans les nœuds 0 et 3 dansarr[].Remarque: la longueur de
[0,3]est ce qui permet de déterminer s'il s'agissait d'un doublon.Utiliser
for(var key in hash){ if (hash.hasOwnProperty(key)){ alert(key); } }alertera chaque valeur unique.
De Raphael Montanaro répondre, il peut être amélioré pour utiliser avec un élément tableau/objet comme suit.
function eliminateDuplicates(arr) {
var len = arr.length,
out = [],
obj = {};
for (var key, i=0; i < len; i++) {
key = JSON.stringify(arr[i]);
obj[key] = (obj[key]) ? obj[key] + 1 : 1;
}
for (var key in obj) {
out.Push(JSON.parse(key));
}
return [out, obj];
}
Remarque: Vous devez utiliser la bibliothèque JSON pour les navigateurs non pris en charge par JSON.
var isUnique = true;
for (var i= 0; i< targetItems.length; i++) {
var itemValue = $(targetItems[i]).val();
if (targetListValues.indexOf(itemValue) >= 0) {
isUnique = false;
break;
}
targetListValues.Push(itemValue);
if (!isUnique) {
//raise any error msg
return false;
}
}
en utilisant Pure Js
function arr(){
var a= [1,2,3,4,5,34,2,5,7,8,6,4,3,25,8,34,56,7,8,76,4,23,34,46,575,8564,53,5345657566];
var b= [];
b.Push(a[0]);
var z=0;
for(var i=0; i< a.length; i++){
for(var j=0; j< b.length; j++){
if(b[j] == a[i]){
z = 0;
break;
}
else
z = 1;
}
if(z)
b.Push(a[i]);
}
console.log(b);
}
Nous allons utiliser la fonctionnalité Javascript ES6 pour faire de la magie!
var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7];
const filtered = arr.filter((value, index) => {
return arr.indexOf(value) >= index;
});
console.log(filtered);
C'est une fonction plus avancée basée sur le nombre d'occurrences.
function getMostDuplicated(arr, count) {
const result = [];
arr.forEach((item) => {
let i = 0;
arr.forEach((checkTo) => {
if (item === checkTo) {
i++;
if (i === count && result.indexOf(item) === -1) {
result.Push(item);
}
}
});
});
return result;
}
arr = [1,1,1,2,5,67,3,2,3,2,3,1,2,3,4,1,4];
result = getMostDuplicated(arr, 5); // result is 1
result = getMostDuplicated(arr, 2); // result 1, 2, 3, 4
console.log(result);
Voici l'une des méthodes permettant d'éviter les doublons dans un tableau javascript ... et il prend en charge les chaînes et les nombres ...
var unique = function(origArr) {
var newArray = [],
origLen = origArr.length,
found,
x = 0; y = 0;
for ( x = 0; x < origLen; x++ ) {
found = undefined;
for ( y = 0; y < newArray.length; y++ ) {
if ( origArr[x] === newArray[y] ) found = true;
}
if ( !found) newArray.Push( origArr[x] );
}
return newArray;
}
vérifier ceci violon ..
/* La méthode indexOf de l’objet Array est utile pour comparer les éléments d’un tableau.
Array.prototype.indexOf= Array.prototype.indexOf || function(what, i){
i= i || 0;
var L= this.length;
while(i<L){
if(this[i]=== what) return i;
++i;
}
return -1;
}
function getarrayduplicates(arg){
var itm, A= arg.slice(0, arg.length), dups= [];
while(A.length){
itm= A.shift();
if(A.indexOf(itm)!= -1 && dups.indexOf(itm)== -1){
dups[dups.length]= itm;
}
}
return dups;
}
var a1 = [1, 22, 3, 2, 2, 3, 3, 4, 1, 22, 7, 8, 9];
alerte (getarrayduplicates (a1));
Pour les très grands tableaux, il peut être plus rapide de supprimer les doublons du tableau au fur et à mesure qu'ils sont trouvés, afin qu'ils ne soient plus consultés:
function getarrayduplicates(arg){
var itm, A= arg.slice(0, arg.length), dups= [];
while(A.length){
itm= A.shift();
if(A.indexOf(itm)!= -1){
dups[dups.length]= itm;
while(A.indexOf(itm)!= -1){
A.splice(A.indexOf(itm), 1);
}
}
}
return dups;
}
J'essaie d'améliorer la réponse de @swilliams, cela renverra un tableau sans doublons.
// arrays for testing
var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7];
// ascending order
var sorted_arr = arr.sort(function(a,b){return a-b;});
var arr_length = arr.length;
var results = [];
if(arr_length){
if(arr_length == 1){
results = arr;
}else{
for (var i = 0; i < arr.length - 1; i++) {
if (sorted_arr[i + 1] != sorted_arr[i]) {
results.Push(sorted_arr[i]);
}
// for last element
if (i == arr.length - 2){
results.Push(sorted_arr[i+1]);
}
}
}
}
alert(results);
Il s'agit d'une approche à une seule boucle avec une table de hachage pour compter les éléments et filtrer le tableau si le compte est 2, car il renvoie le premier doublon trouvé.
Avantage:
- boucle simple
- utilise un objet pour compter dans une fermeture
var array = [5, 0, 2, 1, 2, 3, 3, 4, 4, 8, 6, 7, 9, 4],
duplicates = array.filter((h => v => (h[v] = (h[v] || 0) + 1) === 2)({}));
console.log(duplicates);Cela retournera les doublons d'un tableau sous forme de tableau de doublons.
const duplicates = function(arr) {
// let try moving in pairs.. maybe that will work
let dups = new Set(),
r = []
arr.sort()
arr.reduce((pv, cv) => {
if (pv === cv) {
dups.add(pv)
}
return cv
})
for (let m of dups.values()) {
r.Push(m)
}
return r
}
console.log(duplicates([1,3,5,6,7,4,4,5,1,4,6,3,8,9,5,0]))