使用ramda.js有一个更好更简单的方法可以做到这一点。 代码示例

Const ary = [5,5,5,2,2,2,2,2,2,2,2,2,9,4]; R.countBy (r = > r)(必要) countBy documentation是at documentation

使用O(n)时间复杂度的映射的解决方案。

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

const countOccurrences = (arr) => {
    const map = {};
    for ( var i = 0; i < arr.length; i++ ) {
        map[arr[i]] = ~~map[arr[i]] + 1;
    }
    return map;
}

演示:http://jsfiddle.net/simevidas/bnACW/

如果使用下划线或lodash，这是最简单的事情:

_.countBy(array);

这样:

_.countBy([5, 5, 5, 2, 2, 2, 2, 2, 9, 4])
=> Object {2: 5, 4: 1, 5: 3, 9: 1}

正如其他人指出的那样，然后可以对结果执行_.keys()和_.values()函数，以分别获得唯一的数字及其出现次数。但根据我的经验，原始对象更容易处理。

我在codewars上解决了一个类似的问题，并设计了以下解决方案。

这将给出数组中整数的最高计数以及整数本身。我认为它也可以应用于字符串数组。

要正确地对字符串排序，请从sort()部分中删除函数(a, b){return a-b}

function mostFrequentItemCount(collection) {
    collection.sort(function(a, b){return a-b});
    var i=0;
    var ans=[];
    var int_ans=[];
    while(i<collection.length)
    {
        if(collection[i]===collection[i+1])
        {
            int_ans.push(collection[i]);
        }
        else
        {
            int_ans.push(collection[i]);
            ans.push(int_ans);
            int_ans=[];
        }
        i++;
    }

    var high_count=0;
    var high_ans;

    i=0;
    while(i<ans.length)
    {
        if(ans[i].length>high_count)
        {
            high_count=ans[i].length;
            high_ans=ans[i][0];
        }
        i++;
    }
    return high_ans;
}

这是一个经典的计算数组的方法。

var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
var counted = [], count = [];
var i = 0, j = 0, k = 0;
while (k < arr.length) {
    if (counted.indexOf(arr[k]) < 0) {
        counted[i] = arr[k];
        count[i] = 0;
        for (j = 0; j < arr.length; j++) {
            if (counted[i] == arr[j]) {
                count[i]++;
            }
        }
        i++;
    } else {
        k++;
    }
}

如果您希望得到字母顺序的结果，可以先对其排序，但如果您希望保留输入数据的顺序，则可以尝试这种方法。嵌套循环可能比本页上的其他一些方法要慢一些。

这个问题已经有8年的历史了，很多很多的答案都没有考虑到ES6及其众多的优势。

也许更重要的是，当我们创建额外的数组，创建数组的两倍或三倍副本，甚至将数组转换为对象时，考虑我们的代码对垃圾收集/内存管理的后果。对于小型应用来说，这些都是微不足道的观察结果，但如果规模化是一个长期目标，那么就要彻底考虑这些问题。

如果您只是需要一个特定数据类型的“计数器”，并且起点是一个数组(我假设您因此想要一个有序列表，并利用数组提供的许多属性和方法)，那么您只需简单地遍历array1，并用array1中找到的这些值的值和出现次数填充array2。

就这么简单。

面向对象编程和面向对象设计的简单类SimpleCounter (ES6)的示例

class SimpleCounter { 

    constructor(rawList){ // input array type
        this.rawList = rawList;
        this.finalList = [];
    }

    mapValues(){ // returns a new array

        this.rawList.forEach(value => {
            this.finalList[value] ? this.finalList[value]++ : this.finalList[value] = 1;
        });

        this.rawList = null; // remove array1 for garbage collection

        return this.finalList;

    }

}

module.exports = SimpleCounter;