如何访问嵌套数组的第 n 级？答案

【问题标题】：How to access nth level of a nested array?如何访问嵌套数组的第 n 级？
【发布时间】：2016-04-25 20:52:26
【问题描述】：

我想编写一个函数，它遍历一个嵌套数组并返回 n 个值的总和（参见下面的示例）。

var children = {
  value: 1,
  children: {
    value: 3,
    children: {
      value: 2,
      children: {
        value: 5,
        children: {
          value: 3
        }
      }
    }
  }
}

我认为我需要使用递归，这就是我想象中的方式：

1) 函数接受参数“array”和“targetLevel”（它应该达到的深度）并返回从 level[0] 到 level[nth] 的“values”之和。

2) 一开始，函数会检查内部级别是否等于参数级别（如果是，则将当前级别添加到 var 值，然后返回）。

3) 直到满足条件，每次迭代都会发生以下情况：

结果 += 值
辅助 var level++（默认设置为 0），以便我可以跟踪我当前所处的级别
在 var children 中存储没有当前级别的给定数组
使用更新的参数调用函数，直到满足深度条件

例子：

countNthValue(children, 3) 将返回数字 6 -> level[0] 上的值 + level[1] 上的值 + level[2] 上的值

那么，我是否正确掌握了基本概念（递归调用函数，每次迭代存储数组的较小部分）？如果是这样，我该如何正确编写函数？

如果不是，这只是胡言乱语，我如何访问嵌套数组的第 n 级？

【问题讨论】：

你显示嵌套对象。

标签： javascript algorithm multidimensional-array

【解决方案1】：

根据你给出的对象，答案是 14

var children = {
  value: 1,
  children: {
    value: 3,
    children: {
      value: 2,
      children: {
        value: 5,
        children: {
          value: 3
        }
      }
    }
  }
}

 function sumChildren(children){
      if(children == undefined|| children== null) return 0;
      return children.value + sumChildren(children.children);
    
    }

console.log(sumChildren(children));

【讨论】：

【解决方案2】：

建议：

function getSum(obj, depth){
  var num = 0;
  if(depth - 1)
       num = getSum(obj.child, depth -1);
   return num + obj.value;
}

【讨论】：

【解决方案3】：

var children = {
  value: 1,
  children: {
    value: 3,
    children: {
      value: 2,
      children: {
        value: 5,
        children: {
          value: 3
        }
      }
    }
  }
}


function countNthValue (array, depth, current){

    if(typeof current === 'undefined') {
        current = 1;
    }

    if (depth > current && array.children) {
        return array.value + countNthValue(array.children, depth, current+1);
    } else {
        return array.value;
    }
}

// Test
console.log(countNthValue (children, 1));
console.log(countNthValue (children, 2));
console.log(countNthValue (children, 3));
console.log(countNthValue (children, 4));
console.log(countNthValue (children, 5));
console.log(countNthValue (children, 6));

【讨论】：

【解决方案4】：

你可以这样做

var children = {
                value: 1,
                children: {
                           value: 3,
                           children: {
                                      value: 2,
                                      children: {
                                                 value: 5,
                                                 children: {
                                                            value: 3
                                                           }
                                                }
                                     }
                          }
               },
        sums = (e, v) => !!e.children ? sums(e.children, v + e.value) : v + e.value;
document.write("<pre>" + sums(children,0) + "</pre>");

【讨论】：

【解决方案5】：

我建议使用数组和对象的组合以及递归调用内部Array#reduce 对值求和的函数。

var children = [{
        value: 1,
        children: [{
            value: 3,
            children: [{
                value: 2,
                children: [{
                    value: 5,
                    children: [{
                        value: 3
                    }]
                }]
            }]
        }]
    }],
    i;

function getLevel(array, level) {
    return ~level && Array.isArray(array) ?
        array.reduce(function (r, a) {
            return r + a.value + getLevel(a.children, level - 1);
        }, 0) :
        0;
}

for (i = 0; i < 5; i++) {
    document.write(getLevel(children, i) + '<br>');
}

【讨论】：