如何计算JavaScript对象中的值？

Question

我想获得等于一定数量的所有值并计算每个对象中的多少个。

我的代码看起来像这样：

var countItems = {
    "aa":"70",
    "bb":"70",
    "cc":"80",
    "dd":"90",
    "ee":"90",
    "ff":"90"
}

现在我想做的就是在下半场计数每个。

例如，有两个“ 70”，一个“ 80”和三个90

var firstCounter  = ?? // 2
var secondCounter = ?? // 1
var thirdCounter  = ?? // 3

。

如果像以下内容一样构成不同的构造，我可以这样做：

let firstCounter = 0;
for (let i = 0; i < countItems.length; i++) {
  if (countItems[i].status === '70') firstCounter++;
}

let secondCounter = 0;
for (let i = 0; i < countItems.length; i++) {
  if (countItems[i].status === '80') secondCounter++;
}

let thirdCounter = 0;
for (let i = 0; i < countItems.length; i++) {
  if (countItems[i].status === '90') thirdCounter++;
}

但是，我的原始代码不是那样的结构，所以我不确定如何调整它。

我如何计算原始列表中的项目（ var countitems ），以便找出每个值多少？

Answer 1

您可以使用 object.values（countitems）获得看起来像这样的数组： [“ 70”，“ 70”，“ 80”，“ 90”，“ 90”，“ 90”，“ 90“] 然后，要么使用循环的有条件地增加所需的任何计数器，要么使用 array.reduce.reduce 或 array.filter.filter.filter 计算所需的元素。

Answer 2

您可以使用降低来创建一个计数的哈希地图，因此：

const countItems = [
  { data: 'aa', status: '70' },
  { data: 'bb', status: '70' },
  { data: 'cc', status: '80' },
  { data: 'dd', status: '90' },
  { data: 'ee', status: '90' },
  { data: 'ff', status: '90' },
];

const countedHash = countItems.reduce((acc, curr) => {
  if (!acc[curr.status])
    acc[curr.status] = 1
  else
    acc[curr.status] += 1
  return acc
}, {})

/* print out the results */
console.log(countedHash)

Answer 3

您可以访问这样的对象键：

countItems["aa"] // it will return "70"

您也可以在对象上循环（如果您想像示例中这样做一样）：

for (const item in countItems) {
    console.log(countItems[item])
    if (countItems[item] == "70") firstCounter++;
    
}

Answer 4

object.values（）和 redable（）都是正确的想法。在一起...

var countItems = {
    "aa":"70",
    "bb":"70",
    "cc":"80",
    "dd":"90",
    "ee":"90",
    "ff":"90"
};

let counts = Object.values(countItems).reduce((acc, value) => {
  if (!acc[value]) acc[value] = 0;
  acc[value]++;
  return acc;
}, {});

let [theFirstValue, theSecondValue, theThirdValue] = Object.values(counts)

console.log(theFirstValue, theSecondValue, theThirdValue);

Answer 5

const countItems = [
  { data: 'aa', status: '70' },
  { data: 'bb', status: '70' },
  { data: 'cc', status: '80' },
  { data: 'dd', status: '90' },
  { data: 'ee', status: '90' },
  { data: 'ff', status: '90' },
]; 

var countValues = Object.values(countItems);
let obj ={}
for(let val of countValues){
  if(!obj[val.status]){
    obj[val.status] = 1
  }else{
    obj[val.status] += 1
  }
}
 console.log(obj)

Answer 6

const names = ["Alice", "Bob", "Tiff", "Bruce", "Alice"];

const countedNames = names.reduce((allNames, name) => {
  const currCount = allNames[name] ?? 0;
  return {
    ...allNames,
    [name]: currCount + 1,
  };
}, {});


// results in countedNames having a value of:
// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }

名称阵列上的reald（）方法计算每个名称的出现并将结果存储在countednames对象中。让我们逐步浏览代码以了解其工作原理：

const names = [“爱丽丝”，“鲍勃”，“ tiff”，“ bruce”，“ alice”];
在这里，我们初始化了一个名为名称的数组，其中包含多个名称，包括重复条目。

const countednames = names.Reduce（（AllNames，name）=＆gt; {...}，{}）;
我们声明一个可变计数名称，并将其分配为应用于名称数组的redair（）方法的结果。 RELAD（）方法会在数组的每个元素上迭代，并根据回调函数累积单个值。

（AllNames，name）=＆gt; {...}
这是提供给Reled（）方法的回调函数。它需要两个参数：AllNames和名称。 AllNames表示将保留每个名称计数的累积对象，名称表示正在处理的当前元素。

const currcount = allnames [name] ?? 0;
在回调函数中，我们从Allnames对象中检索名称的当前计数。如果该名称在AllNames对象中不存在，则将CurrCount设置为0。

返回{... AllNames，[name]：CurrCount + 1};
我们返回一个新对象，将现有的AllNames对象与一个新属性[名称]相结合，其值为CurrCount + 1。这将当前名称的计数增量为1。

{}（for Realding（）初始值（））
{}作为第二个参数（）传递为AllNames参数的初始值。它表示一个空的对象，该对象将存储每个名称的计数。

RELAD（）方法在名称数组中的每个名称上迭代，对于每个名称，它检查它是否已经存在于AllNames对象中。如果存在，它将计数增加1;否则，它将名称添加为一个新属性，计数为1。此过程累积了每个名称的计数，从而导致最终计数名称对象：

{ 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }