能否实现支持尾调用优化（TCO）的递归生成器类？

已知通过函数、reduce等方式可实现尾调用优化（TCO），其核心要求是函数在尾位置返回，或借助trampoline等工具实现，但能否通过生成器/迭代器类实现具备TCO特性的递归逻辑？

目前我能运行的最佳方案是基于栈的TCO实现，但该方案代码冗余度较高，希望获取更专业的最优方案建议。

我了解TCO通常和递归函数调用绑定，而非面向对象或迭代器结构，但始终未找到明确答案，ECMAScript规范也未对此作出清晰说明。

1. 首次尝试（递归yield委托） #

最初实现了一个递归生成器类，当节点存在已加载的children数组时，创建新实例并通过yield*委托给它。根据ECMAScript规范，yield*委托似乎能高效处理递归，不会额外消耗栈帧，但未找到细节说明。

class RecursiveIterator {
    constructor(iterable) {
        this._iterable = iterable
    }

    hasChildren(node) {
        return !!node && Object.hasOwn(node, 'children') && Array.isArray(node.children)
    }

    * [Symbol.iterator]() {
        for (const node of this._iterable.values()) {
            if (this.hasChildren(node)) {
                yield* new RecursiveIterator(node.children)
            }
            yield node
        }
    }
}

2. 第二次尝试（表达式式） #

尝试在类的生成器方法内用yield*委托自身的递归调用。yield*虽比传统递归内存高效，但似乎并非严格意义上的TCO。

class RecursiveGeneratorAttempt2 {
    constructor(iterable) {
      this._iterable = iterable
    }

    * generator(iterable = this._iterable) {
      for (const node of iterable) {
        if (node.children) {
          yield* this.generator(node.children)
        }
        yield node
      }
    }

    * [Symbol.iterator]() {
      yield* this.generator()
    }
  }

3. 第三次尝试（栈迭代） #

用_stack跟踪嵌套迭代结构，以纯迭代方式处理数据，是目前最接近目标的实现。

class RecursiveGeneratorAttemptStack {
    constructor(iterable) {
      this._iterable = iterable;
      this._stack = [];
      this._index = 0;

      return {
        [Symbol.iterator]: () => {
          return {
            next: () => {
              while (this._iterable[this._index] || this._stack.length > 0) {
                if (this._iterable[this._index]) {
                  const value = this._iterable[this._index];
                  this._index += 1;
                  if (value.children) {
                    this._stack.push([this._iterable, this._index]);
                    this._iterable = value.children;
                    this._index = 0;
                  }
                  return { value, done: false };
                } else {
                  [this._iterable, this._index] = this._stack.pop();
                }
              }
              return { done: true };
            },
          };
        },
      };
    }
  }

4. 基于反馈的第四次尝试 #

仅修改迭代器方法，将yield*的委托改为带返回值的形式，验证是否能触发类似TCO的优化：

class RecursiveGeneratorAttempt2 {
  //...省略其他代码，仅修改迭代器方法
  * [Symbol.iterator]() {
    return yield* this._iterator
  }
}

各尝试的核心特性 #

1. 递归yield委托（尝试1、2、4）：
   yield*的本质是迭代委托，ECMAScript规范中并未将其纳入TCO的优化范畴。虽然它不会像普通递归那样一次性压满调用栈，但每次委托都会创建新的生成器实例，这些实例会驻留在内存中直到整个迭代完成。对于常规嵌套深度的场景，代码简洁易读，性能足够；但面对极端深层嵌套（如十万级层级）时，会产生不可忽视的内存开销。

2. 基于栈的迭代（尝试3）：
   完全通过栈模拟递归层级，无任何递归调用，内存消耗仅取决于当前嵌套深度，而非总节点数，真正实现了类似TCO的内存高效性。但原实现代码冗余，直接操作数组索引的方式不够符合迭代器协议的设计理念。

优化后的最优方案 #

以下是简化且更符合迭代器规范的栈式实现，兼顾内存高效性与代码可读性：

class StackBasedRecursiveIterator {
  constructor(iterable) {
    // 栈元素格式：[迭代器实例, 预取的next结果]
    this.stack = [[iterable[Symbol.iterator](), null]];
  }

  *[Symbol.iterator]() {
    while (this.stack.length > 0) {
      const top = this.stack[this.stack.length - 1];
      const [iterator, preFetch] = top;
      // 若未预取，则调用迭代器的next方法
      const result = preFetch ?? iterator.next();

      if (result.done) {
        // 当前迭代器耗尽，弹出栈
        this.stack.pop();
      } else {
        // 重置预取标记，避免重复处理
        top[1] = null;
        const node = result.value;
        // 若节点有子节点，将子节点迭代器压入栈
        if (node.children && Array.isArray(node.children)) {
          this.stack.push([node.children[Symbol.iterator](), null]);
        }
        // 输出当前节点
        yield node;
      }
    }
  }
}

方案优势 #

• 完全遵循迭代器协议，兼容所有可迭代对象（不仅限于数组）
• 内存消耗仅与当前嵌套深度相关，极端场景下表现稳定
• 代码结构简洁，逻辑清晰，避免了原实现中直接操作数组索引的冗余代码

关键结论 #

ECMAScript规范中并未定义生成器/迭代器类的TCO特性，yield*委托不属于TCO优化场景。若追求严格的内存高效性，基于栈的迭代实现是最优选择；若场景对嵌套深度要求不高，递归yield委托的实现更简洁易用。

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