Javascript 查找对象数组中的计数总数

包括有多少潜在选民年龄在18-25岁之间，有多少人年龄在26-35岁之间，有多少人年龄在36-55岁之间，以及每个年龄段中有多少人实际参加了投票。包含此数据的结果对象应具有6个属性

var voters = [
    {name:'Bob' , age: 30, voted: true},
    {name:'Jake' , age: 32, voted: true},
    {name:'Kate' , age: 25, voted: false},
    {name:'Sam' , age: 20, voted: false},
    {name:'Phil' , age: 21, voted: true},
    {name:'Ed' , age:55, voted:true},
    {name:'Tami' , age: 54, voted:true},
    {name: 'Mary', age: 31, voted: false},
    {name: 'Becky', age: 43, voted: false},
    {name: 'Joey', age: 41, voted: true},
    {name: 'Jeff', age: 30, voted: true},
    {name: 'Zack', age: 19, voted: false}
];

function voterResults(arr) {
   // your code here
}

console.log(voterResults(voters)); // Returned value shown below:
/*
{ youngVotes: 1,
  youth: 4,
  midVotes: 3,
  mids: 4,
  oldVotes: 3,
  olds: 4 
}

我正在尝试这个特定的问题，下面是我已经尝试过的，在这里我能够形成hashmap。但我不知道如何解决上述问题

function voterResults(arr) {
  let votesArray = ['youngVotes', 'youth', 'midVotes', 'mids', 
      'oldVotes', 'olds']
   return votesArray.reduce((acc, it) => {
     acc[it] = (acc[it] || 0) + 1  
     return acc;
   }, {})
}

//输出

{
   youngVotes: 1 ,
   youth: 1 ,
   midVotes: 1 ,
   mids: 1 ,
   oldVotes: 1 ,
   olds: 1
}

需要的实际输出：

{
  youngVotes: 1,
  youth: 4,
  midVotes: 3,
  mids: 4,
  oldVotes: 3,
  olds: 4 
}

---

我首先要创建一个helper函数，它返回与经过的年龄相对应的属性字符串（例如

20

->

['youth'，'youngvowers']

）。然后使用

.reduce

迭代

投票者

数组-调用该函数找出要递增的属性，并递增它：

const getCat=（年龄）=>{
如果（年龄<25岁）返回[‘青年’、‘青年投票’]；
如果（年龄<35岁）返回['mids'，'MID投票]；
返回['olds'，'oldsvots']；
};
var投票者=[
{姓名：'Bob'，年龄：30岁，投票结果：正确}，
{姓名：'Jake'，年龄：32岁，投票结果：正确}，
{姓名：'Kate'，年龄：25岁，投票：false}，
{姓名：'Sam'，年龄：20岁，投票：false}，
{姓名：'Phil'，年龄：21岁，投票结果：正确}，
{姓名：'Ed'，年龄：55岁，投票结果：正确}，
{姓名：'Tami'，年龄：54岁，投票结果：正确}，
{姓名：'Mary'，年龄：31岁，投票：false}，
{姓名：'Becky'，年龄：43岁，投票：false}，
{姓名：'Joey'，年龄：41岁，投票结果：正确}，
{姓名：'Jeff'，年龄：30岁，投票结果：正确}，
{姓名：'Zack'，年龄：19岁，投票：false}
];
const counts=投票者。reduce（（a，{age，voted}）=>{
const[prop，voteProp]=getCat（年龄）；
a[prop]=（a[prop]| | 0）+1；
如果（投票）{
a[voteProp]=（a[voteProp]| | 0）+1；
}
返回a；
}, {});
控制台日志（计数）您需要使用输入arr，使用投票值和使用年龄来分类和增加对象中的值

const voters = [
    {name:'Bob' , age: 30, voted: true},
    {name:'Jake' , age: 32, voted: true},
    {name:'Kate' , age: 25, voted: false},
    {name:'Sam' , age: 20, voted: false},
    {name:'Phil' , age: 21, voted: true},
    {name:'Ed' , age:55, voted:true},
    {name:'Tami' , age: 54, voted:true},
    {name: 'Mary', age: 31, voted: false},
    {name: 'Becky', age: 43, voted: false},
    {name: 'Joey', age: 41, voted: true},
    {name: 'Jeff', age: 30, voted: true},
    {name: 'Zack', age: 19, voted: false}
];

// define your limit here, will check for <= of defined age
let categories = { youngVotes: 21, youth: 30, midVotes: 40, mids: 50, oldVotes: 60, olds: 130}

function voterResults(arr) {
const conditions = Object.entries(categories);
   return arr.reduce((val, vote)=>{
        if(vote.voted) {

        for(let i=0;i<conditions.length;i++) {
            if(vote.age <= conditions[i][1]) {
            val[conditions[i][0]] = val[conditions[i][0]] ? val[conditions[i][0]] + 1 : 1;
            return val;
          }
        }
      }
      return val;
   }, {})
}

console.log(voterResults(voters));

const投票者=[
{姓名：'Bob'，年龄：30岁，投票结果：正确}，
{姓名：'Jake'，年龄：32岁，投票结果：正确}，
{姓名：'Kate'，年龄：25岁，投票：false}，
{姓名：'Sam'，年龄：20岁，投票：false}，
{姓名：'Phil'，年龄：21岁，投票结果：正确}，
{姓名：'Ed'，年龄：55岁，投票结果：正确}，
{姓名：'Tami'，年龄：54岁，投票结果：正确}，
{姓名：'Mary'，年龄：31岁，投票：false}，
{姓名：'Becky'，年龄：43岁，投票：false}，
{姓名：'Joey'，年龄：41岁，投票结果：正确}，
{姓名：'Jeff'，年龄：30岁，投票结果：正确}，
{姓名：'Zack'，年龄：19岁，投票：false}
];
//在这里定义您的限制，我们将检查{
如果（投票表决）{
对于（设i=0；i您可以简单地使用if条件

var voters = [
    {name:'Bob' , age: 30, voted: true},
    {name:'Jake' , age: 32, voted: true},
    {name:'Kate' , age: 25, voted: false},
    {name:'Sam' , age: 20, voted: false},
    {name:'Phil' , age: 21, voted: true},
    {name:'Ed' , age:55, voted:true},
    {name:'Tami' , age: 54, voted:true},
    {name: 'Mary', age: 31, voted: false},
    {name: 'Becky', age: 43, voted: false},
    {name: 'Joey', age: 41, voted: true},
    {name: 'Jeff', age: 30, voted: true},
    {name: 'Zack', age: 19, voted: false}
];


function voterResults(){
    let youngVotes = 0;
    let youth = 0;
    let midVotes = 0;
    let mids =0;
    let oldVotes =0;
    let olds =0;
    for (var i = voters.length - 1; i >= 0; i--) {
        if(voters[i].age >= 18 && voters[i].age <= 25 && voters[i].voted === true){
            youngVotes++;
        }
        if(voters[i].age >= 18 && voters[i].age <= 25){
            youth++;
        }
        if(voters[i].age >= 26 && voters[i].age <= 35 && voters[i].voted === true){
            midVotes++;
        }
        if(voters[i].age >= 26 && voters[i].age <= 35 ){
            mids++;
        }
        if(voters[i].age >= 36 && voters[i].age <= 55 && voters[i].voted === true){
            oldVotes++;
        }
        if(voters[i].age >= 36 && voters[i].age <= 55){
            olds++;
        }
    }

    return{
        youngVotes,
        youth,
        midVotes,
        mids,
        oldVotes,
        olds
    }

}
console.log(voterResults())


var=[
{姓名：'Bob'，年龄：30岁，投票结果：正确}，
{姓名：'Jake'，年龄：32岁，投票结果：正确}，
{姓名：'Kate'，年龄：25岁，投票：false}，
{姓名：'Sam'，年龄：20岁，投票：false}，
{姓名：'Phil'，年龄：21岁，投票结果：正确}，
{姓名：'Ed'，年龄：55岁，投票结果：正确}，
{姓名：'Tami'，年龄：54岁，投票结果：正确}，
{姓名：'Mary'，年龄：31岁，投票：false}，
{姓名：'Becky'，年龄：43岁，投票：false}，
{姓名：'Joey'，年龄：41岁，投票结果：正确}，
{姓名：'Jeff'，年龄：30岁，投票结果：正确}，
{姓名：'Zack'，年龄：19岁，投票：false}
];
函数voterResults（）{
让YoungVoces=0；
让青春=0；
让中间投票数=0；
设mids=0；
让OldVoces=0；
设olds=0；
对于（var i=1.length-1；i>=0；i--）{
如果（选民[i]。年龄>=18&&i选民[i]。年龄=18&&i选民[i]。年龄=26&&i选民[i]。年龄=26&&i选民[i]。年龄=36&&i选民[i]。年龄这里使用的是
reduce
方法，年龄组可以轻松扩展


功能voterResults（arr）{
const ranges={youngvowers:[18,25]，young:[26,35]}；
返回arr
.filter（x=>x.filter）
.减少（（会计科目，当前）=>{
Object.keys（ranges）.forEach（key=>{
如果（curr.age>=ranges[key][0]&&curr.age需要什么样的实际输出，请说明？您在计算中没有使用输入arr。您需要定义年龄和投票值的逻辑。