Question

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

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

我认为我需要使用递归，这就是我想象的应该去：

1）功能需要params＆＃39; array＆＃39;和一个＆＃39; targetLevel＆＃39; （它应该进入的深度）并返回＆＃39;值的总和＆＃39;从级别[0]到级别[nth]。

2）在开始时，函数检查内部的level是否等于param level（如果是，则将当前级别添加到var值然后返回它）。

3）在每次迭代中发生以下条件之前：

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

示例：

countNthValue（children，3）将返回数字6 - ＆gt;级别[0]上的值+级别[1]上的值+级别[2]上的值

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

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

Answer 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));

Answer 2

建议：

foo::swap

Answer 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));

Answer 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>");

Answer 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>');
}

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

5 个答案: