如何在javascript中计算数组中的重复值

目前，我得到了这样一个数组：

var uniqueCount = Array();

uniqueCount = [a,b,c,d,d,e,a,b,c,f,g,h,h,h,e,a];

uniqueCount = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
var map = new Object();

for(var i = 0; i < uniqueCount.length; i++) {
 if(map[uniqueCount[i]] != null) {
    map[uniqueCount[i]] += 1;
} else {
    map[uniqueCount[i]] = 1;
    }
}

经过几步之后，我的数组如下所示：

var uniqueCount = Array();

uniqueCount = [a,b,c,d,d,e,a,b,c,f,g,h,h,h,e,a];

uniqueCount = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
var map = new Object();

for(var i = 0; i < uniqueCount.length; i++) {
 if(map[uniqueCount[i]] != null) {
    map[uniqueCount[i]] += 1;
} else {
    map[uniqueCount[i]] = 1;
    }
}

如何计算阵列中有多少个a、b、c？我希望得到如下结果：

a = 3
b = 1
c = 2
d = 2

等等。

类似这样的东西：

uniqueCount=[“a”、“b”、“c”、“d”、“d”、“e”、“a”、“b”、“c”、“f”、“g”、“h”、“h”、“h”、“e”、“a”]；
变量计数={}；
forEach（函数（i）{count[i]=（count[i]| | 0）+1；}）；
控制台日志（计数）
const counts={}；
const sampleArray=['a'，'a'，'b'，'c']；
forEach（函数（x）{counts[x]=（counts[x]| | 0）+1；}）；
console.log（计数）
您可以拥有一个包含计数的对象。浏览列表并增加每个元素的计数：

var counts = {};

uniqueCount.forEach(function(element) {
  counts[element] = (counts[element] || 0) + 1;
});

for (var element in counts) {
  console.log(element + ' = ' + counts[element]);
} 


函数计数（）{
数组元素=[“a”、“b”、“c”、“d”、“e”、“a”、“b”、“c”、“f”、“g”、“h”、“h”、“h”、“e”、“a”]；
数组_元素。排序（）；
无功电流=零；
var-cnt=0；
对于（var i=0；i0）{
document.write（当前+'来-->'+cnt+'次
'）；
}
电流=阵列_元素[i]；
cnt=1；
}否则{
cnt++；
}
}
如果（cnt>0）{
document.write（current+'comes-->'+cnt+'times'）；
}
}
计数（）您可以这样做：

var uniqueCount = Array();

uniqueCount = [a,b,c,d,d,e,a,b,c,f,g,h,h,h,e,a];

uniqueCount = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
var map = new Object();

for(var i = 0; i < uniqueCount.length; i++) {
 if(map[uniqueCount[i]] != null) {
    map[uniqueCount[i]] += 1;
} else {
    map[uniqueCount[i]] = 1;
    }
}

uniqueCount=['a'，'b'，'c'，'d'，'d'，'e'，'a'，'b'，'c'，'f'，'g'，'h'，'h'，'h'，'e'，'a']；
var map=新对象（）；
对于（变量i=0；i

现在您有了一张包含所有字符计数的地图，这是一组好答案：

var count = {};
var arr = ['a', 'b', 'c', 'd', 'd', 'e', 'a', 'b', 'c', 'f', 'g', 'h', 'h', 'h', 'e', 'a'];
var iterator = function (element) {
    count[element] = (count[element] || 0) + 1;
}

if (arr.forEach) {
    arr.forEach(function (element) {
        iterator(element);
    });
} else {
    for (var i = 0; i < arr.length; i++) {
        iterator(arr[i]);
    }
}  

var count={}；
var arr=['a'，'b'，'c'，'d'，'d'，'e'，'a'，'b'，'c'，'f'，'g'，'h'，'h'，'h'，'e'，'a']；
变量迭代器=函数（元素）{
计数[元素]=（计数[元素]| 0）+1；
}
if（arr.forEach）{
arr.forEach（函数（元素）{
迭代器（元素）；
});
}否则{
对于（变量i=0；i

希望对您有所帮助。
我认为这是计算数组中相同值出现次数的最简单方法

var a = [true, false, false, false];
a.filter(function(value){
    return value === false;
}).length                                      

我偶然发现了这个（非常古老的）问题。有趣的是，最明显、最优雅的解决方案（imho）缺失了：。自2011年（IE）或更早（所有其他浏览器）以来，所有主要浏览器都支持此功能：


var arr=['a'，'b'，'c'，'d'，'d'，'e'，'a'，'b'，'c'，'f'，'g'，'h'，'h'，'h'，'e'，'a']；
var map=arr.reduce（函数（上、当前）{
上一个[当前]=（上一个[当前]| 0）+1；
返回上一个；
}, {});
//map是将元素映射到其频率的关联数组：
控制台日志（map）；
//打印{“a”：3，“b”：2，“c”：2，“d”：2，“e”：2，“f”：1，“g”：1，“h”：3}
您无需使用任何for/while循环即可解决此问题

function myCounter(inputWords) {        
    return inputWords.reduce( (countWords, word) => {
        countWords[word] = ++countWords[word] || 1;
        return countWords;
    }, {});
}

希望它能帮助你
 
公共类CalculateCount{
var uniqueCount = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
// here we will collect only unique items from the array
var uniqueChars = [];

// iterate through each item of uniqueCount
for (i of uniqueCount) {
// if this is an item that was not earlier in uniqueCount, 
// put it into the uniqueChars array
  if (uniqueChars.indexOf(i) == -1) {
    uniqueChars.push(i);
  } 
}
// after iterating through all uniqueCount take each item in uniqueChars
// and compare it with each item in uniqueCount. If this uniqueChars item 
// corresponds to an item in uniqueCount, increase letterAccumulator by one.
for (x of uniqueChars) {
  let letterAccumulator = 0;
  for (i of uniqueCount) {
    if (i == x) {letterAccumulator++;}
  }
  console.log(`${x} = ${letterAccumulator}`);
}

公共静态void main（字符串[]args）{
int a[]={1,2,1,1,5,4,3,2,2,1,4,4,5,3,4,5,4}；
数组。排序（a）；
整数计数=1；
int i；
对于（i=0；i包含字母的数组中的重复项：

function getUniqueDataCount(objArr, propName) {
        var data = [];
        objArr.forEach(function (d, index) {
            if (d[propName]) {
                data.push(d[propName]);
            }
        });

        var uniqueList = [...new Set(data)];

        var dataSet = {};
        for (var i=0; i < uniqueList.length; i++) {
            dataSet[uniqueList[i]] = data.filter(x => x == uniqueList[i]).length;
        }
        
        return dataSet;
    }


var arr=[“a”、“b”、“a”、“z”、“e”、“a”、“b”、“f”、“d”、“f”]，
分拣机=[]，
计数=1；
分拣机=arr.sort（）；
对于（变量i=0；i”）；
}
通过使用array.map，我们可以减少循环，请参见上的

基于reduce数组函数的单线


const uniqueCount=[“a”、“b”、“c”、“d”、“e”、“a”、“b”、“c”、“f”、“g”、“h”、“h”、“h”、“e”、“a”]；
const distribution=uniqueCount.reduce（（acum，cur）=>Object.assign（acum，{[cur]：（acum[cur]| 0）+1}），{}）；
log（JSON.stringify（distribution，null，2））；
var string=['a'，'a'，'b'，'c'，'c'，'c'，'c'，'c'，'c'，'a'，'a'，'a']；
函数stringCompress（字符串）{
var obj={}，str=“”；
string.forEach（函数（i）{
obj[i]=（obj[i]| | 0）+1；
});
for（obj中的var键）{
str+=（key+obj[key]）；
}
控制台日志（obj）；
console.log（str）；
}字符串压缩（字符串）
/*
随时欢迎改进，请分享
*/
创建一个文件，例如
demo.js
并在控制台中使用节点
demo.js
运行它，您将获得矩阵形式的元素出现

var multipleDuplicateArr = Array(10).fill(0).map(()=>{return Math.floor(Math.random() * Math.floor(9))});
console.log(multipleDuplicateArr);

var resultArr = Array(Array('KEYS','OCCURRENCE'));

for (var i = 0; i < multipleDuplicateArr.length; i++) {
  var flag = true;
  for (var j = 0; j < resultArr.length; j++) {
     if(resultArr[j][0] == multipleDuplicateArr[i]){
       resultArr[j][1] = resultArr[j][1] + 1;
       flag = false;
      }
  }
  if(flag){
    resultArr.push(Array(multipleDuplicateArr[i],1));
  }
}

console.log(resultArr);


//新示例。
var str=[20,1，-1,2，-2,3,3,5,5,1,2,4,20,4，-1，-2,5]；
功能findOdd（第{
变量计数={}；
forEach段（职能）（第段）{
计数[段]=（计数[段]| 0）+1；
});
返回计数；
}
console.log（findOdd（str））；
最快的方法：

function getUniqueDataCount(objArr, propName) {
        var data = [];
        objArr.forEach(function (d, index) {
            if (d[propName]) {
                data.push(d[propName]);
            }
        });

        var uniqueList = [...new Set(data)];

        var dataSet = {};
        for (var i=0; i < uniqueList.length; i++) {
            dataSet[uniqueList[i]] = data.filter(x => x == uniqueList[i]).length;
        }
        
        return dataSet;
    }

是O（n）


函数的重复次数（arr）{
常量计数={}；
for（设i=0；i
var arr=['a'，'d'，'r'，'a'，'a'，'f'，'d']；
//调用函数并传递数组，函数将返回一个对象，其中数组值作为键值，其计数作为键值。
复制器（arr）；
功能复制器（arr）{
var obj={}
对于（变量i=0；i
var testArray=['a'，'b'，'c'，'d'，'d'，'e'，'a'，'b'，'c'，'f'，'g'，'h'，'h'，'h'，'e'，'a']

var newArr = [];
testArray.forEach((item) => {
    newArr[item] = testArray.filter((el) => {
            return el === item;
    }).length;
})
console.log(newArr);

声明一个对象
arr
以将唯一集作为键保存。通过使用map在数组中循环一次来填充
arr
。如果
const counts = arr.reduce((acc, value) => ({
   ...acc,
   [value]: (acc[value] || 0) + 1
}), {});

uniqueCount = ["a","b","a","c","b","a","d","b","c","f","g","h","h","h","e","a"];
var count = {};
uniqueCount.forEach((i) => { count[i] = ++count[i]|| 1});
console.log(count);

function getUniqueDataCount(objArr, propName) {
        var data = [];
        objArr.forEach(function (d, index) {
            if (d[propName]) {
                data.push(d[propName]);
            }
        });

        var uniqueList = [...new Set(data)];

        var dataSet = {};
        for (var i=0; i < uniqueList.length; i++) {
            dataSet[uniqueList[i]] = data.filter(x => x == uniqueList[i]).length;
        }
        
        return dataSet;
    }

let arr=[1,2,3,3,4,5,5,6,7,7]
let obj={}
for(var i=0;i<arr.length;i++){
    obj[arr[i]]=obj[arr[i]]!=null ?obj[arr[i]]+1:1 //stores duplicate in an obj

}
console.log(obj)
//returns object {1:1,:1,3:2,.....}

const obj = {};
const uniqueCount = [ 'a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'f', 'g', 'h', 'h', 'h', 'e', 'a' ];
for (let i of uniqueCount) obj[i] ? obj[i]++ : (obj[i] = 1);
console.log(obj);