如何找到对象中所有值的总和以及数组中包含的对象？

Question

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

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

Answer 1

对象的结构称为树Tree (data structure)。 您可以使用breadth-first 或depth-first 方法对traverse the tree 进行汇总。

其他答案说您必须递归，但您可以使用广度优先方法迭代地执行此操作，我在代码 sn-p 中向您展示了这两种方法。

我已经扩展了你的数据样本，在应该没有下一个值的地方添加了空值（你真的可以使用任何类型的检查）。

let data = {
  value: 4,
  next: [
    {
      value: 3,
      next: [
        {
          value: 5,
          next: null
        },
        {
          value: 6,
          next: null
        }
      ]
    },
    {
      value: 2,
      next: [
        {
          value: 2,
          next: null
        },
        {
          value: 3,
          next: [
            {
              value: 7,
              next: null
            },
            {
              value: 8,
              next: null
            }
          ]
        }
      ]
    }
  ]
}

// iterative approach
function breadthFirst(node){
  let sum = 0
  let q = [node]

  while(q.length > 0){
    let node = q.pop()
    sum += node.value

    if (node.next !== null) {
      for (let other of node.next){
        q.push(other)
      }
    }
  }

  return sum
}

console.log('breadthFirst sum (iterative):', breadthFirst(data))

// recursive apporach
function depthFirst(node){
  let sum = 0

  function recursion(node){
    sum += node.value

    if (node.next !== null) {
      for (let other of node.next){
        recursion(other)
      }
    }
  }

  recursion(node)

  return sum
}

console.log('depthFirst sum (recursive):', depthFirst(data))

Answer 2

使用reduce 和Object.entries 对这些值进行递归求和：

const obj = {
  value: 4,
  next: [{
    value: 3,
    next: [{ value: 1 }]
  }, {
    value: 3,
    next: [{ value: 2, next: [] }]
  }]
};

const sum = (obj) =>
  Object.entries(obj).reduce((acc, [k, v]) => acc + (
    k === 'next'
      ? v.map(sum).reduce((s, x) => s + x, 0)
      : k === 'value' ? v : 0)
  , 0);

console.log(sum(obj));

Answer 3

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

const nestedSum = o => (o.next || []).reduce((acc, o) => acc + nestedSum(o), o.value);

// Demo
const data = {
  value: 4,
  next: [{
      value: 3,
      next: [{value: 5}]
    }, {
      value: 3,
      next: []
    },
  ]
};

console.log(nestedSum(data));

Answer 4

function sum(obj, current = 0) {
   const nextSum = (obj.next || []).reduce((nextSum, obj) => nextSum + sum(obj, current), 0)
   return current + nextSum + obj.value
}

const example = {
  value: 4,
  next: [
    {
      value: 3,
      next: [{
        value: 7
      }]
    },
    {
      value: 3
    }
  ]
}

console.log(sum(example)) // must be 17

Answer 5

您需要一个递归函数并检查键的值是否为数字，然后与变量相加，否则如果它是像next 这样的数组，则遍历它并再次使用新对象调用相同的函数

let data = {
  value: 4,
  next: [{
      value: 3,
      next: [{
        value: 4
      }, {
        value: 5
      }]
    },
    {
      value: 3,
      next: [{
        value: 2
      }]
    }
  ]
}

let sum = 0;

function findSum(obj) {
  for (let keys in obj) {
    if (typeof obj[keys] === 'number') {
      sum += obj[keys];
    } else if (Array.isArray(obj[keys]) && obj[keys].length > 0) {
      obj[keys].forEach(function(item) {
        findSum(item)

      })
    }
  }
}

findSum(data);
console.log(sum)