在JavaScript/Node.js中获取属于特定ID的数组对象数量

Question

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

var array = [ 
    [ '2','Yes'],
    [ '2','Yes'],
    [ '2','Yes'],
    [ '3','Yes'],
    [ '3','Yes'],
    [ '4','Yes'],
]

上述数组中的ID（2、3和4）来自服务器响应，是动态获取的。我需要计算特定ID的条目数量。但我无法想出如何循环遍历此数组以获得期望的输出。期望的输出为：

[{"ID" : "4", Count : "1"},{"ID" : "3", Count : "2"},{"ID" : "2",Count : "3"}]

请注意，输出结果按计数的升序排列。

这是我的尝试：

var temp1 = [];
                var temp2 = [];
                var temp3 = [];
                for(var i = 0; i < array.length; ++i){
                     if(array[i][0] == 2){
                        temp1.push(array[i])
                     }
                     if(array[i][0] == 1){
                        temp2.push(array[i])
                     }
                     if(array[i][0] == 3){
                        temp3.push(array[i])
                     }

                }

 var output = [{
                    ID: "2",
                    Count: temp1.length,
                },
                {
                    ID: "1",
                    Count: temp2.length,
                },
                {
                    ID: "3",
                    Count: temp3.length
                }]

console.log(output)

如果数据是动态的，我相信我的做法不是最好的方法。 如何更好地处理它？

- node_man

---

我正在更新问题，请检查。 - node_man

Answer 1

使用 Array.prototype.reduce()，Object.entries()，Array.prototype.sort() 和 Array.prototype.map() 的联合使用将产生以下结果：

const array = [ 
    [ '2','Yes'],
    [ '2','Yes'],
    [ '2','Yes'],
    [ '3','Yes'],
    [ '3','Yes'],
    [ '4','Yes'],
];

const result = Object.entries(array.reduce((a, [id]) => {
  a[id] = (a[id] || 0) + 1;
  return a;
}, {})).map(([ID, Count]) => ({ID, Count}))
       .sort((a, b) => a.Count - b.Count);

console.log(result);

- Robby Cornelissen

---

你能否推荐一些好的资源给我阅读，以便我可以自己解决这些棘手的情况？ - node_man

你能否请看一下我的问题：https://stackoverflow.com/questions/61493692/node-js-promise-inside-for-loop-always-prints-promise-pending - node_man

Answer 2

你可以使用map和filter来转换数组并计算出现次数，然后通过count属性对数组进行排序：

const array = [ 
    [ '2','Yes'],
    [ '2','Yes'],
    [ '2','Yes'],
    [ '3','Yes'],
    [ '3','Yes'],
    [ '4','Yes'],
];

const result = [];
array.forEach( item => {
  if (result.find( id => item[0] === id["ID"])){
    return;
  }
  result.push({"ID": item[0], Count: array.filter(ids =>  ids[0] === item[0]).length});
})

// And then sort it
result.sort( (a,b) => a.Count - b.Count);

console.log(result);

- David Letrán

Answer 3

你可以尝试这个。

var array = [ 
    [ '2','Yes'],
    [ '2','Yes'],
    [ '2','Yes'],
    [ '3','Yes'],
    [ '3','Yes'],
    [ '4','Yes'],
];

var y = {};
var z = [];
array.forEach(x=>{      //creating object which will store freq of Id
  if(!y[x[0]]){
    y[x[0]] = 0;
  }
  y[x[0]]++;
});
Object.keys(y).forEach(x=>{   //converting above object to array
  z.push({'ID': x, 'Count':y[x]});
});
console.log(z.sort((a,b) => a.Count - b.Count))//sorting array as per requirement

- yajiv

Answer 4

如果您想坚持使用您的for循环，一种简单的方法是检查每个项目是否已包含在输出中，如果是，则增加计数，如下所示：

var array = [
[ '2','Yes'],
[ '2','Yes'],
[ '2','Yes'],
[ '3','Yes'],
[ '3','Yes'],
[ '4','Yes'],
];

var output = [];

for(var i = 0; i < array.length; ++i) {
  if(!output.find(item => item.ID === array[i][0])){
    output.push({'ID': array[i][0], 'Count': 1});
  } else {
    output.find(item => item.ID === array[i][0]).Count += 1;
  }
}
output.sort( (a,b) => a.Count - b.Count)

console.log(output);

- Guillaume Bihet

---

我最初也认为输出只是反转了，但根据问题，实际上是按“计数”排序的。 - Robby Cornelissen

@RobbyCornelissen 绝对正确，我错过了这个，谢谢 ;) - Guillaume Bihet

Answer 5

您也可以使用以下代码获得预期的结果。

var array = [ 
    [ '2','Yes'],
    [ '2','Yes'],
    [ '2','Yes'],
    [ '3','Yes'],
    [ '3','Yes'],
    [ '4','Yes'],
]

var arrMap = {}

array.map(item => {
    if(arrMap[item[0]]){
     arrMap[item[0]]++ 
    }else{
     arrMap[item[0]] = 1
    } 
})

var resultArr = []

for(var keys of Object.keys(arrMap)){
 resultArr.push({"ID":keys,"Count":arrMap[keys]})
}

- Apoorv

Answer 6

尝试使用{{link1：Array#prototype#reduce}}。

const array = [ 
    [ '2','Yes'],
    [ '2','Yes'],
    [ '2','Yes'],
    [ '3','Yes'],
    [ '3','Yes'],
    [ '4','Yes'],
];

const res = array.reduce((acc, curr) => {
 let foundElement = acc.find(x => x.id === curr[0]);
 
 if (!foundElement) {
  foundElement = {
   id: curr[0],
   count: 1
  };
  
  acc.push(foundElement);
 }
 else {
  foundElement.count += 1; 
 }
 
 return acc;
}, [])
.sort((a, b) => a.count - b.count);

console.log(res);

- Kunal Mukherjee