Javascript 如何查找对象中所有值和数组中包含的对象的总和？

如何找到该对象中所有值的总和？在包含对象的数组中，另一个具有值的对象可能是具有类似结构对象的“下一个”数组

{
  value: 4,
  next: [
    {
      value: 3,
      next: [...]
    },
    {
      value: 3,
      next: [...]
    },
    ...
  ]
}

---

您需要递归来处理对象的任意嵌套：

const nestedSum=o=>（o.next | |[]）。reduce（（acc，o）=>acc+nestedSum（o），o.value）；
//演示
常数数据={
价值：4，
下一步：[{
价值：3，
下一步：[{值：5}]
}, {
价值：3，
下一个：[]
},
]
};
console.log（nestedSum（数据））

您需要一个递归函数，检查一个键的值是否是一个数字，然后与变量相加，否则如果它是一个类似于

next

的数组，则遍历它，然后使用新对象再次调用同一个函数

let数据={
价值：4，
下一步：[{
价值：3，
下一步：[{
价值：4
}, {
价值：5
}]
},
{
价值：3，
下一步：[{
价值：2
}]
}
]
}
设和=0；
函数findSum（obj）{
用于（让钥匙进入obj）{
如果（对象的类型[键]='编号'）{
总和+=对象[键]；
}else if（Array.isArray（obj[keys]）&&obj[keys].length>0）{
obj[keys].forEach（功能（项）{
findSum（项目）
})
}
}
}
findSum（数据）；
console.log（sum）

使用和递归求和值：

const obj={
价值：4，
下一步：[{
价值：3，
下一步：[{值：1}]
}, {
价值：3，
下一个：[{值：2，下一个：[]}]
}]
};
常数和=（obj）=>
Object.entries（obj.reduce）（acc[k，v]）=>acc+(
k==“下一步”
v.map（总和）。减少（（s，x）=>s+x，0）
：k==“值”？v:0）
, 0);
控制台日志（总和（obj））
函数和（obj，电流=0）{
const nextSum=（obj.next | |[]）。reduce（（nextSum，obj）=>nextSum+sum（obj，current），0）
返回电流+nextSum+obj.value
}
常量示例={
价值：4，
下一步：[
{
价值：3，
下一步：[{
价值：7
}]
},
{
价值：3
}
]
}
console.log（sum（示例））//必须为17
对象的结构称为树。
您可以使用或接近并收集沿途的总和

其他答案说你必须递归，但你可以用广度优先的方法迭代，我在代码片段中向你展示了这两种方法

我已经扩展了您的数据示例，添加了空值，其中假定没有下一个值（实际上可以使用任何类型的检查）


let数据={
价值：4，
下一步：[
{
价值：3，
下一步：[
{
数值：5，
下一个：空
},
{
价值：6，
下一个：空
}
]
},
{
价值：2，
下一步：[
{
价值：2，
下一个：空
},
{
价值：3，
下一步：[
{
数值：7，
下一个：空
},
{
数值：8，
下一个：空
}
]
}
]
}
]
}
//迭代法
功能范围第一（节点）{
设和=0
设q=[节点]
而（q.length>0）{
let node=q.pop（）
总和+=节点值
if（node.next！==null）{
for（让另一个node.next）{
q、 推送（其他）
}
}
}
回报金额
}
log（'breadthFirst sum（迭代）：'，breadthFirst（data））
//递归逼近
功能深度优先（节点）{
设和=0
函数递归（节点）{
总和+=节点值
if（node.next！==null）{
for（让另一个node.next）{
递归（其他）
}
}
}
递归（节点）
回报金额
}
console.log（'depthFirst sum（recursive）：'，depthFirst（data））
如果将next:[]更改为next:[{value:5}]，它的可能重复项似乎不正确。我已将该大小写添加到代码段中。@trincot您能让我解释一下如何使用
o.value
？我是怎么看的？首先，我们检查是否有数组，为了使用reduce，然后我们使用递归，然后我不理解这一部分：
o.value
：）
o.value
作为第二个参数传递给
reduce
，以便通过回调累积的和从该值开始（与从0开始相反）。我们当然可以通过0代替，然后将
o.value
添加到
reduce
的返回值中，但这只是一个额外的操作。最好直接从
o.value
开始求和。