Question

我有一个像这样的对象数组：

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
}

键甚至可以在数组中。我尝试在arrayOfObjs上使用Lodash的countBy函数。但是，这只是导致了

{[object Object]:5}

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

类似的东西

更新

作为替代方案，我尝试像这样组织我的数组：

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}

哪个有点好，但我现在必须使用正则表达式来拆分对象的每个键，因为＆＃34; 1，h＆＃34;是一个字符串。不理想:(

理想情况，我希望我的密钥可以是对象，数组或类似的东西。

Answer 1

arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}];

var hash = {};
arrayOfObjs.forEach(function(item){
    var key = JSON.stringify(item);
    if (hash[key]) {
        hash[key]++;
    } else {
        hash[key] = 1;
    }
});
console.log(hash);

var hash2 = {};
arrayOfObjs.forEach(function(item){
    var key = JSON.stringify(item);
    if (hash2[key]) {
        hash2[key]++;
    } else {
        hash2[key] = 1;
    }
});
for (key in hash2) {
    val = hash2[key];
    console.log(key, val);
}

请注意，hash[key]您可以hash[item]使用console.log(hash)，var numberOfSubArrays = 3 var sub_array1 = [] var sub_array2 = [] var sub_array3 = [] var array1 = [] var array2 = [sub_array1,sub_array2,sub_array3] for (var i = 0; i < numberOfSubArrays; i++) { array1[i] = "sub_array" + i }无法按照预期的方式看到它{/ 1}}

Answer 2

无耻插头：

我正在开发一个名为Pro.js的库，它有一个收集模块，可以完成各种整洁的事情。可枚举类有一个.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();

您可以转到Pro.js GitHub Page并使用开发人员工具测试库。运行我在页面上的答案中发布的代码片段，看看它是否会为您产生可爱的结果。

Answer 3

我使用_.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)

https://jsfiddle.net/tkv94whe/

Answer 4

您可以尝试这样的事情：

＆＃13;

var arrayOfObjs = [{1:"h"}, {1:"h"}, {2:"h"}, {3:"ha"}, {4:"haa"}, {4:"haa"}, {4:"haa"}]

var result = {};

arrayOfObjs.forEach(function(item){
  var objStr = JSON.stringify(item);
  result[objStr] = result[objStr]? ++result[objStr]: 1;
});
console.log(result);

＆＃13;

Answer 5

您可以迭代数组并使用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);

https://jsfiddle.net/xv22v72v/

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

5 个答案: