Javascript 如何对嵌套数组中的所有元素求和？

这是一个数组，如下所示：

let arrayNumbers = [ 5, 7, 
        [ 4, [2], 8, [1,3], 2 ], 
        [ 9, [] ], 
        1, 8
      ];

并且输出必须是

50

此代码必须不带Array.isArray

let sum = 0;
function treeSum(array) {
    for (let i = 0; i < array.length; i++) {
        if (array[i] === false) {
            treeSum(array[i]);
        } else {
            sum += array[i];
        }
    }
    return sum;
}

treeSum(arrayNumbers);

let sum=0；
函数树（数组）{
for（设i=0；i

---

帮助，请提供一个想法或代码，谢谢。

您可以

flat

列表，然后使用

reduce

方法获得总和

您可以使用

if（item.map）

条件来检查它是否是数组

让arrayNumbers=[5,7,，
[ 4, [2], 8, [1,3], 2 ], 
[ 9, [] ], 
1, 8
];
常量数组=（arr）=>{
常数res=[]
用于（arr的施工项目）{
if（item.map）{
const subRes=扁平阵列（项目）
res.push（…子res）
}否则{
资源推送（项目）
}
}
返回res；
}      
log（flatArray（arrayNumbers）.reduce（（a，b）=>a+b））

您还需要使用一个本地

sum

变量，以防止重复添加嵌套和

你可以检查一下这个项目

• 是…的一个例子

  函数树（数组）{
  var总和=0；
  for（设i=0；iconsole.log（treeSum（arrayNumbers））您可以使用递归。所以您需要检查迭代元素是否为数组。如果是array，则再次运行
  sumArray
  方法，否则可以求和值：
  
  const sumArray = (arr) => {
    let sum = 0;
    arr.forEach(element => {
      if (typeof element != 'number') {
          sum += sumArray(element);
      } else {
        sum += element
        return sum;
      }
    });
    return sum;
  }
  
  
  console.log(sumArray(arrayNumbers));
  
  例如：
  
  
  让arrayNumbers=[5,7,，
  [ 4, [2], 8, [1,3], 2 ],
  [ 9, [] ],
  1, 8
  ];
  常量数组=（arr）=>{
  设和=0；
  arr.forEach（元素=>{
  if（元素类型！=“编号”）{
  sum+=sum数组（元素）；
  }否则{
  总和+=元素
  回报金额；
  }
  });
  回报金额；
  }
  log（sumArray（arrayNumbers））您可以使用“连接”、“拆分”和“减少”的组合
  
  
  var t=[5,7,，
  [ 4, [2], 8, [1,3], 2 ], 
  [ 9, [] ], 
  1, 8
  ].join（）.split（'，）.reduce（函数（a，b）{return parseInt（a？a:“0”）+parseInt（b？b:“0”）}
  console.log（t）
  使用功能：
  
  var flat = arrayNumbers.flat(Infinity);
  var sum = flat.reduce((x, y) => x + y);
  console.log(sum);
  
  对任何数组深度都有效的一个简单技巧是将
  连接到字符串。
  
  然后使用
  match
  获取数字。
  
  然后
  将这些数字减少为一个总和
  
  示例代码片段：
  
  
  让arrayNumbers=[5,7,，
  [ 4, [2], 8, [1,3], 2 ], 
  [ 9, [] ], 
  1, 8
  ];
  设sum=arrayNumbers
  .join（）
  .match（/\d+/g）
  .reduce（（acc，x）=>acc+parseInt（x），0）；
  console.log（sum）
  按如下方式展平并缩小阵列：-
  
  var sum = arrayNumbers.flat(Infinity).reduce((a,b)=>a+b)
  
  使用
  Array.prototype.reduce的递归版本
  让arrayNumbers=[5,7,4,2,8,1,3,2,9,1,8]；
  函数树（数组）{
  返回数组.reduce(
  （和，n）=>
  总数+
  （类型n==“编号”
  ？//n是一个数字
  N
  ：//n是一个数组
  树根（n）），
  0
  );
  }
  console.log（treeSum（arrayNumbers）==50）；
  
  使用<代码>的递归版本
  让arrayNumbers=[5,7,4,2,8,1,3,2,9,1,8]；
  函数树（数组，和=0）{
  for（数组的常数n）{
  sum+=类型n==“数字”？n:treeSum（n）；
  }
  回报金额；
  }
  console.log（treeSum（arrayNumbers）==50）；
  
  迭代版本
  让arrayNumbers=[5,7,4,2,8,1,3,2,9,1,8]；
  函数树（数组）{
  设和=0；
  做{
  //非求和值
  让值=[]；
  for（数组的常数n）{
  如果（类型n==“数字”）和+=n；
  else值=值。concat（n）；
  }
  数组=值；
  }而（array.length>0）；
  回报金额；
  }
  console.log（treeSum（arrayNumbers）==50）；
  
  使用
  Array.prototype.flat的单线解决方案
  为什么要“计数数组元素”或获取所有元素的总和？为什么
  5
  ？
  arrayNumbers.flat（无穷大）。reduce（（a，b）=>a+b，0）
  ？是50，我正在尝试解决这个问题，是否值得解释为什么不能使用
  Array.isArray
  ？它一直支持IE9。如果不能使用
  Array.isArray
  ，那么还有什么东西不能使用<代码>平面
  ，
  平面映射
  ，
  减少
  ，递归，
  类型
  ，
  实例
  ，
  构造函数
  。。。？如果没有更多的上下文，这样的要求就没有意义。我也不能这样做，这就是问题所在（
  Array#reduce
  如果没有初始值，则会对空数组抛出错误。因此，您可能应该将
  0
  设置为reducer的初始值。请注意
  Number（[]）
  返回
  0
  ，因此这与JavaScript将空数组转换为数字的方式一致。@PStarter，我使用了
  if（item.map）
  检查它是否是数组。@customcommander，OP说
  此代码必须没有数组。isArray；
  @customcommander，一个可能的选择是
  类型的arr.map==='function'
  为什么
  .flat（）.flat（）
  何时可以指定深度？如果数组为空，没有初始值的缩减器将抛出错误。您应该指定
  0
  作为初始值。感谢深度建议，并且不会给出错误，因为它已经有值，否则您可以使用默认值
  let arrayNumbers = [5, 7, [4, [2], 8, [1, 3], 2], [9, []], 1, 8];
  
  function treeSum(array) {
    return array.flat(Infinity).reduce((sum, n) => sum + n, 0);
  }
  
  console.log(treeSum(arrayNumbers) === 50);