在 Javascript 中，我试图获取一个数字值的初始数组并计算其中的元素数量。理想情况下，结果会是两个新数组，第一个指定每个唯一元素，第二个包含每个元素出现的次数。但是，对于输出格式，我也很乐意听取建议。
例如，如果初始数组如下：
5, 5, 5, 2, 2, 2, 2, 2, 9, 4
然后将创建两个新数组。第一个数组将包含每个唯一元素的名称：
5, 2, 9, 4
3, 5, 1, 1
你可以使用一个对象来保存结果：
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);
console.log(counts[5], counts[2], counts[9], counts[4]);现在你的counts对象可以告诉你特定数字的计数：
console.log(counts[5]); // logs '3'
keys() 函数。keys(counts); // returns ["5", "2", "9", "4"]
Object.keys()函数只受IE9+、FF4+、SF5+、CH6+支持，但Opera不支持。我认为最大的问题在于**IE9+**。 - Robert Koritnikcounts[num] = (counts[num] || 0) + 1。这种方式只需要在那一行中写两次counts[num]，而不是三次。 - robruvar arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
var counts = {};
arr.forEach(function(num) {
if (!(num in counts)) { counts[num] = 0; } counts[num]++; });
console.log(counts);这种方法满足了获取唯一值和计数的要求，而且只使用了一个对象来处理这两个需求，而不是使用两个独立的数组。 - Patrick Lewis[1, "1", { toString: () => "1" }]，则会得到结果 { 1: 3 }。 - 3limin4t0rconst 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) // => {2: 5, 4: 1, 5: 3, 9: 1}const keys = Object.keys(a);
const values = Object.values(a); - ncenerar[1, "1", { toString: () => "1" }]，则会得到结果 { 1: 3 }。 - 3limin4t0rnum:2,occ:5？谢谢。 - Menai Ala Eddine - Aladdin一行ES6解决方案。很多答案使用对象作为映射，但我没有看到有人使用实际的Map
const map = arr.reduce((acc, e) => acc.set(e, (acc.get(e) || 0) + 1), new Map());
map.keys() 可以获取唯一的元素。map.values() 可以获取元素出现的次数。map.entries() 可以获取 [元素，频率] 对。
var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]
const map = arr.reduce((acc, e) => acc.set(e, (acc.get(e) || 0) + 1), new Map());
console.info([...map.keys()])
console.info([...map.values()])
console.info([...map.entries()])e 改为 e.id 应该就足够了。另外，我不确定 id 是否应该包含重复的属性，因为它可以帮助我们识别元素。 - corashinaconst 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)O(N log(N))，所获得的优雅程度不值得这样做。 - ninjageckoArray.sort 添加了一个免责声明，因为在实际代码中忽略这个事实会让我犯错。 (很容易天真地将它视为制作副本，因为它返回已排序的数组。) - jpaugh如果使用underscore或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()函数，以获得唯一数字和它们的出现次数。但是根据我的经验，原始对象更容易处理。
filter([true, true, true, false], function(m){return m==true}).length。如果没有值存在，则仅返回0。 - Douga = [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
}
如何使用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构造函数，创建一个包含唯一值的集合。然后展开语法将这些值扩展到一个新数组中，以便我们可以调用map并将其转换为一个二维数组[value, count]对，即以下结构：Array [
[5, 3],
[2, 5],
[9, 1],
[4, 1]
]
Map构造函数，从而产生一个可迭代对象：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));Set 使用对象引用来保证唯一性，并没有提供比较“相似”对象的 API。如果你想在这种任务中使用这种方法，你需要一些中间的归约函数来保证实例数组的唯一性。虽然不是最高效的方法，但我在这里快速地组合了一个示例。 - Emissary我认为这是在数组中计算相同值出现次数的最简单方法。
var a = [true, false, false, false];
a.filter(function(value){
return value === false;
}).length
a.filter(value => !value).length 重写为：a.filter(!).length。 - t3chb0tconst 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))逻辑空值赋值运算符 (x ??= y)与Array＃reduce()结合使用。主要思路仍然是使用Array＃reduce()进行聚合，输出为object，以实现在搜索和构建大量中间数组等方面获得最高性能（时间和空间复杂性），就像其他答案一样。
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));使用 逗号运算符 (,) 语法。
逗号运算符 (,)从左到右依次评估其每个操作数，并返回最后一个操作数的值。
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);输出
{
"2": 5,
"4": 1,
"5": 3,
"9": 1
}
const result = arr.reduce((acc, curr) => (acc[curr] = -~(acc[curr]), acc), {});
请参见https://dev59.com/emMl5IYBdhLWcg3wK0aA#47546846进行解释。 - Yoni Rabinovitch位运算看起来也很优雅简洁。 - Nguyễn Văn Phong
if (arr.indexOf(value) == arr.lastIndexOf(value))。 - Rodrigoramda.js来轻松实现这一点。R.countBy(r=> r)(ary)```- Eshwar Prasad Yaddanapudiarr.filter(x => x===5).length会返回3，表示数组中有 '3' 个数字 '5'。 - noobninja