计算JavaScript数组中对象的出现次数

我有这样一个对象数组：

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}]

{
  {4:"haa"}: 3,
  {1:"h"}: 2,
  {2:"h"}: 1,
  {3:"ha"}: 1
}

array = [[1,"h"], [1,"h"], [2,"h"], [3,"ha"], [4,"haa"], [4,"haa"], [4,"haa"]];

我想计算每个对象的出现次数，并将结果返回到一个排序的、可编辑的数据结构中，如下所示：

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}]

{
  {4:"haa"}: 3,
  {1:"h"}: 2,
  {2:"h"}: 1,
  {3:"ha"}: 1
}

array = [[1,"h"], [1,"h"], [2,"h"], [3,"ha"], [4,"haa"], [4,"haa"], [4,"haa"]];

这些键甚至可以是数组。 我尝试在arrayOfObjs上使用Lodash的countBy函数。然而，这只会导致

{[object Object]:5}

我可以使用任何库/函数来完成这项工作吗？类似于Python的计数器的东西

更新

作为替代方案，我尝试按如下方式组织阵列：

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}]

{
  {4:"haa"}: 3,
  {1:"h"}: 2,
  {2:"h"}: 1,
  {3:"ha"}: 1
}

array = [[1,"h"], [1,"h"], [2,"h"], [3,"ha"], [4,"haa"], [4,"haa"], [4,"haa"]];

再次使用Lodash的countBY函数，结果是：

{1,h: 2, 2,h: 1, 3,ha: 1, 4,haa: 3}

这稍微好一点，但我现在必须使用正则表达式来分割对象的每个键，因为“1，h”是一个字符串。不理想：(

理想情况下，我希望我的键是对象、数组或类似的东西。

arrayOfObjs=[{1:h}，{1:h}，{2:h}，{3:ha}，{4:haa}，{4:haa}，{4:haa}]；
var hash={}；
arrayOfObjs.forEach（功能（项目）{
var key=JSON.stringify（项目）；
if（散列[键]）{
散列[键]+；
}否则{
散列[键]=1；
}
});
console.log（散列）；
var hash2={}；
arrayOfObjs.forEach（功能（项目）{
var key=JSON.stringify（项目）；
if（hash2[key]）{
hash2[键]+；
}否则{
hash2[key]=1；
}
});
for（输入hash2）{
val=hash2[key]；
console.log（key，val）；
}

arrayOfObjs=[{1:h}，{1:h}，{2:h}，{3:ha}，{4:haa}，{4:haa}，{4:haa}]；
var hash={}；
arrayOfObjs.forEach（功能（项目）{
var key=JSON.stringify（项目）；
if（散列[键]）{
散列[键]+；
}否则{
散列[键]=1；
}
});
console.log（散列）；
var hash2={}；
arrayOfObjs.forEach（功能（项目）{
var key=JSON.stringify（项目）；
if（hash2[key]）{
hash2[键]+；
}否则{
hash2[key]=1；
}
});
for（输入hash2）{
val=hash2[key]；
console.log（key，val）；
}

您可以在数组上迭代，并使用JSON.stringify（）将对象转换为字符串，然后进行比较。这是一种简单的hashmap技术，可供使用

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}];
    var result={}
    for(var i=0;i<arrayOfObjs.length;i++){
        if(!result[JSON.stringify(arrayOfObjs[i])]){
        result[JSON.stringify(arrayOfObjs[i])]=1;
      } else {
        result[JSON.stringify(arrayOfObjs[i])]=result[JSON.stringify(arrayOfObjs[i])]+1;
      }
    }
    console.log(result);

arrayOfObjs=[{1:h}，{1:h}，{2:h}，{3:ha}，{4:haa}，{4:haa}，{4:haa}]；
var result={}
对于（var i=0；i
），您可以迭代数组，并使用JSON.stringify（）将对象转换为字符串，然后进行比较。这是一种简单的hashmap技术，可供使用

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}];
    var result={}
    for(var i=0;i<arrayOfObjs.length;i++){
        if(!result[JSON.stringify(arrayOfObjs[i])]){
        result[JSON.stringify(arrayOfObjs[i])]=1;
      } else {
        result[JSON.stringify(arrayOfObjs[i])]=result[JSON.stringify(arrayOfObjs[i])]+1;
      }
    }
    console.log(result);

arrayOfObjs=[{1:h}，{1:h}，{2:h}，{3:ha}，{4:haa}，{4:haa}，{4:haa}]；
var result={}
对于（var i=0；i
您可以尝试以下方法：

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}]

{
  {4:"haa"}: 3,
  {1:"h"}: 2,
  {2:"h"}: 1,
  {3:"ha"}: 1
}

array = [[1,"h"], [1,"h"], [2,"h"], [3,"ha"], [4,"haa"], [4,"haa"], [4,"haa"]];


var arrayOfObjs=[{1:h}，{1:h}，{2:h}，{3:ha}，{4:haa}，{4:haa}，{4:haa}]
var result={}；
arrayOfObjs.forEach（功能（项目）{
var objStr=JSON.stringify（项目）；
结果[objStr]=结果[objStr]？+结果[objStr]：1；
});
console.log（结果）；
您可以尝试以下方法：

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}]

{
  {4:"haa"}: 3,
  {1:"h"}: 2,
  {2:"h"}: 1,
  {3:"ha"}: 1
}

array = [[1,"h"], [1,"h"], [2,"h"], [3,"ha"], [4,"haa"], [4,"haa"], [4,"haa"]];


var arrayOfObjs=[{1:h}，{1:h}，{2:h}，{3:ha}，{4:haa}，{4:haa}，{4:haa}]
var result={}；
arrayOfObjs.forEach（功能（项目）{
var objStr=JSON.stringify（项目）；
结果[objStr]=结果[objStr]？+结果[objStr]：1；
});
console.log（结果）；
无耻插头：

我正在开发一个名为的库，它有一个集合模块，可以完成各种简单的工作。enumerable类有一个.groupBy（）方法，在这里特别有用

var arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}];
var enumerable = pro.collections.asEnumerable(arrayOfObjs);
var grouped = enumerable.groupBy(function(o) {
    return JSON.stringify(o);
});
var composites = grouped.select(function(g) {
    return {
        key: g[0],
        count: g.length,
        group: g
    };
});
var output = composites.toArray();

您可以转到并使用开发人员工具测试库。运行我在页面上的答案中发布的代码片段，看看它是否能为您产生令人喜欢的结果。
无耻的插件：

我正在开发一个名为的库，它有一个集合模块，可以完成各种简单的工作。enumerable类有一个.groupBy（）方法，在这里特别有用

var arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}];
var enumerable = pro.collections.asEnumerable(arrayOfObjs);
var grouped = enumerable.groupBy(function(o) {
    return JSON.stringify(o);
});
var composites = grouped.select(function(g) {
    return {
        key: g[0],
        count: g.length,
        group: g
    };
});
var output = composites.toArray();

您可以转到并使用开发人员工具测试库。运行我在页面上的答案中发布的代码片段，看看它是否为您产生了一个令人喜欢的结果。
我决定使用.countBy、.map和.reduce完成此任务

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}];

var a = _.countBy(arrayOfObjs, function (obj) {
    return _.map(obj, function (value, key) {
    return key + ' ' + value;
  });
})

b = _.reduce(a, function (result, value, key) {
    var splittedKey = key.split(' ');
  var newObj = {};

  newObj[splittedKey[0]] = splittedKey[1];

  var newKey = JSON.stringify(newObj)
  var resultObj = {};

  resultObj[newKey] = value;
  result.push(resultObj)

  return result;
}, []);

console.log(b)

我决定使用u.countBy、u.map和u.reduce执行此任务

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}];

var a = _.countBy(arrayOfObjs, function (obj) {
    return _.map(obj, function (value, key) {
    return key + ' ' + value;
  });
})

b = _.reduce(a, function (result, value, key) {
    var splittedKey = key.split(' ');
  var newObj = {};

  newObj[splittedKey[0]] = splittedKey[1];

  var newKey = JSON.stringify(newObj)
  var resultObj = {};

  resultObj[newKey] = value;
  result.push(resultObj)

  return result;
}, []);

console.log(b)

您的意思是要统计彼此具有相同属性的对象的出现次数？因为在示例数组中，每个对象只出现一次：前两个数组元素不是同一个对象，它们是两个定义了相同属性的不同对象。请尝试比较JSON.stringify StringSun幸运的是，您的键e不能是对象，也不能是字符串以外的任何对象。JavaScript对象是哈希表，哈希表键是字符串。JavaScript也不允许将原始值作为键，因此即使将对象键设置为数字，它仍将转换为字符串。使用JSON的建议主要是解决了这个问题，因为您可以在以后将键反序列化回对象。@JacobHeater，您知道反序列化每个键是否花费时间吗？当我循环遍历结果时，我必须反序列化每个键，每个循环。@user5792950，我想的是这样的，[{count:3，key:{4:'ha'}，…{count:2，key:{1:'h'}}]。该数组将包含存储有关计数的元数据的对象，并且键可能仍处于其对象形式。您的意思是要计数彼此具有相同属性的对象的出现次数吗？因为在示例数组中，每个对象只出现一次：前两个数组元素不是同一个对象，它们是两个不同的对象cts恰好定义了相同的属性。请尝试比较JSON.stringify StringSun幸运的是，您的键不能是对象，也不能是字符串以外的任何对象。JavaScript对象是哈希表，哈希表键是字符串。JavaScript也不允许将基元值作为键，因此即使您将对象键设置为数字，它仍将转换为字符串