web-dev-qa-db-fra.com

Comment compter la valeur en double dans un tableau en javascript

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.

javascriptarrays
61
detno29
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');
    }

}

Démo Fiddle

14
Vinay Pratap Singh
var counts = {};
your_array.forEach(function(x) { counts[x] = (counts[x] || 0)+1; });
206
SheetJS

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 à la place de forEach si vous ne voulez pas que cela casse dans les anciens navigateurs.

42
loxxy

Je suis tombé sur cette question (très ancienne). Fait intéressant, il manque la solution la plus évidente et la plus élégante (imho): 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}

23
isnot2bad

Une seule ligne basée sur la fonction de réduction de 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));

5
dinigo

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

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

Vous pouvez le résoudre sans utiliser aucune boucle for/while ou forEach.

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

J'espère que ça vous aide!

4
Pablo Souza

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 caractères

3
Rami

Vous pouvez avoir un objet qui contient des comptes. Parcourez la liste et incrémentez le nombre pour 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]);
}
3
nkron

Doublons 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>");
}

Dupliquer 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>");
}

1
Ankit Gupta
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}`);
}
1
Ilya Kushlianski

Créez un fichier par exemple demo.js et exécutez-le dans la console avec le noeud demo.js et vous obtiendrez 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 ] ]
0
Jitendra

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);
0
Ali Adravi

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 
*/

0
sg28

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.

0
Xiaodan Mao
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");

}

}

0
Parv Johari

Méthode la plus rapide:

complexité complexe 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']);
0
Serhii Zghama
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;
}
0
thaps
  
    // 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));
    
     </ code>
 0 
Ryan Luu