在Javascript中，我试图采取数字值的初始数组，并计算其中的元素。理想情况下，结果将是两个新数组，第一个数组指定每个唯一元素，第二个数组包含每个元素出现的次数。但是，我愿意听取关于输出格式的建议。
例如，如果初始数组是:
5, 5, 5, 2, 2, 2, 2, 2, 9, 4
然后将创建两个新数组。第一个将包含每个唯一元素的名称:
5, 2, 9, 4
第二个将包含该元素在初始数组中出现的次数:
3, 5, 1, 1
因为数字5在初始数组中出现了三次，数字2出现了五次，9和4都出现了一次。
我一直在寻找解决方案，但似乎没有一个可行，而且我自己尝试过的每件事最后都出奇地复杂。任何帮助都将不胜感激!
谢谢:)
当前回答
您可以通过使用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}
其他回答
一行ES6解决方案。这么多的答案使用对象作为地图，但我看不到任何人使用实际的地图
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,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([…]. entry ()))
编辑2020年:这是一个相当老的答案(9年)。扩展本机原型总是会引起讨论。尽管我认为程序员可以自由选择自己的编程风格，这里有一个(更现代的)方法来解决这个问题，而不需要扩展Array.prototype:
{ // create array with some pseudo random values (1 - 5) const arr = Array.from({length: 100}) .map( () => Math.floor(1 + Math.random() * 5) ); // frequencies using a reducer const arrFrequencies = arr.reduce((acc, value) => ({ ...acc, [value]: acc[value] + 1 || 1}), {} ) console.log(arrFrequencies); console.log(`Value 4 occurs ${arrFrequencies[4]} times in arrFrequencies`); // bonus: restore Array from frequencies const arrRestored = Object.entries(arrFrequencies) .reduce( (acc, [key, value]) => acc.concat(Array(value).fill(+key)), [] ); console.log(arrRestored.join()); } .as-console-wrapper { top: 0; max-height: 100% !important; }
旧的(2011年)答案是:你可以扩展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(); console.log(`freqs[2]: ${freqs[2]}`); //=> 5 // or var freqs = '1,1,2,one,one,2,2,22,three,four,five,three,three,five' .split(',') .frequencies(); console.log(`freqs.three: ${freqs.three}`); //=> 3 // Alternatively you can utilize 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; } } .as-console-wrapper { top: 0; max-height: 100% !important; }
查看下面的代码。
<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>
使用减法和波浪号(~)操作符的较短版本。
Const data = [2,2,2,2,2,2,4,5,5,5,9]; 函数频率(nums) { num返回。Reduce ((acc, curr) => { Acc [curr] = -~ Acc [curr]; 返回acc; }, {}); ｝ console.log(频率(数据));
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对象的伟大之处在于它保留了数据类型——也就是说account .get(5)将返回3，但account .get("5")将返回未定义。它还允许任何值/类型作为键，这意味着该解决方案也适用于对象数组。
函数频率(/*{数组}*/ a){ 返回新地图([…]新组(a)] . map ( X => [X, a.filter(y => y == X).length] )); ｝ 让foo = {value: 'foo'}， Bar = {value: ' Bar '}， Baz ={值:' Baz '}; let aNumbers = [5,5,5,2,2,2,2,2,2,2,2,9,4]， aObjects = [foo, bar, foo, foo, baz, bar]; 频率(许多)。forEach (val关键)= > console.log(关键 + ': ' + val)); 频率(aObjects)。forEach((val, key) => console.log(key. log)Value + ': ' + val));
