嵌套Observable数组数字求和：代码报错原因咨询（预期结果16）

嘿，我来帮你揪出这个问题的根源！从你描述的错误——else分支提示acc1是数组——来看，核心问题出在递归逻辑里没有正确维护累加器的数字类型，大概率是你混淆了Observable的reduce和数组的reduce，或者在递归处理子数组时错误地把累加器当成数组来操作了。

先分析你可能踩的坑 #

假设你的错误代码大概是这样的：

import { of } from 'rxjs';
import { reduce } from 'rxjs/operators';

const nestedArray$ = of([1, [2, 3], [4, [5]], 1]); // 预期求和16

nestedArray$.pipe(
  reduce((acc, curr) => {
    if (typeof curr === 'number') {
      return acc + curr;
    } else {
      // 这里的acc会被错误地当成数组处理，因为curr是整个父数组
      return curr.reduce(reducer, acc);
    }
  }, 0)
).subscribe(sum => console.log(sum));

问题出在这两点：

1. Observable的reduce作用对象错了：Observable的reduce是对它发射的每个值进行累加——这里它只发射了一次，就是整个嵌套数组。所以第一个curr是整个数组，不是单个数字，直接进入else分支，把初始值0传入数组的reduce。如果你的递归逻辑没处理好，就会把累加器从数字变成数组。
2. 递归逻辑的累加器类型混乱：如果在递归处理子数组时，你没有把子数组的求和结果加到累加器上，而是错误地做了数组拼接（比如return [...acc, ...子数组结果]），那acc就会从数字变成数组，后续再执行加法操作时自然会报错。

正确的实现方式 #

我们可以拆分两步：先写一个递归函数处理嵌套数组的深度求和，再用Observable的操作符调用这个函数。

方法1：递归求和函数 + Observable map

import { of } from 'rxjs';
import { map } from 'rxjs/operators';

// 递归处理嵌套数组，返回所有数字的总和
function deepSum(arr: any[]): number {
  return arr.reduce((total, item) => {
    // 如果是子数组，递归求和；否则直接加数字
    return total + (Array.isArray(item) ? deepSum(item) : item);
  }, 0);
}

const nestedArray$ = of([1, [2, 3], [4, [5]], 1]); // 总和1+2+3+4+5+1=16

nestedArray$.pipe(
  map(arr => deepSum(arr))
).subscribe(sum => {
  console.log(sum); // 输出16
});

方法2：先扁平化数组再求和

如果你想用更多Observable操作符来实现，可以先把嵌套数组完全扁平化，再对扁平化后的数字序列求和：

import { of, from } from 'rxjs';
import { map, mergeMap, reduce } from 'rxjs/operators';

// 递归扁平化嵌套数组
function flattenDeep(arr: any[]): any[] {
  return arr.reduce((flat, item) => flat.concat(Array.isArray(item) ? flattenDeep(item) : item), []);
}

const nestedArray$ = of([1, [2, 3], [4, [5]], 1]);

nestedArray$.pipe(
  map(flattenDeep), // 把嵌套数组转成[1,2,3,4,5,1]
  mergeMap(flatArr => from(flatArr)), // 把数组转成逐个发射数字的Observable
  reduce((acc, curr) => acc + curr, 0) // 对所有数字求和
).subscribe(sum => console.log(sum)); // 输出16

总结 #

你的核心问题就是递归时没有保持累加器的数字类型——要么是误用了Observable的reduce，要么是递归逻辑里错误地将累加器当作数组操作。上面两种方法都能完美解决嵌套数组的深度求和问题，你可以根据自己的习惯选择。

内容的提问来源于stack exchange，提问作者EugenSunic