blocks|key|930501|text|您可以使用对象来保存结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930502|​|930503|const+arr+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4];
const+counts+=+{};

for+(const+num+of+arr)+{
++counts[num]+=+counts[num]+?+counts[num]+%2B+1+:+1;
}

console.log(counts[5],+counts[2],+counts[9],+counts[4]);|code-block|syntax|javascript|930504|930505|现在，您的counts对象可以告诉您某个特定数字的计数：|offset|length|style|CODE|930506|console.log(counts[5]);+//+logs+'3'|930507|如果想要获取成员数组，只需使用keys()函数|930508|keys(counts);+//+returns+["5",+"2",+"9",+"4"]|930509|entityMap^0|0|0|0|0|5|6|0|0|F|6|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@$L|12|M|13|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|R|3|S|5|6|7|15|8|@$L|16|M|17|N|O]]|9|@]|A|$]]|$1|T|3|U|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|V|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|W|$]]

<p>You can use an object to hold the results:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
const counts = {};

for (const num of arr) {
  counts[num] = counts[num] ? counts[num] + 1 : 1;
}

console.log(counts[5], counts[2], counts[9], counts[4]);</code></pre>
</div>
</div>
</p>
<p>So, now your <code>counts</code> object can tell you what the count is for a particular number:</p>
<pre><code>console.log(counts[5]); // logs '3'
</code></pre>
<p>If you want to get an array of members, just use the <code>keys()</code> functions</p>
<pre><code>keys(counts); // returns [&quot;5&quot;, &quot;2&quot;, &quot;9&quot;, &quot;4&quot;]
</code></pre>


blocks|key|930598|text|不要为结果使用两个数组，使用一个对象：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930599|a++++++=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4];
result+=+{+};
for(var+i+=+0;+i+<+a.length;+%2B%2Bi)+{
++++if(!result[a[i]])
++++++++result[a[i]]+=+0;
++++%2B%2Bresult[a[i]];
}|code-block|syntax|javascript|930600|然后result将如下所示：|offset|length|style|CODE|930601|{
++++2:+5,
++++4:+1,
++++5:+3,
++++9:+1
}|930602|entityMap^0|0|0|2|6|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

<p>Don't use two arrays for the result, use an object:</p>

<pre><code>a      = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
result = { };
for(var i = 0; i &lt; a.length; ++i) {
    if(!result[a[i]])
        result[a[i]] = 0;
    ++result[a[i]];
}
</code></pre>

<p>Then <code>result</code> will look like:</p>

<pre><code>{
    2: 5,
    4: 1,
    5: 3,
    9: 1
}
</code></pre>


blocks|key|930604|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930605|const+arr+=+[2,+2,+5,+2,+2,+2,+4,+5,+5,+9];

function+foo+(array)+{
++let+a+=+[],
++++b+=+[],
++++arr+=+[...array],+//+clone+array+so+we+don't+change+the+original+when+using+.sort()
++++prev;

++arr.sort();
++for+(let+element+of+arr)+{
++++if+(element+!==+prev)+{
++++++a.push(element);
++++++b.push(1);
++++}
++++else+%2B%2Bb[b.length+-+1];
++++prev+=+element;
++}

++return+[a,+b];
}

const+result+=+foo(arr);
console.log('['+%2B+result[0]+%2B+']','['+%2B+result[1]+%2B+']')
console.log(arr)|code-block|syntax|javascript|930606|930607|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const arr = [2, 2, 5, 2, 2, 2, 4, 5, 5, 9];

function foo (array) {
  let a = [],
    b = [],
    arr = [...array], // clone array so we don't change the original when using .sort()
    prev;

  arr.sort();
  for (let element of arr) {
    if (element !== prev) {
      a.push(element);
      b.push(1);
    }
    else ++b[b.length - 1];
    prev = element;
  }

  return [a, b];
}

const result = foo(arr);
console.log('[' + result[0] + ']','[' + result[1] + ']')
console.log(arr)</code></pre>
</div>
</div>
</p>


blocks|key|930629|text|查看下面的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930630|<html>
<head>
<script>
//+array+with+values
var+ar+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4];

var+Unique+=+[];+//+we'll+store+a+list+of+unique+values+in+here
var+Counts+=+[];+//+we'll+store+the+number+of+occurances+in+here

for(var+i+in+ar)
{
++++var+Index+=+ar[i];
++++Unique[Index]+=+ar[i];
++++if(typeof(Counts[Index])=='undefined')++
++++++++Counts[Index]=1;
++++else
++++++++Counts[Index]%2B%2B;
}

//+remove+empty+items
Unique+=+Unique.filter(function(){+return+true});
Counts+=+Counts.filter(function(){+return+true});

alert(ar.join(','));
alert(Unique.join(','));
alert(Counts.join(','));

var+a=[];

for(var+i=0;+i<Unique.length;+i%2B%2B)
{
++++a.push(Unique[i]+%2B+':'+%2B+Counts[i]+%2B+'x');
}
alert(a.join(',+'));

</script>
</head>
<body>

</body>
</html>|code-block|syntax|javascript|930631|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Check out the code below.</p>

<pre><code>&lt;html&gt;
&lt;head&gt;
&lt;script&gt;
// array with values
var ar = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

var Unique = []; // we'll store a list of unique values in here
var Counts = []; // we'll store the number of occurances in here

for(var i in ar)
{
    var Index = ar[i];
    Unique[Index] = ar[i];
    if(typeof(Counts[Index])=='undefined')  
        Counts[Index]=1;
    else
        Counts[Index]++;
}

// remove empty items
Unique = Unique.filter(function(){ return true});
Counts = Counts.filter(function(){ return true});

alert(ar.join(','));
alert(Unique.join(','));
alert(Counts.join(','));

var a=[];

for(var i=0; i&lt;Unique.length; i++)
{
    a.push(Unique[i] + ':' + Counts[i] + 'x');
}
alert(a.join(', '));

&lt;/script&gt;
&lt;/head&gt;
&lt;body&gt;

&lt;/body&gt;
&lt;/html&gt;
</code></pre>


blocks|key|714634|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|714635|const+occurrences+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4].reduce(function+(acc,+curr)+{
++return+acc[curr]+?+%2B%2Bacc[curr]+:+acc[curr]+=+1,+acc
},+{});

console.log(occurrences)+//+=>+{2:+5,+4:+1,+5:+3,+9:+1}|code-block|syntax|javascript|714636|714637|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const occurrences = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4].reduce(function (acc, curr) {
  return acc[curr] ? ++acc[curr] : acc[curr] = 1, acc
}, {});

console.log(occurrences) // =&gt; {2: 5, 4: 1, 5: 3, 9: 1}</code></pre>
</div>
</div>
</p>


blocks|key|930750|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930751|Array.prototype.getItemCount+=+function(item)+{
++++var+counts+=+{};
++++for(var+i+=+0;+i<+this.length;+i%2B%2B)+{
++++++++var+num+=+this[i];
++++++++counts[num]+=+counts[num]+?+counts[num]%2B1+:+1;
++++}
++++return+counts[item]+%7C%7C+0;
}|code-block|syntax|javascript|930752|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Try this:</p>

<pre><code>Array.prototype.getItemCount = function(item) {
    var counts = {};
    for(var i = 0; i&lt; this.length; i++) {
        var num = this[i];
        counts[num] = counts[num] ? counts[num]+1 : 1;
    }
    return counts[item] || 0;
}
</code></pre>


blocks|key|930792|text|如果您使用下划线，则可以使用函数路线|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930793|a+=+['foo',+'foo',+'bar'];

var+results+=+_.reduce(a,function(counts,key){+counts[key]%2B%2B;+return+counts+},
++++++++++++++++++_.object(+_.map(+_.uniq(a),+function(key)+{+return+[key,+0]+})))|code-block|syntax|javascript|930794|所以你的第一个数组是|930795|_.keys(results)|930796|第二个数组是|930797|_.values(results)|930798|其中大部分将默认为原生javascript函数(如果可用)。|930799|演示：http://jsfiddle.net/dAaUU/|offset|length|930800|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/dAaUU/^0|0|0|0|0|0|0|0|3|Q|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@$S|1A|T|1B|1|1C]]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

<p>If you are using underscore you can go the functional route</p>

<pre><code>a = ['foo', 'foo', 'bar'];

var results = _.reduce(a,function(counts,key){ counts[key]++; return counts },
                  _.object( _.map( _.uniq(a), function(key) { return [key, 0] })))
</code></pre>

<p>so your first array is</p>

<pre><code>_.keys(results)
</code></pre>

<p>and the second array is</p>

<pre><code>_.values(results)
</code></pre>

<p>most of this will default to native javascript functions if they are available </p>

<p>demo : <a href="http://jsfiddle.net/dAaUU/">http://jsfiddle.net/dAaUU/</a></p>


blocks|key|930838|text|我认为这是计算数组中具有相同值的事件的最简单方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930839|var+a+=+[true,+false,+false,+false];
a.filter(function(value){
++++return+value+===+false;
}).length|code-block|syntax|javascript|930840|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I think this is the simplest way how to count occurrences with same value in array.</p>

<pre><code>var a = [true, false, false, false];
a.filter(function(value){
    return value === false;
}).length
</code></pre>


blocks|key|714894|text|如果使用下划线或加下划线，这是最简单的做法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|714895|_.countBy(array);|code-block|syntax|javascript|714896|这样：|714897|_.countBy([5,+5,+5,+2,+2,+2,+2,+2,+9,+4])
=>+Object+{2:+5,+4:+1,+5:+3,+9:+1}|714898|正如其他人所指出的，然后可以对结果执行_.keys()和_.values()函数，以分别获得唯一的数字和它们的匹配项。但根据我的经验，原始对象更容易处理。|offset|length|style|CODE|714899|entityMap^0|0|0|0|0|J|8|S|A|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

<p>If using underscore or lodash, this is the simplest thing to do:</p>

<pre><code>_.countBy(array);
</code></pre>

<p>Such that:</p>

<pre><code>_.countBy([5, 5, 5, 2, 2, 2, 2, 2, 9, 4])
=&gt; Object {2: 5, 4: 1, 5: 3, 9: 1}
</code></pre>

<p>As pointed out by others, you can then execute the <code>_.keys()</code> and <code>_.values()</code> functions on the result to get just the unique numbers, and their occurrences, respectively. But in my experience, the original object is much easier to deal with.</p>


blocks|key|930978|text|给定数组x即x+=+['boy','man','oldman','scout','pilot'];元素出现的次数'man'为|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|930979|x.length+-+x.toString().split(',man,').toString().split(',').length+;|code-block|syntax|javascript|930980|entityMap^0|6|17|1K|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

<p>Given array x
i.e <code>x = ['boy','man','oldman','scout','pilot'];</code>
number of occurrences of an element <code>'man'</code> is </p>

<pre><code>x.length - x.toString().split(',man,').toString().split(',').length ;
</code></pre>


blocks|key|931015|text|我正在解决一个类似的关于codewar的问题，并设计了下面的解决方案，它对我有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931016|这给出了数组中整数的最高计数以及整数本身。我认为它也可以应用于字符串数组。|931017|要对字符串进行正确排序，请从sort()部分中删除function(a,+b){return+a-b}|offset|length|style|CODE|931018|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%2B1])
++++++++{
++++++++++++int_ans.push(collection[i]);
++++++++}
++++++++else
++++++++{
++++++++++++int_ans.push(collection[i]);
++++++++++++ans.push(int_ans);
++++++++++++int_ans=[];
++++++++}
++++++++i%2B%2B;
++++}

++++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%2B%2B;
++++}
++++return+high_ans;
}|code-block|syntax|javascript|931019|entityMap^0|0|0|E|6|P|Q|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@$F|T|G|U|H|I]|$F|V|G|W|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

<p>I was solving a similar problem on codewars and devised the following solution which worked for me.</p>

<p>This gives the highest count of an integer in an array and also the integer itself. I think it can be applied to string array as well.  </p>

<p>To properly sort Strings, remove the <code>function(a, b){return a-b}</code> from inside the <code>sort()</code> portion</p>

<pre><code>function mostFrequentItemCount(collection) {
    collection.sort(function(a, b){return a-b});
    var i=0;
    var ans=[];
    var int_ans=[];
    while(i&lt;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&lt;ans.length)
    {
        if(ans[i].length&gt;high_count)
        {
            high_count=ans[i].length;
            high_ans=ans[i][0];
        }
        i++;
    }
    return high_ans;
}
</code></pre>


blocks|key|715053|text|这是一个经典的计算数组的传统方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|715054|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%2B%2B)+{
++++++++++++if+(counted[i]+==+arr[j])+{
++++++++++++++++count[i]%2B%2B;
++++++++++++}
++++++++}
++++++++i%2B%2B;
++++}+else+{
++++++++k%2B%2B;
++++}
}|code-block|syntax|javascript|715055|如果您想要字母顺序的结果，可以先对其进行排序，但如果您想保留输入数据的顺序，请尝试此操作。嵌套循环可能比此页面上的其他一些方法慢一点。|715056|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>Here's a classic old school method for counting arrays.</p>

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

<p>You can sort it first if you want an alphabetical result, but if you want to preserve the order in which the data was entered then give this a try. Nested loops may be a bit slower than some of the other methods on this page.</p>


blocks|key|715061|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|715062|const+data+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4]

function+count(arr)+{
++return+arr.reduce((prev,+curr)+=>+(prev[curr]+=+%2B%2Bprev[curr]+%7C%7C+1,+prev),+{})
}

console.log(count(data))|code-block|syntax|javascript|715063|715064|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const data = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

function count(arr) {
  return arr.reduce((prev, curr) =&gt; (prev[curr] = ++prev[curr] || 1, prev), {})
}

console.log(count(data))</code></pre>
</div>
</div>
</p>


blocks|key|931131|text|有一种更好、更简单的方法，我们可以使用ramda.js来做这件事。Code+sample+here|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|931132|documentation上提供了const+ary+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4];+R.countBy(r=>+r)(ary)+countBy文档|931133|entityMap|0|LINK|mutability|MUTABLE|url|http://ramdajs.com/repl/?v=0.23.0#?const%2520ary%2520%253D%2520%255B5%252C%25205%252C%25205%252C%25202%252C%25202%252C%25202%252C%25202%252C%25202%252C%25209%252C%25204%255D%253B%250AR.countBy%2528r%253D%253E%2520r%2529%2528ary%2529|1|http://ramdajs.com/docs/#countBy^0|J|8|X|G|0|0|H|1T|0|D|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]]|E|$]]|$1|H|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

<p>There is a much better and easy way that we can do this using <code>ramda.js</code>.
<a href="http://ramdajs.com/repl/?v=0.23.0#?const%20ary%20%3D%20%5B5%2C%205%2C%205%2C%202%2C%202%2C%202%2C%202%2C%202%2C%209%2C%204%5D%3B%0AR.countBy%28r%3D%3E%20r%29%28ary%29" rel="nofollow noreferrer">Code sample here</a></p>

<p><code>const ary = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
R.countBy(r=&gt; r)(ary)
</code>
countBy documentation is at <a href="http://ramdajs.com/docs/#countBy" rel="nofollow noreferrer">documentation</a></p>


blocks|key|931199|text|这是一种计算对象数组内出现次数的方法。它还将第一个数组的内容放在一个新数组中，以便对值进行排序，这样原始数组中的顺序就不会被打乱。然后使用递归函数遍历每个元素，并计算数组中每个对象的数量属性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931200|var+big_array+=+[
++{+name:+"Pineapples",+quantity:+3+},
++{+name:+"Pineapples",+quantity:+1+},
++{+name:+"Bananas",+quantity:+1+},
++{+name:+"Limes",+quantity:+1+},
++{+name:+"Bananas",+quantity:+1+},
++{+name:+"Pineapples",+quantity:+2+},
++{+name:+"Pineapples",+quantity:+1+},
++{+name:+"Bananas",+quantity:+1+},
++{+name:+"Bananas",+quantity:+1+},
++{+name:+"Bananas",+quantity:+5+},
++{+name:+"Coconuts",+quantity:+1+},
++{+name:+"Lemons",+quantity:+2+},
++{+name:+"Oranges",+quantity:+1+},
++{+name:+"Lemons",+quantity:+1+},
++{+name:+"Limes",+quantity:+1+},
++{+name:+"Grapefruit",+quantity:+1+},
++{+name:+"Coconuts",+quantity:+5+},
++{+name:+"Oranges",+quantity:+6+}
];

function+countThem()+{
++var+names_array+=+[];
++for+(var+i+=+0;+i+<+big_array.length;+i%2B%2B)+{
++++names_array.push(+Object.assign({},+big_array[i])+);
++}

++function+outerHolder(item_array)+{
++++if+(item_array.length+>+0)+{
++++++var+occurrences+=+[];
++++++var+counter+=+0;
++++++var+bgarlen+=+item_array.length;
++++++item_array.sort(function(a,+b)+{+return+(a.name+>+b.name)+?+1+:+((b.name+>+a.name)+?+-1+:+0);+});

++++++function+recursiveCounter()+{
++++++++occurrences.push(item_array[0]);
++++++++item_array.splice(0,+1);
++++++++var+last_occurrence_element+=+occurrences.length+-+1;
++++++++var+last_occurrence_entry+=+occurrences[last_occurrence_element].name;
++++++++var+occur_counter+=+0;
++++++++var+quantity_counter+=+0;
++++++++for+(var+i+=+0;+i+<+occurrences.length;+i%2B%2B)+{
++++++++++if+(occurrences[i].name+===+last_occurrence_entry)+{
++++++++++++occur_counter+=+occur_counter+%2B+1;
++++++++++++if+(occur_counter+===+1)+{
++++++++++++++quantity_counter+=+occurrences[i].quantity;
++++++++++++}+else+{
++++++++++++++quantity_counter+=+quantity_counter+%2B+occurrences[i].quantity;
++++++++++++}
++++++++++}
++++++++}

++++++++if+(occur_counter+>+1)+{
++++++++++var+current_match+=+occurrences.length+-+2;
++++++++++occurrences[current_match].quantity+=+quantity_counter;
++++++++++occurrences.splice(last_occurrence_element,+1);
++++++++}

++++++++counter+=+counter+%2B+1;

++++++++if+(counter+<+bgarlen)+{
++++++++++recursiveCounter();
++++++++}
++++++}

++++++recursiveCounter();

++++++return+occurrences;
++++}
++}
++alert(JSON.stringify(outerHolder(names_array)));
}|code-block|syntax|javascript|931201|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here is a way to count occurrences inside an array of objects. It also places the first array's contents inside a new array to sort the values so that the order in the original array is not disrupted. Then a recursive function is used to go through each element and count the quantity property of each object inside the array.</p>

<pre><code>var big_array = [
  { name: "Pineapples", quantity: 3 },
  { name: "Pineapples", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Limes", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Pineapples", quantity: 2 },
  { name: "Pineapples", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Bananas", quantity: 5 },
  { name: "Coconuts", quantity: 1 },
  { name: "Lemons", quantity: 2 },
  { name: "Oranges", quantity: 1 },
  { name: "Lemons", quantity: 1 },
  { name: "Limes", quantity: 1 },
  { name: "Grapefruit", quantity: 1 },
  { name: "Coconuts", quantity: 5 },
  { name: "Oranges", quantity: 6 }
];

function countThem() {
  var names_array = [];
  for (var i = 0; i &lt; big_array.length; i++) {
    names_array.push( Object.assign({}, big_array[i]) );
  }

  function outerHolder(item_array) {
    if (item_array.length &gt; 0) {
      var occurrences = [];
      var counter = 0;
      var bgarlen = item_array.length;
      item_array.sort(function(a, b) { return (a.name &gt; b.name) ? 1 : ((b.name &gt; a.name) ? -1 : 0); });

      function recursiveCounter() {
        occurrences.push(item_array[0]);
        item_array.splice(0, 1);
        var last_occurrence_element = occurrences.length - 1;
        var last_occurrence_entry = occurrences[last_occurrence_element].name;
        var occur_counter = 0;
        var quantity_counter = 0;
        for (var i = 0; i &lt; occurrences.length; i++) {
          if (occurrences[i].name === last_occurrence_entry) {
            occur_counter = occur_counter + 1;
            if (occur_counter === 1) {
              quantity_counter = occurrences[i].quantity;
            } else {
              quantity_counter = quantity_counter + occurrences[i].quantity;
            }
          }
        }

        if (occur_counter &gt; 1) {
          var current_match = occurrences.length - 2;
          occurrences[current_match].quantity = quantity_counter;
          occurrences.splice(last_occurrence_element, 1);
        }

        counter = counter + 1;

        if (counter &lt; bgarlen) {
          recursiveCounter();
        }
      }

      recursiveCounter();

      return occurrences;
    }
  }
  alert(JSON.stringify(outerHolder(names_array)));
}
</code></pre>


blocks|key|931269|text|ES6版本应该更简单(另一种单行解决方案)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931270|let+arr+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4];
let+acc+=+arr.reduce((acc,+val)+=>+acc.set(val,+1+%2B+(acc.get(val)+%7C%7C+0)),+new+Map());

console.log(acc);
//+output:+Map+{+5+=>+3,+2+=>+5,+9+=>+1,+4+=>+1+}|code-block|syntax|javascript|931271|一个Map而不是普通的对象帮助我们区分不同类型的元素，否则所有的计数都是基于字符串的|931272|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>ES6 version should be much simplifier (another one line solution)</p>

<pre class="lang-js prettyprint-override"><code>let arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
let acc = arr.reduce((acc, val) =&gt; acc.set(val, 1 + (acc.get(val) || 0)), new Map());

console.log(acc);
// output: Map { 5 =&gt; 3, 2 =&gt; 5, 9 =&gt; 1, 4 =&gt; 1 }
</code></pre>

<p>A Map instead of plain Object helping us to distinguish different type of elements, or else all counting are base on strings</p>


blocks|key|931292|text|function+countOcurrences(arr){
++++return+arr.reduce((aggregator,+value,+index,+array)+=>+{
++++++if(!aggregator[value]){
++++++++return+aggregator+=+{...aggregator,+[value]:+1};++
++++++}else{
++++++++return+aggregator+=+{...aggregator,+[value]:%2B%2Baggregator[value]};
++++++}
++++},+{})
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|931293|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function countOcurrences(arr){
    return arr.reduce((aggregator, value, index, array) =&gt; {
      if(!aggregator[value]){
        return aggregator = {...aggregator, [value]: 1};  
      }else{
        return aggregator = {...aggregator, [value]:++aggregator[value]};
      }
    }, {})
}
</code></pre>


blocks|key|715332|text|使用过滤器很简单|type|unstyled|depth|inlineStyleRanges|entityRanges|data|715333|在本例中，我们只需指定count，即根据您要查找的键过滤的数组的长度|715334|let+array+=+[{name:+"steve",+age:+22},+{name:+"bob",+age:+30}]

let+count+=+array.filter(obj+=>+obj.name+===+obj.name).length

console.log(count)|code-block|syntax|javascript|715335|有关JS过滤器的更多信息，请单击此处https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter|offset|length|715336|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter^0|0|0|0|I|2L|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

<p>Its easy with filter</p>

<p>In this example we simply assign count, the length of the array filtered by the key you're looking for</p>

<pre><code>let array = [{name: "steve", age: 22}, {name: "bob", age: 30}]

let count = array.filter(obj =&gt; obj.name === obj.name).length

console.log(count)
</code></pre>

<p>more on JS Filiters here <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter" rel="nofollow noreferrer">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter</a></p>


blocks|key|931396|text|下面是我如何使用一些最新的javascript特性来实现的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931397|首先，将数组减少为计数的Map：|offset|length|style|CODE|931398|let+countMap+=+array.reduce(
++(map,+value)+=>+{map.set(value,+(map.get(value)+%7C%7C+0)+%2B+1);+return+map},+
++new+Map()
)|code-block|syntax|javascript|931399|通过使用Map，起始数组可以包含任何类型的对象，并且计数将是正确的。如果没有Map，某些类型的对象会给出奇怪的计数。有关差异的更多信息，请参阅Map+docs。|931400|如果所有值都是符号、数字或字符串，也可以对对象执行此操作：|931401|let+countObject+=+array.reduce(
++(map,+value)+=>+{+map[value]+=+(map[value]+%7C%7C+0)+%2B+1;+return+map+},
++{}
)|931402|或者使用解构和对象扩展语法，以没有突变的函数式方式稍微有点花哨：|931403|let+countObject+=+array.reduce(
++(value,+{[value]:+count+=+0,+...rest})+=>+({+[value]:+count+%2B+1,+...rest+}),
++{}
)|931404|此时，您可以使用Map或object进行计数(与object不同，map是直接可迭代的)，或者将其转换为两个数组。|931405|对于Map|931406|countMap.forEach((count,+value)+=>+console.log(`value:+${value},+count:+${count}`)

let+values+=+countMap.keys()
let+counts+=+countMap.values()|931407|或者对于对象：|931408|Object
++.entries(countObject)+//+convert+to+array+of+[key,+valueAtKey]+pairs
++.forEach(([value,+count])+=>+console.log(`value:+${value},+count:+${count}`)

let+values+=+Object.keys(countObject)
let+counts+=+Object.values(countObject)|931409|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map|1^0|0|C|3|C|3|0|0|0|4|3|12|3|1Z|3|1Z|8|1|0|0|0|0|0|8|3|0|2|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1G|8|@$D|1H|E|1I|F|G]]|9|@$D|1J|E|1K|1|1L]]|A|$]]|$1|H|3|I|5|J|7|1M|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1N|8|@$D|1O|E|1P|F|G]|$D|1Q|E|1R|F|G]|$D|1S|E|1T|F|G]]|9|@$D|1U|E|1V|1|1W]]|A|$]]|$1|O|3|P|5|6|7|1X|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|U|3|V|5|J|7|20|8|@]|9|@]|A|$K|L]]|$1|W|3|X|5|6|7|21|8|@$D|22|E|23|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|24|8|@$D|25|E|26|F|G]]|9|@]|A|$]]|$1|10|3|11|5|J|7|27|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|28|8|@]|9|@]|A|$]]|$1|14|3|15|5|J|7|29|8|@]|9|@]|A|$K|L]]|$1|16|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]]|17|$18|$5|19|1A|1B|A|$1C|1D]]|1E|$5|19|1A|1B|A|$1C|1D]]]]

<p>So here's how I'd do it with some of the newest javascript features:</p>

<p>First, reduce the array to a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map" rel="nofollow noreferrer"><code>Map</code></a> of the counts:</p>

<pre><code>let countMap = array.reduce(
  (map, value) =&gt; {map.set(value, (map.get(value) || 0) + 1); return map}, 
  new Map()
)
</code></pre>

<p>By using a <code>Map</code>, your starting array can contain any type of object, and the counts will be correct. Without a <code>Map</code>, some types of objects will give you strange counts.
See the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map" rel="nofollow noreferrer"><code>Map</code> docs</a> for more info on the differences.</p>

<p>This could also be done with an object if all your values are symbols, numbers, or strings:</p>

<pre><code>let countObject = array.reduce(
  (map, value) =&gt; { map[value] = (map[value] || 0) + 1; return map },
  {}
)
</code></pre>

<p>Or slightly fancier in a functional way without mutation, using destructuring and object spread syntax:</p>

<pre><code>let countObject = array.reduce(
  (value, {[value]: count = 0, ...rest}) =&gt; ({ [value]: count + 1, ...rest }),
  {}
)
</code></pre>

<p>At this point, you can use the <code>Map</code> or object for your counts (and the map is directly iterable, unlike an object), or convert it to two arrays.</p>

<p>For the <code>Map</code>:</p>

<pre><code>countMap.forEach((count, value) =&gt; console.log(`value: ${value}, count: ${count}`)

let values = countMap.keys()
let counts = countMap.values()
</code></pre>

<p>Or for the object:</p>

<pre><code>Object
  .entries(countObject) // convert to array of [key, valueAtKey] pairs
  .forEach(([value, count]) =&gt; console.log(`value: ${value}, count: ${count}`)

let values = Object.keys(countObject)
let counts = Object.values(countObject)
</code></pre>


blocks|key|715434|text|我对ramda的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|715435|const+testArray+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4]

const+counfFrequency+=+R.compose(
++R.map(R.length),
++R.groupBy(R.identity),
)

counfFrequency(testArray)|code-block|syntax|javascript|715436|Link+to+REPL.|offset|length|715437|entityMap|0|LINK|mutability|MUTABLE|url|https://ramdajs.com/repl/?v=0.26.1#?const%2520testArray%2520%253D%2520%255B5%252C%25205%252C%25205%252C%25202%252C%25202%252C%25202%252C%25202%252C%25202%252C%25209%252C%25204%255D%250A%250Aconst%2520counfFrequency%2520%253D%2520R.compose%2528%250A%2520%2520R.map%2528R.length%2529%252C%250A%2520%2520R.groupBy%2528R.identity%2529%252C%250A%2529%250A%250AcounfFrequency%2528testArray%2529^0|0|0|0|D|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>My solution with ramda:</p>

<pre><code>const testArray = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

const counfFrequency = R.compose(
  R.map(R.length),
  R.groupBy(R.identity),
)

counfFrequency(testArray)
</code></pre>

<p><a href="https://ramdajs.com/repl/?v=0.26.1#?const%20testArray%20%3D%20%5B5%2C%205%2C%205%2C%202%2C%202%2C%202%2C%202%2C%202%2C%209%2C%204%5D%0A%0Aconst%20counfFrequency%20%3D%20R.compose%28%0A%20%20R.map%28R.length%29%2C%0A%20%20R.groupBy%28R.identity%29%2C%0A%29%0A%0AcounfFrequency%28testArray%29" rel="nofollow noreferrer">Link to REPL.</a></p>


blocks|key|931454|text|var+aa+=+[1,3,5,7,3,2,4,6,8,1,3,5,5,2,0,6,5,9,6,3,5,2,5,6,8];
var+newArray+=+{};
for(var+element+of+aa){
++if(typeof+newArray[element]+===+'undefined'+%7C%7C+newArray[element]+===+null){
++++newArray[element]+=+1;
++}else{
++++newArray[element]+%2B=1;
++}
}

for+(+var+element+in+newArray){
++console.log(+element+%2B"+->+"%2B+newArray[element]);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|931455|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var aa = [1,3,5,7,3,2,4,6,8,1,3,5,5,2,0,6,5,9,6,3,5,2,5,6,8];
var newArray = {};
for(var element of aa){
  if(typeof newArray[element] === 'undefined' || newArray[element] === null){
    newArray[element] = 1;
  }else{
    newArray[element] +=1;
  }
}

for ( var element in newArray){
  console.log( element +" -&gt; "+ newArray[element]);
}
</code></pre>


blocks|key|931512|text|单行ES6解决方案。这么多答案使用object作为地图，但我看不到任何人使用实际的Map|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|931513|const+map+=+arr.reduce((acc,+e)+=>+acc.set(e,+(acc.get(e)+%7C%7C+0)+%2B+1),+new+Map());|code-block|syntax|javascript|931514|使用map.keys()获取唯一元素|style|CODE|931515|使用map.values()获取匹配项|931516|使用map.entries()获取配对元素、频率|931517|​|931518|var+arr+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4]

const+map+=+arr.reduce((acc,+e)+=>+acc.set(e,+(acc.get(e)+%7C%7C+0)+%2B+1),+new+Map());

console.info([...map.keys()])
console.info([...map.values()])
console.info([...map.entries()])|931519|931520|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys|2|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values|3|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries^0|15|3|0|0|0|2|A|2|A|1|0|2|C|2|C|2|0|2|D|2|D|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@$A|1A|B|1B|1|1C]]|C|$]]|$1|D|3|E|5|F|7|1D|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1E|8|@$A|1F|B|1G|K|L]]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|M|3|N|5|6|7|1K|8|@$A|1L|B|1M|K|L]]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|O|3|P|5|6|7|1Q|8|@$A|1R|B|1S|K|L]]|9|@$A|1T|B|1U|1|1V]]|C|$]]|$1|Q|3|R|5|6|7|1W|8|@]|9|@]|C|$]]|$1|S|3|T|5|F|7|1X|8|@]|9|@]|C|$G|H]]|$1|U|3|R|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|V|3|-4|5|6|7|1Z|8|@]|9|@]|C|$]]]|W|$X|$5|Y|Z|10|C|$11|12]]|13|$5|Y|Z|10|C|$11|14]]|15|$5|Y|Z|10|C|$11|16]]|17|$5|Y|Z|10|C|$11|18]]]]

<p>One line ES6 solution. So many answers using object as a map but I can't see anyone using an actual <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map" rel="noreferrer">Map</a></p>

<pre><code>const map = arr.reduce((acc, e) =&gt; acc.set(e, (acc.get(e) || 0) + 1), new Map());
</code></pre>

<p>Use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys" rel="noreferrer"><code>map.keys()</code></a> to get unique elements</p>

<p>Use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values" rel="noreferrer"><code>map.values()</code></a> to get the occurrences</p>

<p>Use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries" rel="noreferrer"><code>map.entries()</code></a> to get the pairs [element, frequency]</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

const map = arr.reduce((acc, e) =&gt; acc.set(e, (acc.get(e) || 0) + 1), new Map());

console.info([...map.keys()])
console.info([...map.values()])
console.info([...map.entries()])</code></pre>
</div>
</div>
</p>


blocks|key|931674|text|使用Lodash|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931675|​|931676|const+values+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4];
const+frequency+=+_.map(_.groupBy(values),+val+=>+({+value:+val[0],+frequency:+val.length+}));
console.log(frequency);|code-block|syntax|javascript|931677|<script+src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>|931678|931679|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|K|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

<p>Using Lodash</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const values = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
const frequency = _.map(_.groupBy(values), val =&gt; ({ value: val[0], frequency: val.length }));
console.log(frequency);</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"&gt;&lt;/script&gt;</code></pre>
</div>
</div>
</p>


blocks|key|931716|text|给定下面提供的数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931717|const+array+=+[+'a',+'b',+'b',+'c',+'c',+'c'+];|code-block|syntax|javascript|931718|您可以使用这个简单的一行代码来生成一个散列映射，该映射将一个键链接到它在数组中出现的次数：|931719|const+hash+=+Object.fromEntries([+...array.reduce((map,+key)+=>+map.set(key,+(map.get(key)+%7C%7C+0)+%2B+1),+new+Map())+]);
//+{+a:+1,+b:+2,+c:+3+}|931720|扩展和解释：|931721|//+first,+we+use+reduce+to+generate+a+map+with+values+and+the+amount+of+times+they+appear
const+map+=+array.reduce((map,+key)+=>+map.set(key,+(map.get(key)+%7C%7C+0)+%2B+1),+new+Map())

//+next,+we+spread+this+map+into+an+array
const+table+=+[+...map+];

//+finally,+we+use+Object.fromEntries+to+generate+an+object+based+on+this+entry+table
const+result+=+Object.fromEntries(table);|931722|array.reduce代码归功于@corashina|offset|length|style|CODE|931723|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/7306664/corashina^0|0|0|0|0|0|0|0|C|H|A|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@$Q|19|R|1A|S|T]]|9|@$Q|1B|R|1C|1|1D]]|A|$]]|$1|U|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

<p>Given the array supplied below:</p>
<pre class="lang-js prettyprint-override"><code>const array = [ 'a', 'b', 'b', 'c', 'c', 'c' ];
</code></pre>
<p>You can use this simple one-liner to generate a hash map which links a key to the number of times it appears in the array:</p>
<pre class="lang-js prettyprint-override"><code>const hash = Object.fromEntries([ ...array.reduce((map, key) =&gt; map.set(key, (map.get(key) || 0) + 1), new Map()) ]);
// { a: 1, b: 2, c: 3 }
</code></pre>
<p>Expanded &amp; Explained:</p>
<pre class="lang-js prettyprint-override"><code>// first, we use reduce to generate a map with values and the amount of times they appear
const map = array.reduce((map, key) =&gt; map.set(key, (map.get(key) || 0) + 1), new Map())

// next, we spread this map into an array
const table = [ ...map ];

// finally, we use Object.fromEntries to generate an object based on this entry table
const result = Object.fromEntries(table);
</code></pre>
<p>credit to <a href="https://stackoverflow.com/users/7306664/corashina">@corashina</a> for the <code>array.reduce</code> code</p>


blocks|key|715712|text|我知道这个问题有点老了，但我意识到只用最少的代码就能得到计数数组的解决方案太少了，所以下面是我的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|715713|//+The+initial+array+we+want+to+count+occurences
var+initial+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4];++

//+The+count+array+asked+for
var+count+=+Array.from(new+Set(initial)).map(val+=>+initial.filter(v+=>+v+===+val).length);++

//+Outputs+[+3,+5,+1,+1+]|code-block|syntax|javascript|715714|此外，您还可以使用以下命令从该初始数组中获取集合|715715|var+set+=+Array.from(new+Set(initial));++

//set+=+[5,+2,+9,+4]++|715716|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>I know this question is old but I realized there are too few solutions where you get the count array as asked with a minimal code so here is mine</p>
<pre class="lang-js prettyprint-override"><code>// The initial array we want to count occurences
var initial = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];  

// The count array asked for
var count = Array.from(new Set(initial)).map(val =&gt; initial.filter(v =&gt; v === val).length);  

// Outputs [ 3, 5, 1, 1 ]
</code></pre>
<p>Beside you can get the set from that initial array with</p>
<pre class="lang-js prettyprint-override"><code>var set = Array.from(new Set(initial));  

//set = [5, 2, 9, 4]  
</code></pre>


blocks|key|931821|text|较短的版本使用reduce和代字号(~)运算符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|931822|​|931823|const+data+=+[2,+2,+2,+2,+2,+4,+5,+5,+5,+9];

function+freq(nums)+{
++return+nums.reduce((acc,+curr)+=>+{
++++acc[curr]+=+-~acc[curr];
++++return+acc;
++},+{});
}

console.log(freq(data));|code-block|syntax|javascript|931824|931825|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce^0|7|6|I|1|7|6|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|15|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]]]

<p>A shorter version use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce" rel="nofollow noreferrer"><code>reduce</code></a> and tilde (<code>~</code>) operator.</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const data = [2, 2, 2, 2, 2, 4, 5, 5, 5, 9];

function freq(nums) {
  return nums.reduce((acc, curr) =&gt; {
    acc[curr] = -~acc[curr];
    return acc;
  }, {});
}

console.log(freq(data));</code></pre>
</div>
</div>
</p>


blocks|key|931856|text|似乎问题特别要求有两个结果数组，我还没有见过，所以这是我的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931857|const+theArray+=+[1,+3425,+56,+7,+9,+5,+4,+3425,+7,+7,+7];

const+uniqueVals+=+[...new+Set(theArray)];
const+countPerUniqueValArray+=+uniqueVals.map(uv+=>+theArray.filter(i+=>+i+===+uv).length);

console.log(uniqueVals);
console.log(countPerUniqueValArray);

//+Expect:
//+[1,+3425,+56,+7,+9,+5,+4]
//+[1,+2,+1,+4,+1,+1,+1]|code-block|syntax|javascript|931858|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>It seems like the questions specifically asks to have two resulting arrays, which I haven't seen, so here's my solution:</p>
<pre><code>const theArray = [1, 3425, 56, 7, 9, 5, 4, 3425, 7, 7, 7];

const uniqueVals = [...new Set(theArray)];
const countPerUniqueValArray = uniqueVals.map(uv =&gt; theArray.filter(i =&gt; i === uv).length);

console.log(uniqueVals);
console.log(countPerUniqueValArray);

// Expect:
// [1, 3425, 56, 7, 9, 5, 4]
// [1, 2, 1, 4, 1, 1, 1]
</code></pre>


blocks|key|715823|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|715824|const+data+=+[5,+5,+5,+2,+2,+2,+2,+2,+9,+4]+
function+countAndSort(arr)+{+
++++return+Object.entries(arr.reduce((prev,+curr)+=>+(prev[curr]+=+%2B%2Bprev[curr]+%7C%7C+1,+prev),+{})).sort((a,b)+=>+b[1]-a[1])
}+
console.log(countAndSort(data))|code-block|syntax|javascript|715825|715826|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const data = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4] 
function countAndSort(arr) { 
    return Object.entries(arr.reduce((prev, curr) =&gt; (prev[curr] = ++prev[curr] || 1, prev), {})).sort((a,b) =&gt; b[1]-a[1])
} 
console.log(countAndSort(data))</code></pre>
</div>
</div>
</p>


<p>In Javascript, I'm trying to take an initial array of number values and count the elements inside it. Ideally, the result would be two new arrays, the first specifying each unique element, and the second containing the number of times each element occurs. However, I'm open to suggestions on the format of the output.</p>

<p>For example, if the initial array was:</p>

<pre><code>5, 5, 5, 2, 2, 2, 2, 2, 9, 4
</code></pre>

<p>Then two new arrays would be created. The first would contain the name of each unique element:</p>

<pre><code>5, 2, 9, 4
</code></pre>

<p>The second would contain the number of times that element occurred in the initial array:</p>

<pre><code>3, 5, 1, 1
</code></pre>

<p>Because the number 5 occurs three times in the initial array, the number 2 occurs five times and 9 and 4 both appear once.</p>

<p>I've searched a lot for a solution, but nothing seems to work, and everything I've tried myself has wound up being ridiculously complex. Any help would be appreciated!</p>

<p>Thanks :)</p>


Counting the occurrences / frequency of array elements

JSON

在Javascript中，我尝试获取一个初始的数值数组，并对其中的元素进行计数。理想情况下，结果应该是两个新数组，第一个指定每个唯一的元素，第二个包含每个元素出现的次数。但是，我对输出格式的建议持开放态度。例如，如果初始数组为：5, 5, 5, 2, 2, 2, 2, 2, 9, 4然后将创建两个新的数组。第一个将包含...

问统计数组元素的出现次数/频率
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问统计数组元素的出现次数/频率EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问统计数组元素的出现次数/频率
EN