如果你喜欢单线。

加勒比海盗。reduce(function(countMap, word) {countMap[word] = ++countMap[word] || 1;return countMap}， {});

编辑(6/12/2015): 由内而外的解释。 countMap是一个映射一个单词的频率的映射，我们可以看到匿名函数。reduce所做的是应用带有参数的函数作为所有数组元素，并将countMap作为最后一次函数调用的返回值传递。最后一个参数({})是第一次函数调用时countMap的默认值。

如果你喜欢单线。

加勒比海盗。reduce(function(countMap, word) {countMap[word] = ++countMap[word] || 1;return countMap}， {});

编辑(6/12/2015): 由内而外的解释。 countMap是一个映射一个单词的频率的映射，我们可以看到匿名函数。reduce所做的是应用带有参数的函数作为所有数组元素，并将countMap作为最后一次函数调用的返回值传递。最后一个参数({})是第一次函数调用时countMap的默认值。

我在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;
}

这个问题已经有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;

您可以通过使用count函数扩展数组来简化这一点。它的工作原理类似于Ruby的array# count，如果你熟悉它的话。

Array.prototype.count = function(obj){
  var count = this.length;
  if(typeof(obj) !== "undefined"){
    var array = this.slice(0), count = 0; // clone array and reset count
    for(i = 0; i < array.length; i++){
      if(array[i] == obj){ count++ }
    }
  }
  return count;
}

用法:

let array = ['a', 'b', 'd', 'a', 'c'];
array.count('a'); // => 2
array.count('b'); // => 1
array.count('e'); // => 0
array.count(); // => 5

Gist

Edit

然后你可以使用array# filter获取你的第一个数组，包含每个出现的项:

let occurred = [];
array.filter(function(item) {
  if (!occurred.includes(item)) {
    occurred.push(item);
    return true;
  }
}); // => ["a", "b", "d", "c"]

你的第二个数组，使用数组#count到数组#map:

occurred.map(array.count.bind(array)); // => [2, 1, 1, 1]

或者，如果顺序无关紧要，你可以直接返回一个键值对:

let occurrences = {}
occurred.forEach(function(item) { occurrences[item] = array.count(item) });
occurences; // => {2: 5, 4: 1, 5: 3, 9: 1}

Const data = [5,5,5,2,2,2,2,2,2,2,2,9,4] 函数countAndSort(arr) { 返回Object.entries(加勒比海盗。减少((上一页,咕咕叫)= >(上一页[咕咕叫]= + +上一页[咕咕叫]| | 1,上一页),{})).sort (b (a, b) = >[1]——[1]) ｝ console.log (countAndSort(数据)