Javascript 查找嵌套数组的和

我试图找到一个嵌套数组的所有数字之和，但我没有让它正常工作。这就是我所尝试的：

function arraySum(i) {
  sum = 0;
  for (a = 0; a < i.length; a++) {
    if (typeof i[a] == 'number') {
      sum += i[a];
    } else if (i[a] instanceof Array) {
      sum += arraySum(i[a]);
    }
  }
  return sum;
}

函数数组sum（i）{
总和=0；
对于（a=0；a

当您使用数组

[[1,2,3]，4,5]

进行尝试时，得到的答案是

6

，而不是

15

。

---

有人知道哪里有错误吗？

你在那里遗漏了两个

var

。您在窗口范围内隐式声明了

sum

和

a

：

function arraySum(i) {
    **var** sum=0;
    for(**var** a=0;a<i.length;a++){
        if(typeof i[a]=="number"){
            sum+=i[a];
        }else if(i[a] instanceof Array){
            sum+=arraySum(i[a]);
        }
    }
    return sum;
}

函数数组sum（i）{
**var**sum=0；
例如，对于（**var**a=0；a递归

function arraySum(x) {
    var sum = 0, i;
    if (typeof x === 'number')
        return x;
    else if (x instanceof Array)
        for (i = 0; i < x.length; ++i)
            sum += arraySum(x[i]);
    return sum;
}
arraySum([[1,2,3],4,5]); // 15

函数数组sum（x）{
var总和=0，i；
如果（x的类型=='number'）
返回x；
else if（数组的x实例）
对于（i=0；i

我并没有对此进行优化，所以很明显，在递归之前，您可能需要更多的逻辑


你的代码不起作用的原因是因为你需要
var
和
a
这两个变量。你的代码的问题是
sum
和
a
变量是全局变量，而不是局部变量。因此你得到了一个无限循环（函数中第一个条目的a由第二个条目重置，因此再次处理相同的元素）

通过将
var
添加到声明
sum
和
a
的位置，使其成为函数的局部变量，从而修复此问题：

function arraySum(i) {
    var sum=0; // missing var added
    for(var a=0;a<i.length;a++){ // missing var added
        if(typeof i[a]=="number"){
            sum+=i[a];
        }else if(i[a] instanceof Array){
            sum+=arraySum(i[a]);
        }
    }
    return sum;
}

函数数组sum（i）{
var sum=0；//添加了缺少的变量
对于（var a=0；a首先，为什么使用“i”作为函数的输入？我们使用“i”表示运行索引。。
关于您的问题，您希望“a”在循环中是本地的，所以不要“for（a=0；…”而要“write”for（var a=0


函数嵌套数组求和（arr）
{
var总和=0；
对于2018年的（var i=0；i），该解决方案干净且功能正常：

let arr = [[1,2,3],4,5]
arr.flat().reduce((accumulator,currentValue)=>accumulator+currentValue)

和的文档。
可以使用lodash和：


const arr=[[1,2,3,4,5]；
arraySum（arr）；
函数arraySum（arr）{
var ARRFLANTS=u0.flattdeep（arr）；
// => [1, 2, 3, 4, 5]
控制台日志（u.sum（arrs））；
}
我知道很晚了，但他们说“永远不会晚”：


const sumNestedArray=arr=>arr.flat（无穷大）.reduce（（a，b）=>a+b，0）
log（sumNestedArray（[1,2]，[2,3,4]]）
给你：

（我的假设是，您希望将字符串（例如“13”）解析为数字，以便将它们包含在总和中。如果没有，只需将
isNumber
更改为
typeof val==='number'
）

function arraySum(arr) {
  let sum = 0;

  while (arr.length) {
    const val = arr.pop();
    const isArray = typeof val === 'object' && val.length !== undefined;
    const isNumber = !isArray && !isNaN(sum + parseFloat(val)); 

    if (isArray && val.length) {
      sum += arraySum(val);
    }
    else if (isNumber) {
      sum += parseFloat(val);
    }
  }

  return sum;
}

console.log(arraySum([])); //0
console.log(arraySum([1, 1, 1, [3, 4, [8]], [4]])); //22
console.log(arraySum([1, 1, [], {}, 'l', 1, [3, 4, [8]], [4]])); //22

我也这么想，但在6Var中测试它仍然会产生这样的结果：）尝试将
var-sum
移动到函数上方。我认为声明：var-sum=0；会对您起作用。缺少关键字var.+1，似乎每个人都发现了缺少的
var
for-sum，但没有人注意到for循环中缺少它。现场做得很好，也解释了问题！正确格式化的代码总是很容易的阅读和理解。我已为您格式化了此答案。请阅读有关格式化的帮助指南。请解释此代码如何解决OP的问题。您使用了错误的编程语言回答了问题…另外还有“
来自内置导入int
”o\o
let arr = [[1,2,3],4,5]
arr.flat().reduce((accumulator,currentValue)=>accumulator+currentValue)

const sumNestedArray = arr => arr.flat(Infinity).reduce((a,b)=> a+b, 0)

function arraySum(arr) {
  let sum = 0;

  while (arr.length) {
    const val = arr.pop();
    const isArray = typeof val === 'object' && val.length !== undefined;
    const isNumber = !isArray && !isNaN(sum + parseFloat(val)); 

    if (isArray && val.length) {
      sum += arraySum(val);
    }
    else if (isNumber) {
      sum += parseFloat(val);
    }
  }

  return sum;
}

console.log(arraySum([])); //0
console.log(arraySum([1, 1, 1, [3, 4, [8]], [4]])); //22
console.log(arraySum([1, 1, [], {}, 'l', 1, [3, 4, [8]], [4]])); //22