मेरे पास जावास्क्रिप्ट ऑब्जेक्ट है, और आईडी की सरणी है:

var ids = [46,44,49,47];
var obj = {
        "46": {
            "group": "A",
            "temp": 26,
            "humid": 36
        },
        "44": {
            "group": "B",
            "temp": 19,
            "humid": 32
        },
        "49": {
            "group": "B",
            "temp": 20,
            "humid": 31
        },
        "47": {
            "group": "A",
            "temp": 24,
            "humid": 32
        }
    };

मैं प्रत्येक 'group' का औसत 'temp' प्राप्त करना चाहता हूं। मैं यह कैसे कर सकता हूँ?

मुझे अन्य उदाहरण मिले जो इस समस्या को हल करेंगे, हालांकि, ये उदाहरण मानते हैं कि 'group' हमेशा एक जैसे रहेंगे। मेरे मामले में, 'group' हमेशा बदलता रहता है।

तो अनिवार्य रूप से मुझे यह पता लगाना होगा कि कितने अद्वितीय समूह मौजूद हैं, फिर प्रत्येक का औसत 'temp' मान वापस करें।

मैंने एक साथ नेस्टेड लूप के लिए कुछ का उपयोग करने का प्रयास किया, लेकिन यह जल्दी से जटिल हो गया ...

अपेक्षित उत्पादन: avgTemps = {"A":25, "B": 19.5}

1
MattG 11 जुलाई 2021, 20:09

5 जवाब

सबसे बढ़िया उत्तर

पहले चरण में, आप डेटा में मौजूद अद्वितीय समूह नामों की एक सूची प्राप्त करते हैं। फिर, आप प्रत्येक समूह के लिए तापमान को फ़िल्टर करते हैं और औसत की गणना करते हैं।

आप किसी सूची (_.uniq) से डुप्लिकेट प्रविष्टियों को हटाने और संख्याओं की एक सरणी (_.sum) को जोड़ने के लिए लॉश फ़ंक्शन का भी उपयोग कर सकते हैं।

var ids = [46,44,49,47];
var obj = {
        "46": {
            "group": "A",
            "temp": 26,
            "humid": 36
        },
        "44": {
            "group": "B",
            "temp": 19,
            "humid": 32
        },
        "49": {
            "group": "B",
            "temp": 20,
            "humid": 31
        },
        "47": {
            "group": "A",
            "temp": 24,
            "humid": 32
        }
    };
function onlyUnique(value, index, self) {
  return self.indexOf(value) === index;
}

let groups = Object.values(obj).map((o)=>o.group).filter(onlyUnique)
for (let group of groups) {
  let temps = Object.values(obj).filter((o)=>o.group===group).map((o)=>o.temp)
  let avgtmp = temps.reduce((pv, cv) => pv + cv, 0)/temps.length;
  console.log(`group ${group} has an avg tmp of ${avgtmp}`)
}

// OUTPUT
// group B has an avg tmp of 19.5
// group A has an avg tmp of 25
1
jboockmann 11 जुलाई 2021, 17:26

आप समूह की प्रत्येक आईडी प्राप्त करने के लिए Object.keys(obj) का उपयोग कर सकते हैं।

तब आप इस समूह से इस तरह के मूल्य प्राप्त कर सकते हैं:

const obj = {
        "46": {
            "group": "A",
            "temp": 26,
            "humid": 36
        },
        "44": {
            "group": "B",
            "temp": 19,
            "humid": 32
        },
        "49": {
            "group": "B",
            "temp": 20,
            "humid": 31
        },
        "47": {
            "group": "A",
            "temp": 24,
            "humid": 32
        }
    };

Object.keys(obj).map((id) => console.log(`Temp of id ${id} is ${obj[id].temp}`))

हम समूह मूल्यों के साथ वस्तु बना सकते हैं।

अब यदि आप अपने ओबीजे को मैप कर सकते हैं, तो आइए प्रत्येक समूह का औसत मूल्य बनाएं।

const obj = {
            "46": {
                "group": "A",
                "temp": 26,
                "humid": 36
            },
            "44": {
                "group": "B",
                "temp": 19,
                "humid": 32
            },
            "49": {
                "group": "B",
                "temp": 20,
                "humid": 31
            },
            "47": {
                "group": "A",
                "temp": 24,
                "humid": 32
            }
        };
const groups = {};

Object.keys(obj).map((id) => {
  if(!!groups[obj[id].group]) {
    groups[obj[id].group].push(obj[id].temp);
  } else {
    groups[obj[id].group] = [obj[id].temp]
  }
})

console.log(groups)

तब अंत में हम औसत तापमानों की गणना कर सकते हैं।

const obj = {
            "46": {
                "group": "A",
                "temp": 26,
                "humid": 36
            },
            "44": {
                "group": "B",
                "temp": 19,
                "humid": 32
            },
            "49": {
                "group": "B",
                "temp": 20,
                "humid": 31
            },
            "47": {
                "group": "A",
                "temp": 24,
                "humid": 32
            }
        };
const groups = {};

Object.keys(obj).forEach((id) => {
  if(!!groups[obj[id].group]) {
    groups[obj[id].group].push(obj[id].temp);
  } else {
    groups[obj[id].group] = [obj[id].temp]
  }
})

function getAvg(grades) {
  const total = grades.reduce((acc, c) => acc + c, 0);
  return total / grades.length;
}

Object.keys(groups).forEach((group) => {
  groups[group] = getAvg(groups[group])
})

console.log(groups)
1
Kordrad 11 जुलाई 2021, 17:30

यह थोड़ा छोटा होना चाहिए:

 let output = {};
 
 for (let group in obj) {
        const groupName = obj[group]['group'];
        if(!output[groupName]) {
            output[groupName] =  obj[group]['temp'];
         } else {
            output[groupName] = (output[groupName] + obj[group]['temp'])/2;
         }
 }
 console.log(output);
1
Pasha 11 जुलाई 2021, 17:32

लक्ष्य वस्तु को पहले योग और गणना के साथ बनाएं, और फिर उन्हें औसत से विभाजित करें:

function getAvgTemp(obj) {
    let data = Object.values(obj);
    let result = Object.fromEntries(data.map(({group}) => [group, { sum: 0, count: 0 }]));
    for (let {group, temp} of data) {
        let o = result[group];
        o.count++; 
        o.sum += temp;
    }
    for (let key of Object.keys(result)) {
        result[key] = result[key].sum / result[key].count;
    }
    return result;
}

// Demo    
var obj = {"46": {"group": "A","temp": 26,"humid": 36},"44": {"group": "B","temp": 19,"humid": 32},"49": {"group": "B","temp": 20,"humid": 31},"47": {"group": "A","temp": 24,"humid": 32}};
let avgTemp = getAvgTemp(obj);
console.log(avgTemp);

ध्यान दें कि ids सरणी अधिक लगती है, क्योंकि वस्तु के गुणों को Object.keys के साथ एकत्र किया जा सकता है।

1
trincot 11 जुलाई 2021, 17:39

सबसे पहले, मैंने सभी अद्वितीय समूहों को भेद के लिए एक सेट में लिया है। फिर बनाई गई वस्तुओं की एक सरणी में हेरफेर किया जाता है और अंततः सभी औसत, गणना और कुल वस्तुओं की सरणी में असाइन किया जाता है। और अपेक्षित परिणाम उत्पन्न होता है।

  var ids = [46, 44, 49, 47];
  var obj = {
    "46": {
      "group": "A",
      "temp": 26,
      "humid": 36
    },
    "44": {
      "group": "B",
      "temp": 19,
      "humid": 32
    },
    "49": {
      "group": "B",
      "temp": 20,
      "humid": 31
    },
    "47": {
      "group": "A",
      "temp": 24,
      "humid": 32
    }
  };
  var groups = new Set()
  Object.keys(obj).forEach(element => {
    groups.add(obj[element].group);
  });
  var tempAvgByGroups = [];
  const avgTemp = {}
  groups.forEach(element => {
    const groupObj = {
      "group": element,
      "average": 0,
      "count": 0,
      "total": 0,
    }
    Object.keys(obj).forEach(item => {
      if (element === obj[item]["group"]) {
        groupObj["count"] = groupObj["count"] + 1;
        groupObj["total"] = groupObj["total"] + obj[item]["temp"]
      }
    });
    groupObj["average"] = groupObj["total"] / groupObj["count"];
    tempAvgByGroups.push(groupObj);
    avgTemp[element] = groupObj["average"]
  });
  console.log(avgTemp);
0
Ehtesham Ahmad Nadim 11 जुलाई 2021, 17:51