Comment compter la valeur en double dans un tableau en javascript

100

Actuellement, j'ai un tableau comme ça:

var uniqueCount = Array();

Après quelques étapes, mon tableau ressemble à ça:

uniqueCount = [a,b,c,d,d,e,a,b,c,f,g,h,h,h,e,a];

Comment puis-je compter combien de a, b, c y a-t-il dans le tableau? Je veux avoir un résultat comme:

a = 3
b = 1
c = 2
d = 2

etc.

detno29
la source
1
duplicata possible de stackoverflow.com/questions/12749200/…
Vinay Pratap Singh
@Nirk Je suppose que musical_coder signifiait une carte comme dans {}, pas une programmation fonctionnelle map.
Matt Ball

Réponses:

28

function count() {
    array_elements = ["a", "b", "c", "d", "e", "a", "b", "c", "f", "g", "h", "h", "h", "e", "a"];

    array_elements.sort();

    var current = null;
    var cnt = 0;
    for (var i = 0; i < array_elements.length; i++) {
        if (array_elements[i] != current) {
            if (cnt > 0) {
                document.write(current + ' comes --> ' + cnt + ' times<br>');
            }
            current = array_elements[i];
            cnt = 1;
        } else {
            cnt++;
        }
    }
    if (cnt > 0) {
        document.write(current + ' comes --> ' + cnt + ' times');
    }

}

count();

Démo Fiddle

Vous pouvez également utiliser des fonctions d'ordre supérieur pour effectuer l'opération. Voir cette réponse

Vinay Pratap Singh
la source
1
l'instruction supplémentaire if après la boucle n'est pas nécessaire ... utilisez simplement for (var i = 0; i <= array_elements.length; i++) {ou à la <=place de <.
EmmaGamma
Salut @Vinay, tu pourrais peut-être m'aider ici? stackoverflow.com/questions/57819850/…
SMPLYJR
321
var counts = {};
your_array.forEach(function(x) { counts[x] = (counts[x] || 0)+1; });
FeuilleJS
la source
9
C'est certainement la réponse la plus simple
Josh Beam
3
(compte [x] || 0) +1 comment cela donne le compte?
jsduniya
5
@SidBhalke: l'expression counts[x] || 0renvoie la valeur de counts[x]si elle est définie, sinon 0. Ensuite, ajoutez-en un et réinstallez-le dans l'objet et le décompte est terminé.
Constantinius
1
@SheetJS si vous vous demandez pourquoi le vote négatif - c'était moi; Je naviguais sur mobile et j'ai cliqué sur le bouton sans m'en apercevoir. Une fois que j'ai découvert qu'il était trop tard pour revenir en arrière. Toutes mes excuses, la réponse est vraiment bonne. Si vous souhaitez le modifier, je serais heureux d'annuler.
Todor Minakov
4
Aussi avec reduce:var counts = your_array.reduce((map, val) => {map[val] = (map[val] || 0)+1; return map}, {} );
Alberto89
70

Quelque chose comme ça:

uniqueCount = ["a","b","c","d","d","e","a","b","c","f","g","h","h","h","e","a"];
var count = {};
uniqueCount.forEach(function(i) { count[i] = (count[i]||0) + 1;});
console.log(count);

Utilisez une simple boucle for au lieu de forEach si vous ne voulez pas que cela se brise dans les anciens navigateurs.

loxxy
la source
4
@web_dev il crée un objet tableau associatif appelé count qui aura une paire clé / valeur pour chaque élément unique du tableau, où la clé est la valeur d'élément unique et la valeur est le nombre. Il itère sur le tableau et pour chaque valeur incrémente la valeur ou crée la paire clé / valeur (la valeur de la clé inexistante est évaluée comme indéfinie, donc l'opérateur || ou prend un zéro à la place et ajoute le 1)
robisrob
@neelmeg Peut-être que l'écriture de tous les paramètres pour "forEach" aide à mieux comprendre ("i" est la valeur de chaque tableau et NON son index):uniqueCount.forEach(function(value, index) { count[value] = (count[value] || 0) + 1; });
Pedro Ferreira
37

Je suis tombé sur cette (très ancienne) question. Fait intéressant, la solution la plus évidente et la plus élégante (à mon humble avis) manque: Array.prototype.reduce (...) . Tous les principaux navigateurs prennent en charge cette fonctionnalité depuis environ 2011 (IE) ou même avant (tous les autres):

var arr = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
var map = arr.reduce(function(prev, cur) {
  prev[cur] = (prev[cur] || 0) + 1;
  return prev;
}, {});

// map is an associative array mapping the elements to their frequency:
document.write(JSON.stringify(map));
// prints {"a": 3, "b": 2, "c": 2, "d": 2, "e": 2, "f": 1, "g": 1, "h": 3}

isnot2bad
la source
10

Ligne unique basée sur la fonction de réduction du tableau

const uniqueCount =  ["a", "b", "c", "d", "d", "e", "a", "b", "c", "f", "g", "h", "h", "h", "e", "a"];
const distribution = uniqueCount.reduce((acum,cur) => Object.assign(acum,{[cur]: (acum[cur] | 0)+1}),{});
console.log(JSON.stringify(distribution,null,2));

dinigo
la source
Je viens de réaliser que @ isnot2bad ( stackoverflow.com/a/32886673/621058 ) est presque le même que le mien. Il se trouve que j'utilise des fonctions et des constantes de grosse flèche
dinigo
8

Simple c'est mieux, une variable, une fonction :)

const counts = arr.reduce((acc, value) => ({
   ...acc,
   [value]: (acc[value] || 0) + 1
}), {});
Shannon Hochkins
la source
6

Je pense que c'est le moyen le plus simple de compter les occurrences avec la même valeur dans le tableau.

var a = [true, false, false, false];
a.filter(function(value){
    return value === false;
}).length                                      
Dmytro Kozlovskyi
la source
5

// Initial array
let array = ['a', 'b', 'c', 'd', 'd', 'e', 'a', 'b', 'c', 'f', 'g', 'h', 'h', 'h', 'e', 'a'];

// Unique array without duplicates ['a', 'b', ... , 'h']
let unique = [...new Set(array)];

// This array counts duplicates [['a', 3], ['b', 2], ... , ['h', 3]] 
let duplicates = unique.map(value => [value, array.filter(str => str === value).length]);
Erik Martín Jordán
la source
5

Personne ne répondant ne semble utiliser le Map()module intégré pour cela, qui a tendance à être mon choix combiné avec Array.prototype.reduce():

const data = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
const result = data.reduce((a, c) => a.set(c, (a.get(c) || 0) + 1), new Map());
console.log(...result);

Nb, vous devrez polyfillMap() si vous souhaitez l'utiliser dans des navigateurs plus anciens.

aendrew
la source
Pourriez-vous expliquer un peu en détail comment cela fonctionne? (spécialement la partie set / get). J'ai essayé de casser le réducteur dans une fonction mais j'ai "get" n'est pas une fonction en réponse.
Antoine Nedelec
Ok getet les setfonctions viennent de l' Mapobjet. Mais l'accumulateur initial n'est pas un objet Map, alors pourquoi la version réduite du réducteur en prend-elle un?
Antoine Nedelec
@AntoineNedelec La valeur initiale est un nouvel Mapobjet; voir le deuxième argument de la réduction. Map.prototype.setrenvoie l'objet de la carte et Map.prototype.getrenvoie undefinedla valeur de la clé qui lui est fournie. Cela nous permet d'obtenir le décompte actuel de chaque lettre (ou 0s'il n'est pas défini), puis l'incrémenter de un, puis définir le décompte de cette lettre sur le nouveau décompte, qui renvoie la carte et devient la nouvelle valeur de l'accumulateur.
aendrew
4

Vous pouvez avoir un objet qui contient des comptes. Parcourez la liste et augmentez le nombre de chaque élément:

var counts = {};

uniqueCount.forEach(function(element) {
  counts[element] = (counts[element] || 0) + 1;
});

for (var element in counts) {
  console.log(element + ' = ' + counts[element]);
} 
nkron
la source
pourquoi avez-vous posé cette condition counts[element] || 0?
AskMen
La première fois que vous accédez aux counts[element]retours, undefinedcar la propriété n'a pas encore de valeur. Si vous essayez ensuite d'ajouter undefined + 1, vous vous retrouverez avec NaN . Le (count[element] || 0)remplacera le undefinedpar 0ainsi l'ajout 1produit 1au lieu de NaN. ECMAScript 2020 ajoute l'opérateur de fusion nul ??qui fait une chose similaire mais est un peu plus explicite qu'il utilise la deuxième valeur lorsque la première est undefined(ou null). Cette version serait (counts[element] ?? 0) + 1.
nkron il y a
4

Vous pouvez le résoudre sans utiliser de boucles for / while ou forEach.

function myCounter(inputWords) {        
    return inputWords.reduce( (countWords, word) => {
        countWords[word] = ++countWords[word] || 1;
        return countWords;
    }, {});
}

J'espère que cela vous aide!

Pablo Souza
la source
4

// new example.
var str= [20,1,-1,2,-2,3,3,5,5,1,2,4,20,4,-1,-2,5];

function findOdd(para) {
  var count = {};
  para.forEach(function(para) {
  count[para] = (count[para] || 0) + 1;
  });
  return count;
}

console.log(findOdd(str));

Ryan Luu
la source
3

Vous pouvez faire quelque chose comme ça:

uniqueCount = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
var map = new Object();

for(var i = 0; i < uniqueCount.length; i++) {
 if(map[uniqueCount[i]] != null) {
    map[uniqueCount[i]] += 1;
} else {
    map[uniqueCount[i]] = 1;
    }
}

maintenant vous avez une carte avec tous les personnages comptent

Rami
la source
1
var uniqueCount = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
// here we will collect only unique items from the array
var uniqueChars = [];

// iterate through each item of uniqueCount
for (i of uniqueCount) {
// if this is an item that was not earlier in uniqueCount, 
// put it into the uniqueChars array
  if (uniqueChars.indexOf(i) == -1) {
    uniqueChars.push(i);
  } 
}
// after iterating through all uniqueCount take each item in uniqueChars
// and compare it with each item in uniqueCount. If this uniqueChars item 
// corresponds to an item in uniqueCount, increase letterAccumulator by one.
for (x of uniqueChars) {
  let letterAccumulator = 0;
  for (i of uniqueCount) {
    if (i == x) {letterAccumulator++;}
  }
  console.log(`${x} = ${letterAccumulator}`);
}
Ilya Kushlianski
la source
Merci de l'avoir mis à jour, beaucoup plus utile à ceux qui commencent.
Regular Joe
1

Dupliques dans un tableau contenant des alphabets:

var arr = ["a", "b", "a", "z", "e", "a", "b", "f", "d", "f"],
  sortedArr = [],
  count = 1;

sortedArr = arr.sort();

for (var i = 0; i < sortedArr.length; i = i + count) {
  count = 1;
  for (var j = i + 1; j < sortedArr.length; j++) {
    if (sortedArr[i] === sortedArr[j])
      count++;
  }
  document.write(sortedArr[i] + " = " + count + "<br>");
}

Duplique dans un tableau contenant des nombres:

var arr = [2, 1, 3, 2, 8, 9, 1, 3, 1, 1, 1, 2, 24, 25, 67, 10, 54, 2, 1, 9, 8, 1],
  sortedArr = [],
  count = 1;
sortedArr = arr.sort(function(a, b) {
  return a - b
});
for (var i = 0; i < sortedArr.length; i = i + count) {
  count = 1;
  for (var j = i + 1; j < sortedArr.length; j++) {
    if (sortedArr[i] === sortedArr[j])
      count++;
  }
  document.write(sortedArr[i] + " = " + count + "<br>");
}

Ankit Gupta
la source
1

var testArray = ['a', 'b', 'c', 'd', 'd', 'e', ​​'a', 'b', 'c', 'f', 'g', 'h ',' h ',' h ',' e ',' a '];

var newArr = [];
testArray.forEach((item) => {
    newArr[item] = testArray.filter((el) => {
            return el === item;
    }).length;
})
console.log(newArr);
utilisateur6160741
la source
1
uniqueCount = ["a","b","a","c","b","a","d","b","c","f","g","h","h","h","e","a"];
var count = {};
uniqueCount.forEach((i) => { count[i] = ++count[i]|| 1});
console.log(count);
Muhammad Javeed
la source
1

simplifié sheet.js answare

var counts = {};
var aarr=['a','b','a'];
aarr.forEach(x=>counts[x]=(counts[x] || 0)+1 );
console.log(counts)

ßãlãjî
la source
0

Une combinaison de bonnes réponses:

var count = {};
var arr = ['a', 'b', 'c', 'd', 'd', 'e', 'a', 'b', 'c', 'f', 'g', 'h', 'h', 'h', 'e', 'a'];
var iterator = function (element) {
    count[element] = (count[element] || 0) + 1;
}

if (arr.forEach) {
    arr.forEach(function (element) {
        iterator(element);
    });
} else {
    for (var i = 0; i < arr.length; i++) {
        iterator(arr[i]);
    }
}  

J'espère que c'est utile.

Xiaodan Mao
la source
0
public class CalculateCount {
public static void main(String[] args) {
    int a[] = {1,2,1,1,5,4,3,2,2,1,4,4,5,3,4,5,4};
    Arrays.sort(a);
    int count=1;
    int i;
    for(i=0;i<a.length-1;i++){
        if(a[i]!=a[i+1]){
            System.out.println("The Number "+a[i]+" appears "+count+" times");
            count=1;                
        }
        else{
            count++;
        }
    }
    System.out.println("The Number "+a[i]+" appears "+count+" times");

}   

}

Parv Johari
la source
Pouvez-vous ajouter du contexte à ce sujet?
Neo
0

En utilisant array.map, nous pouvons réduire la boucle, voir ceci sur jsfiddle

function Check(){
    var arr = Array.prototype.slice.call(arguments);
    var result = [];
    for(i=0; i< arr.length; i++){
        var duplicate = 0;
        var val = arr[i];
        arr.map(function(x){
            if(val === x) duplicate++;
        })
        result.push(duplicate>= 2);
    }
    return result;
}

Tester:

var test = new Check(1,2,1,4,1);
console.log(test);
Ali Adravi
la source
0

var string = ['a','a','b','c','c','c','c','c','a','a','a'];

function stringCompress(string){

var obj = {},str = "";
string.forEach(function(i) { 
  obj[i] = (obj[i]||0) + 1;
});

for(var key in obj){
  str += (key+obj[key]);
}
  console.log(obj);
  console.log(str);
}stringCompress(string)

/*
Always open to improvement ,please share 
*/

sg28
la source
0

Créez un fichier par exemple demo.jset exécutez-le dans la console avec node demo.jset vous obtiendrez l'occurrence des éléments sous forme de matrice.

var multipleDuplicateArr = Array(10).fill(0).map(()=>{return Math.floor(Math.random() * Math.floor(9))});
console.log(multipleDuplicateArr);

var resultArr = Array(Array('KEYS','OCCURRENCE'));

for (var i = 0; i < multipleDuplicateArr.length; i++) {
  var flag = true;
  for (var j = 0; j < resultArr.length; j++) {
     if(resultArr[j][0] == multipleDuplicateArr[i]){
       resultArr[j][1] = resultArr[j][1] + 1;
       flag = false;
      }
  }
  if(flag){
    resultArr.push(Array(multipleDuplicateArr[i],1));
  }
}

console.log(resultArr);

Vous obtiendrez le résultat dans la console comme ci-dessous:

[ 1, 4, 5, 2, 6, 8, 7, 5, 0, 5 ] . // multipleDuplicateArr
[ [ 'KEYS', 'OCCURENCE' ],        // resultArr
  [ 1, 1 ],
  [ 4, 1 ],
  [ 5, 3 ],
  [ 2, 1 ],
  [ 6, 1 ],
  [ 8, 1 ],
  [ 7, 1 ],
  [ 0, 1 ] ]
Jitendra
la source
0

La façon la plus rapide:

Сomputational complexité est O (n).

function howMuchIsRepeated_es5(arr) {
	const count = {};
	for (let i = 0; i < arr.length; i++) {
		const val = arr[i];
		if (val in count) {
			count[val] = count[val] + 1;
		} else {
			count[val] = 1;
		}
	}

	for (let key in count) {
		console.log("Value " + key + " is repeated " + count[key] + " times");
	}
}

howMuchIsRepeated_es5(['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a']);

Le code le plus court:

Utilisez ES6.

function howMuchIsRepeated_es6(arr) {
	// count is [ [valX, count], [valY, count], [valZ, count]... ];
	const count = [...new Set(arr)].map(val => [val, arr.join("").split(val).length - 1]);

	for (let i = 0; i < count.length; i++) {
		console.log(`Value ${count[i][0]} is repeated ${count[i][1]} times`);
	}
}

howMuchIsRepeated_es6(['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a']);

Serhii Zghama
la source
0
var arr = ['a','d','r','a','a','f','d'];  

//call function and pass your array, function will return an object with array values as keys and their count as the key values.
duplicatesArr(arr);

function duplicatesArr(arr){
    var obj = {}
    for(var i = 0; i < arr.length; i++){
        obj[arr[i]] = [];
        for(var x = 0; x < arr.length; x++){
            (arr[i] == arr[x]) ? obj[arr[i]].push(x) : '';
        }
        obj[arr[i]] = obj[arr[i]].length;
    }

    console.log(obj);
    return obj;
}
thaps
la source
0

Déclarez un objet arrpour contenir l'ensemble unique en tant que clés. Remplissez arren boucle dans le tableau une fois à l'aide de map. Si la clé n'a pas été trouvée précédemment, ajoutez la clé et attribuez une valeur de zéro. À chaque itération, incrémentez la valeur de la clé.

TestArray donné:

var testArray = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];

Solution:

var arr = {};
testArray.map(x=>{ if(typeof(arr[x])=="undefined") arr[x]=0; arr[x]++;});

JSON.stringify(arr) sortira

{"a":3,"b":2,"c":2,"d":2,"e":2,"f":1,"g":1,"h":3}

Object.keys(arr) reviendra ["a","b","c","d","e","f","g","h"]

Pour trouver les occurrences de n'importe quel élément, par exemple, b arr['b']affichera2

jidexl21
la source
Veuillez ne pas publier uniquement le code comme réponse, mais inclure également une explication de ce que fait votre code et comment il résout le problème. Les réponses avec une explication sont généralement de meilleure qualité et sont plus susceptibles d'attirer des votes positifs.
Mark Rotteveel
0

C'est simple en javascript en utilisant la méthode de réduction de tableau:

const arr = ['a','d','r','a','a','f','d'];
const result =  arr.reduce((json,val)=>({...json, [val]:(json[val] | 0) + 1}),{});
console.log(result)
//{ a:3,d:2,r:1,f:1 }

Yathin K Rao
la source
0

Usage:

wrap.common.getUniqueDataCount(, columnName);

CODE:

function getUniqueDataCount(objArr, propName) {
        var data = [];
        objArr.forEach(function (d, index) {
            if (d[propName]) {
                data.push(d[propName]);
            }
        });

        var uniqueList = [...new Set(data)];

        var dataSet = {};
        for (var i=0; i < uniqueList.length; i++) {
            dataSet[uniqueList[i]] = data.filter(x => x == uniqueList[i]).length;
        }
        
        return dataSet;
    }

Fragment

var data= [
          {a:'you',b:'b',c:'c',d:'c'},
          {a: 'you', b: 'b', c: 'c', d:'c'},
          {a: 'them', b: 'b', c: 'c', d:'c'},
          {a: 'them', b: 'b', c: 'c', d:'c'},
          {a: 'okay', b: 'b', c: 'c', d:'c'},
          {a: 'okay', b: 'b', c: 'c', d:'c'},
          ];
          
  console.log(getUniqueDataCount(data, 'a'));       
  
  function getUniqueDataCount(objArr, propName) {
        var data = [];
        objArr.forEach(function (d, index) {
            if (d[propName]) {
                data.push(d[propName]);
            }
        });

        var uniqueList = [...new Set(data)];

        var dataSet = {};
        for (var i=0; i < uniqueList.length; i++) {
            dataSet[uniqueList[i]] = data.filter(x => x == uniqueList[i]).length;
        }

        return dataSet;
    }

ARr0w
la source