在Javascript中，我试图获取一个数字值的初始数组并计算其中的元素。理想情况下，结果将是两个新数组，第一个指定每个唯一元素，第二个包含每个元素出现的次数。但是，我愿意接受有关输出格式的建议。
例如，如果初始数组是：
5, 5, 5, 2, 2, 2, 2, 2, 9, 4
然后将创建两个新阵列。第一个将包含每个唯一元素的名称：
5, 2, 9, 4
第二个将包含元素在初始数组中出现的次数：
3, 5, 1, 1
因为数字5在初始数组中出现三次，所以数字2出现五次，9和4出现一次。
我经常搜索一个解决方案，但似乎没有任何工作，我自己尝试过的所有事情都变得非常复杂。任何帮助将不胜感激！
谢谢：）
答案 0 :(得分：183)
您可以使用对象来保存结果：
var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
var counts = {};
for (var i = 0; i < arr.length; i++) {
var num = arr[i];
counts[num] = counts[num] ? counts[num] + 1 : 1;
}
console.log(counts[5], counts[2], counts[9], counts[4]);
所以，现在你的计数对象可以告诉你特定数字的计数是什么：
console.log(counts[5]); // logs '3'
如果您想获得一系列成员，只需使用keys()函数
keys(counts); // returns ["5", "2", "9", "4"]
答案 1 :(得分：76)
你走了：
function foo(arr) {
var a = [], b = [], prev;
arr.sort();
for ( var i = 0; i < arr.length; i++ ) {
if ( arr[i] !== prev ) {
a.push(arr[i]);
b.push(1);
} else {
b[b.length-1]++;
}
prev = arr[i];
}
return [a, b];
}
现场演示： http://jsfiddle.net/simevidas/bnACW/
注意
这会使用
更改原始输入数组的顺序Array.sort
答案 2 :(得分：76)
var a = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4].reduce(function (acc, curr) {
if (typeof acc[curr] == 'undefined') {
acc[curr] = 1;
} else {
acc[curr] += 1;
}
return acc;
}, {});
// a == {2: 5, 4: 1, 5: 3, 9: 1}
答案 3 :(得分：64)
如果使用下划线或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()函数，以分别获得唯一的数字及其出现次数。但根据我的经验，原始对象更容易处理。
答案 4 :(得分：51)
不要使用两个数组作为结果，使用对象：
a = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
result = { };
for(var i = 0; i < a.length; ++i) {
if(!result[a[i]])
result[a[i]] = 0;
++result[a[i]];
}
然后result将如下所示：
{
2: 5,
4: 1,
5: 3,
9: 1
}
答案 5 :(得分：35)
ECMAScript2015选项怎么样。
const a = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
const aCount = new Map([...new Set(a)].map(
x => [x, a.filter(y => y === x).length]
));
aCount.get(5) // 3
aCount.get(2) // 5
aCount.get(9) // 1
aCount.get(4) // 1
此示例将输入数组传递给Set构造函数，以创建唯一值的集合。 spread syntax然后将这些值扩展为一个新数组，以便我们可以调用map并将其转换为[value, count]对的二维数组 - 即以下结构：
Array [
[5, 3],
[2, 5],
[9, 1],
[4, 1]
]
然后将新数组传递给Map构造函数，生成iterable对象：
Map {
5 => 3,
2 => 5,
9 => 1,
4 => 1
}
Map对象的优点在于它保留了数据类型 - 也就是说aCount.get(5)将返回3，但aCount.get("5")将返回undefined }。它还允许任何值/类型作为键，这意味着此解决方案也可以使用对象数组。
function frequencies(/* {Array} */ a){
return new Map([...new Set(a)].map(
x => [x, a.filter(y => y === x).length]
));
}
let foo = { value: 'foo' },
bar = { value: 'bar' },
baz = { value: 'baz' };
let aNumbers = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4],
aObjects = [foo, bar, foo, foo, baz, bar];
frequencies(aNumbers).forEach((val, key) => console.log(key + ': ' + val));
frequencies(aObjects).forEach((val, key) => console.log(key.value + ': ' + val));
答案 6 :(得分：29)
我认为这是如何计算数组中具有相同值的事件的最简单方法。
var a = [true, false, false, false];
a.filter(function(value){
return value === false;
}).length
答案 7 :(得分：26)
const data = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]
function count(arr) {
return arr.reduce((prev, curr) => (prev[curr] = ++prev[curr] || 1, prev), {})
}
console.log(count(data))
答案 8 :(得分：20)
如果您喜欢单个衬垫。
arr.reduce(function(countMap, word) {countMap[word] = ++countMap[word] || 1;return countMap}, {});
编辑（2015年12月12日）： 从里到外的解释。 countMap是一个映射单词及其频率的映射，我们可以看到匿名函数。 reduce的作用是将带有参数的函数应用为所有数组元素和countMap作为最后一个函数调用的返回值传递。最后一个参数（{}）是第一个函数调用的countMap的默认值。
答案 9 :(得分：14)
Logical nullish assignment (x ??= y) 与 Array#reduce() 结合使用，时间复杂度为 O(n)。主要思想仍然是使用 Array#reduce() 与输出聚合为 object 以获得最高性能 （时间和空间复杂度） 在 {{1} } & searching 喜欢其他答案。
construct bunches of intermediate arrays使用 Comma operator (,) 语法。
<块引用>const arr = [2, 2, 2, 2, 2, 4, 5, 5, 5, 9];
const result = arr.reduce((acc, curr) => {
acc[curr] ??= {[curr]: 0};
acc[curr][curr]++;
return acc;
}, {});
console.log(Object.values(result)); 计算其每个操作数（从左到
right) 并返回最后一个操作数的值。
The comma operator (,)输出
const arr = [2, 2, 2, 2, 2, 4, 5, 5, 5, 9];
const result = arr.reduce((acc, curr) => (acc[curr] = (acc[curr] || 0) + 1, acc), {});
console.log(result);答案 10 :(得分：14)
ES6版本应该是更简化（另一个行解决方案）
let arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
let acc = arr.reduce((acc, val) => acc.set(val, 1 + (acc.get(val) || 0)), new Map());
console.log(acc);
// output: Map { 5 => 3, 2 => 5, 9 => 1, 4 => 1 }
Map而不是plain Object帮助我们区分不同类型的元素，否则所有计数都基于字符串
答案 11 :(得分：8)
如果您使用下划线，您可以使用功能路线
a = ['foo', 'foo', 'bar'];
var results = _.reduce(a,function(counts,key){ counts[key]++; return counts },
_.object( _.map( _.uniq(a), function(key) { return [key, 0] })))
所以你的第一个数组是
_.keys(results)
，第二个数组是
_.values(results)
如果可用的话，大部分内容将默认为原生javascript函数
答案 12 :(得分：6)
基于answer和@adamse @pmandell（我赞成），在 ES6 中，您可以在一行中执行此操作>：
||来减少代码大小并使其更具可读性。
var a=[7,1,7,2,2,7,3,3,3,7,,7,7,7];
alert(JSON.stringify(
a.reduce((r,k)=>{r[k]=1+r[k]||1;return r},{})
));
它可用于计算字符数：
var s="ABRACADABRA";
alert(JSON.stringify(
s.split('').reduce((a, c)=>{a[c]++?0:a[c]=1;return a},{})
));
答案 13 :(得分：5)
这对眼睛来说简直轻松......
function count(a,i){
var result = 0;
for(var o in a)
if(a[o] == i)
result++;
return result;
}
编辑，因为你想要所有的出现......
function count(a){
var result = {};
for(var i in a){
if(result[a[i]] == undefined) result[a[i]] = 0;
result[a[i]]++;
}
return result;
}
答案 14 :(得分：5)
因此，我将使用一些最新的javascript功能来做到这一点：
首先，将数组减少为计数的Map：
let countMap = array.reduce(
(map, value) => {map.set(value, (map.get(value) || 0) + 1); return map},
new Map()
)
通过使用Map，您的起始数组可以包含任何类型的对象，并且计数将是正确的。如果没有Map，则某些类型的对象会给您带来奇怪的计数。
有关差异的更多信息，请参见Map docs。
如果您所有的值都是符号，数字或字符串，也可以用一个对象来完成：
let countObject = array.reduce(
(map, value) => { map[value] = (map[value] || 0) + 1; return map },
{}
)
使用解构和对象传播语法，或者以某种功能性稍稍稍差一点而不会发生变化：
let countObject = array.reduce(
(value, {[value]: count = 0, ...rest}) => ({ [value]: count + 1, ...rest }),
{}
)
此时，您可以使用Map或对象进行计数（与对象不同，地图可以直接迭代），或将其转换为两个数组。
对于Map：
countMap.forEach((count, value) => console.log(`value: ${value}, count: ${count}`)
let values = countMap.keys()
let counts = countMap.values()
或对象：
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)
答案 15 :(得分：5)
您可以扩展Array原型，如下所示：
Array.prototype.frequencies = function() {
var l = this.length, result = {all:[]};
while (l--){
result[this[l]] = result[this[l]] ? ++result[this[l]] : 1;
}
// all pairs (label, frequencies) to an array of arrays(2)
for (var l in result){
if (result.hasOwnProperty(l) && l !== 'all'){
result.all.push([ l,result[l] ]);
}
}
return result;
};
var freqs = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4].frequencies();
alert(freqs[2]); //=> 5
// or
var freqs = '1,1,2,one,one,2,2,22,three,four,five,three,three,five'
.split(',')
.frequencies();
alert(freqs.three); //=> 3
或者，您可以使用Array.map：
Array.prototype.frequencies = function () {
var freqs = {sum: 0};
this.map( function (a){
if (!(a in this)) { this[a] = 1; }
else { this[a] += 1; }
this.sum += 1;
return a; }, freqs
);
return freqs;
}
答案 16 :(得分：4)
var array = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
function countDuplicates(obj, num){
obj[num] = (++obj[num] || 1);
return obj;
}
var answer = array.reduce(countDuplicates, {});
// answer => {2:5, 4:1, 5:3, 9:1};
如果您仍然需要两个数组，那么您可以像这样使用 answer ......
var uniqueNums = Object.keys(answer);
// uniqueNums => ["2", "4", "5", "9"];
var countOfNums = Object.keys(answer).map(key => answer[key]);
// countOfNums => [5, 1, 3, 1];
或者，如果您想将uniqueNums作为数字
var uniqueNums = Object.keys(answer).map(key => +key);
// uniqueNums => [2, 4, 5, 9];
答案 17 :(得分：3)
ES6解决方案with reduce（fixed）：
const arr = [2, 2, 2, 3, 2]
const count = arr.reduce((pre, cur) => (cur === 2) ? ++pre : pre, 0)
console.log(count) // 4
答案 18 :(得分：3)
使用Set可以提取唯一数字，然后可以过滤输入以获取每个数字的计数：
input = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]
setOcc = new Set(input)
arrOcc = [...setOcc]
arrNumberOcc = arrOcc.map(occ => input.filter(e => e===occ).length);
console.log(arrOcc, arrNumberOcc)
答案 19 :(得分：2)
较短的版本使用 reduce 和波浪号 (~) 运算符。
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));答案 20 :(得分：2)
我的ramda解决方案：
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)
答案 21 :(得分：1)
试试这个：
Array.prototype.getItemCount = function(item) {
var counts = {};
for(var i = 0; i< this.length; i++) {
var num = this[i];
counts[num] = counts[num] ? counts[num]+1 : 1;
}
return counts[item] || 0;
}
答案 22 :(得分：1)
我知道这个问题很旧，但是我意识到解决方案太少了，因为用最少的代码就可以得到count数组，所以这是我的
// 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 ]
此外，您还可以通过以下方式从初始数组中获取集合：
var set = Array.from(new Set(initial));
//set = [5, 2, 9, 4]
答案 23 :(得分：1)
使用Lodash
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);<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>
答案 24 :(得分：1)
查看以下代码。
<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]++;
}
// 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++)
{
a.push(Unique[i] + ':' + Counts[i] + 'x');
}
alert(a.join(', '));
</script>
</head>
<body>
</body>
</html>
答案 25 :(得分：0)
const data = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]
function countAndSort(arr) {
return Object.entries(arr.reduce((prev, curr) => (prev[curr] = ++prev[curr] || 1, prev), {})).sort((a,b) => b[1]-a[1])
}
console.log(countAndSort(data))答案 26 :(得分：0)
给出下面提供的数组：
const array = [ 'a', 'b', 'b', 'c', 'c', 'c' ];
您可以使用此简单的单行代码生成哈希图，该哈希图将键与键在数组中出现的次数链接起来：
const hash = Object.fromEntries([ ...array.reduce((map, key) => map.set(key, (map.get(key) || 0) + 1), new Map()) ]);
// { a: 1, b: 2, c: 3 }
展开和解释：
// 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) || 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);
使用array.reduce代码获得@corashina的奖励
答案 27 :(得分：0)
使用时间复杂度为 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;
}
答案 28 :(得分：0)
似乎这些问题特别要求有两个结果数组，我没有看到，所以这是我的解决方案：
import matplotlib.pyplot as plt
true = [1,2,3,4,5,6,7,8,9,10]
pred = [1.02, 2.1, 2.99, 4, 5.01, 5.98, 7, 8.1, 9, 10.1]
std = [0.001, 0.002, 0.002, 0.001, 0.003, 0.004, 0.004, 0.001, 0.002, 0.004]
fig = plt.figure(figsize=(6,6))
ax = fig.add_subplot(1,1,1)
cmap = 'coolwarm'
my_plot = ax.scatter(true, pred, c=std, cmap=cmap, edgecolors='black', lw=1)
ax.set_xlabel('Observed', fontsize=18)
ax.set_ylabel('Predicted', fontsize=18)
cbar = fig.colorbar(my_plot)
cbar.set_label('standard deviation', rotation=270)
plt.axis('equal')
答案 29 :(得分：0)
单行ES6解决方案。使用对象作为地图的答案如此之多，但我看不到有人使用实际的Map
const map = arr.reduce((acc, e) => acc.set(e, acc.get(e) + 1 || 1), new Map());
使用map.keys()获取唯一元素
使用map.values()来获取事件
我希望至少有一个人会有所帮助。
var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]
const map = arr.reduce((acc, e) => acc.set(e, acc.get(e) + 1 || 1), new Map());
console.log(...map.keys())
console.log(...map.values())
答案 30 :(得分：0)
此问题已有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;
答案 31 :(得分：0)
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 +" -> "+ newArray[element]);
}
答案 32 :(得分：0)
这是最简单的解决方案
const data = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
let occurance_arr=[];
const aCount = [...new Set(data)].map(x => {
occurance_arr.push(data.filter(y=> y==x).length)
});
console.log(occurance_arr); //[3, 5, 1, 1]
答案 33 :(得分：0)
使用 MAP ，您可以在输出中包含2个数组：一个数组包含事件，另一个数组包含事件的数量。
const dataset = [2,2,4,2,6,4,7,8,5,6,7,10,10,10,15];
let values = [];
let keys = [];
var mapWithOccurences = dataset.reduce((a,c) => {
if(a.has(c)) a.set(c,a.get(c)+1);
else a.set(c,1);
return a;
}, new Map())
.forEach((value, key, map) => {
keys.push(key);
values.push(value);
});
console.log(keys)
console.log(values)
答案 34 :(得分：0)
function countOcurrences(arr){
return arr.reduce((aggregator, value, index, array) => {
if(!aggregator[value]){
return aggregator = {...aggregator, [value]: 1};
}else{
return aggregator = {...aggregator, [value]:++aggregator[value]};
}
}, {})
}
答案 35 :(得分：0)
这是一种计算对象数组内出现次数的方法。它还将第一个数组的内容放在一个新数组中，以对值进行排序，以便原始数组中的顺序不会中断。然后使用递归函数遍历每个元素并计算数组内每个对象的quantity属性。
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++) {
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++) {
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 > 1) {
var current_match = occurrences.length - 2;
occurrences[current_match].quantity = quantity_counter;
occurrences.splice(last_occurrence_element, 1);
}
counter = counter + 1;
if (counter < bgarlen) {
recursiveCounter();
}
}
recursiveCounter();
return occurrences;
}
}
alert(JSON.stringify(outerHolder(names_array)));
}
答案 36 :(得分：0)
关于我的评论，要求@Emissary调整他的解决方案。我添加了处理它的方式：
let distinctArr = yourArray.filter((curElement, index, array) => array.findIndex(t => t.prop1=== curElement.prop1 && t.prop2 === curElement.prop2 && t.prop3=== curElement.prop3) === index);
let distinctWithCount = [...new Set(distinctArr)].map(function(element){element.prop4 = yourArray.filter(t => t.prop1=== element.prop1 && t.prop2 === element.prop2 && t.prop2=== element.prop2).length;
我在这里做的是，首先删除重复项并保存数组（distinctArr）然后我依靠原始数组（yourArray）计算对象重复的时间，并添加第4个属性，其值为出现次数< / p>
希望对需要此特定解决方案的人有所帮助 它是由ES6制成的
答案 37 :(得分：0)
我们可以使用ramda.js执行此操作，这是一种更好，更简单的方法。
Code sample here
const ary = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
R.countBy(r=> r)(ary)
countBy文档位于documentation
答案 38 :(得分：0)
我在代码战中解决了类似的问题，并设计了以下对我有用的解决方案。
这给出了数组中整数的最高计数以及整数本身。我认为它也可以应用于字符串数组。
要正确排序字符串，请从function(a, b){return a-b}部分
sort()
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;
}
答案 39 :(得分：-1)
这是一种用于计算数组的经典老派方法。
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++;
}
}
如果您想要按字母顺序排列结果，可以先对其进行排序，但如果您想保留输入数据的顺序，请尝试一下。嵌套循环可能比本页上的其他一些方法慢一点。
答案 40 :(得分：-1)
您可以通过使用count函数扩展数组来简化此操作。如果您熟悉它，它的工作方式与Ruby’s 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
然后，您可以使用Array#filter
let occurred = [];
array.filter(function(item) {
if (!occurred.includes(item)) {
occurred.push(item);
return true;
}
}); // => ["a", "b", "d", "c"]
第二个数组，包含出现次数，使用Array#count进入Array#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}
答案 41 :(得分：-2)
使用过滤器很容易
在此示例中，我们仅分配计数，即由您要查找的键过滤的数组的长度
list_item.setInfo(
'video', {
'title': video['title'],
'plot': video['overview'],
'genre' : '???'}
有关JS Filiters的更多信息，请点击此处https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
答案 42 :(得分：-2)
给定数组x
即x = ['boy','man','oldman','scout','pilot'];
元素'man'的出现次数为
x.length - x.toString().split(',man,').toString().split(',').length ;
答案 43 :(得分：-6)
工作示例：https://jsfiddle.net/NChetanKumar/fuoxd6pg/
arr = [1,2,3,4,0,5,0,1,1,0,0];
function countOfRepeatednum(num,arr){
var count =0;
for(i=0;i<arr.length;i++){
if(arr[i] === num){
count += 1;
}
}
console.log(count);
}
countOfRepeatednum(1,arr);