链表entries、keys、values方法：保留Generator还是改迭代器？如何实现？

背景 #

我正在实现一个模拟Array行为的链表类，现有基础类代码如下：

class Node {
  constructor(value, next_node=null, prev_node=null) {
    this.value = value;
    this.next_node = next_node;
    this.prev_node = prev_node;
  }
}

class List {
  constructor() {
    this.head = null;
    this.tail = null;
    this.length = 0;
  }
}

我尝试实现values()、entries()和keys()方法，当前用生成器函数实现的代码如下：

[Symbol.iterator]() {
  let current = this.head;
  return {
    next() {
      if (current) {
        let value = current.value;
        current = current.next; // 注意：原代码此处可能笔误，应为current.next_node
        return {value: value, done: false};
      }
      return {done: true};
    }
  };
}

entries() {
  return this._entries();
}

keys() {
  return this._keys();
}

values() {
  return this._values();
}

* _entries() {
  var node = this.head;
  var counter = 0;
  while (node) {
    yield [counter,node.value];
    node = node.next_node;
    counter += 1;
  }
}

* _keys() {
  var node = this.head;
  var counter = 0;
  while (node) {
    yield counter;
    node = node.next_node;
    counter += 1;
  }
}

* _values() {
  var node = this.head;
  while (node) {
    yield node.value;
    node = node.next_node;
  }
}

对比原生Array的方法返回值：

Object [Array Iterator] {} // array.entries()返回
Object [Generator] {}      // list.entries()返回

疑问1：是否应该保留Generator实现？为什么Array使用Array Iterator而非Generator？ #

1. 保留Generator完全可行：生成器对象天生符合迭代器协议（拥有next()方法，返回{value, done}结构），在for...of循环、扩展运算符...、Array.from()等实际场景中，它和原生迭代器的表现完全一致。如果你的代码只需要满足功能需求，生成器实现代码更简洁易读，没有强制修改的必要。

2. Array不用Generator的核心原因：

   • 性能优势：原生Array Iterator是JavaScript引擎底层实现的，没有生成器函数的状态管理、上下文切换开销，执行效率更高。
   • 封装性与类型统一：自定义迭代器（如Array Iterator）仅暴露迭代器协议要求的next()方法，不会像生成器那样暴露throw()、return()等额外方法，能更好地隐藏内部实现细节；同时内置集合类型统一使用专属迭代器类型，保持了语言生态的一致性。
   • 规范设计：ECMAScript规范中，Array、Map、Set等内置集合都使用专属迭代器对象而非生成器，这是语言设计层面的统一选择。

疑问2：如果改为迭代器实现，三个方法该如何编写？如何复用已有的[Symbol.iterator]？ #

可以封装一个通用的迭代器生成函数，复用遍历逻辑并生成符合要求的迭代器对象，同时让[Symbol.iterator]复用values()的实现（和Array行为保持一致）。修改后的代码如下：

class List {
  constructor() {
    this.head = null;
    this.tail = null;
    this.length = 0;
  }

  // 通用迭代器生成函数，接收映射函数转换每个节点的输出
  _createIterator(mapFn) {
    let current = this.head;
    let index = 0;
    return {
      next() {
        if (current) {
          const result = mapFn(current.value, index);
          current = current.next_node;
          index++;
          return { value: result, done: false };
        }
        return { done: true };
      },
      // 让迭代器自身也可迭代（符合原生迭代器行为）
      [Symbol.iterator]() {
        return this;
      }
    };
  }

  entries() {
    return this._createIterator((value, index) => [index, value]);
  }

  keys() {
    return this._createIterator((_, index) => index);
  }

  values() {
    return this._createIterator((value) => value);
  }

  // 复用values()的迭代器，和Array的默认迭代行为一致
  [Symbol.iterator]() {
    return this.values();
  }
}

说明：

• _createIterator是封装了核心遍历逻辑的私有方法，通过传入不同的映射函数，生成对应类型的迭代器。
• entries()、keys()、values()分别传入对应的映射函数，输出符合Array规范的迭代结果。
• [Symbol.iterator]直接返回this.values()，和原生Array的默认迭代行为保持一致（Array的默认迭代器就是values()的迭代器）。
• 迭代器对象实现了[Symbol.iterator]()方法，确保它自身也可以被for...of循环遍历，符合原生迭代器的行为规范。

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