手把手教你实现TypeScript自定义迭代器，轻松提升代码优雅度

原创于 2025-10-22 16:09:49 发布 · 848 阅读

CC 4.0 BY-SA版权

第一章：TypeScript迭代器的核心概念与设计思想

TypeScript中的迭代器是一种设计模式的实现，它提供了一种统一的方式访问集合元素，而无需暴露其底层结构。该机制基于ES6规范中的Iterator协议，通过定义`next()`方法返回一个包含`value`和`done`属性的对象，实现对数据序列的逐步遍历。

迭代器的基本结构

一个符合迭代器协议的对象必须实现`next()`方法，该方法返回如下格式的结果：

interface IteratorResult<T> {
  value: T;
  done: boolean;
}

开发者可以通过手动实现迭代器来控制遍历逻辑。例如，创建一个递增数字的迭代器：

function createCounter(max: number): Iterator<number> {
  let current = 0;
  return {
    next(): IteratorResult<number> {
      if (current < max) {
        return { value: current++, done: false };
      } else {
        return { value: undefined, done: true };
      }
    }
  };
}

const counter = createCounter(3);
console.log(counter.next()); // { value: 0, done: false }
console.log(counter.next()); // { value: 1, done: false }
console.log(counter.next()); // { value: 2, done: false }
console.log(counter.next()); // { value: undefined, done: true }

可迭代协议与Symbol.iterator

为了让对象能被for...of循环或扩展运算符使用，需实现`[Symbol.iterator]()`方法。该方法应返回一个迭代器实例。

实现了`[Symbol.iterator]()`的对象被称为可迭代对象
常见的可迭代类型包括数组、字符串、Map、Set等
TypeScript会据此推断类型并支持编译时检查

特性	说明
迭代器协议	对象具有next()方法，返回{value, done}
可迭代协议	对象具有[Symbol.iterator]()方法
应用场景	for...of、yield*、Array.from()等

graph LR A[可迭代对象] -- 调用Symbol.iterator --> B[迭代器] B -- 调用next --> C{done: false?} C -- 是 --> D[返回value] C -- 否 --> E[遍历结束]

第二章：理解可迭代协议与迭代器协议

2.1 可迭代对象的定义与Symbol.iterator原理

可迭代对象是实现了 Symbol.iterator 方法的对象，该方法返回一个迭代器，用于按顺序访问集合中的元素。JavaScript 中的数组、字符串、Map、Set 等原生数据结构均是可迭代对象。

Symbol.iterator 的工作机制

当对象被 for...of 循环或展开运算符使用时，JavaScript 引擎会自动调用其 [Symbol.iterator]() 方法，获取一个具有 next() 方法的迭代器。

const iterable = {
  data: [1, 2, 3],
  [Symbol.iterator]() {
    let index = 0;
    return {
      next: () => {
        return index < this.data.length
          ? { value: this.data[index++], done: false }
          : { done: true };
      }
    };
  }
};

上述代码中，[Symbol.iterator] 返回一个迭代器对象，其 next() 方法逐步返回值和完成状态。每次调用返回的对象包含 value（当前值）和 done（是否遍历结束），符合迭代器协议。

2.2 迭代器协议的返回结构与行为规范

迭代器协议的核心在于其统一的返回结构和标准化的行为模式。一个符合规范的迭代器必须实现 next() 方法，该方法返回一个包含 value 和 done 两个属性的对象。

标准返回结构

每个 next() 调用应返回如下结构：


{
  value: '当前产出值',
  done: false // 或 true 表示迭代完成
}

其中，value 可为任意类型数据，done 为布尔值，表示迭代是否终止。

行为规范要求

一旦 done 为 true，后续调用应保持返回相同状态
在未结束前，每次调用应推进内部指针并返回新值
不可逆向遍历，不支持重置（除非显式提供 reset() 方法）

2.3 手动实现一个符合迭代器协议的对象

在 Python 中，只要实现了 __iter__() 和 __next__() 方法，对象即可成为迭代器。通过手动实现这两个方法，可以精确控制遍历行为。

基本结构与协议要求

__iter__()：返回迭代器对象本身，通常为 return self
__next__()：返回下一个值，遍历结束时抛出 StopIteration

代码实现示例

class CountUpTo:
    def __init__(self, max_val):
        self.max_val = max_val
        self.current = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.current > self.max_val:
            raise StopIteration
        result = self.current
        self.current += 1
        return result

该类从 1 开始递增输出整数，直到达到指定上限。每次调用 __next__() 时更新状态，确保下一次获取正确的值。当超出范围时主动抛出异常，符合迭代器协议规范。

2.4 for...of循环背后的执行机制解析

可迭代协议与迭代器模式

JavaScript 中的 for...of 循环依赖于“可迭代协议”和“迭代器协议”。一个对象若实现了 Symbol.iterator 方法，即被视为可迭代对象。


const iterable = {
  [Symbol.iterator]() {
    let step = 0;
    return {
      next() {
        return step < 3 ? { value: step++, done: false } : { done: true };
      }
    };
  }
};

上述代码定义了一个自定义可迭代对象。调用 Symbol.iterator 返回一个迭代器，其 next() 方法控制值的逐次生成。

循环执行流程

调用可迭代对象的 Symbol.iterator() 获取迭代器；
重复调用迭代器的 next() 方法；
每次返回的 value 被赋值给循环变量；
当 done: true 时，循环终止。

2.5 使用生成器函数快速创建迭代器

在JavaScript中，生成器函数提供了一种简洁高效的方式来创建自定义迭代器。通过在函数名前添加星号（*），即可将其定义为生成器。

基本语法与行为

function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}
const gen = numberGenerator();
console.log(gen.next().value); // 1

上述代码定义了一个生成器函数，每次调用 next() 时执行到下一个 yield 表达式并暂停，返回其右侧的值。

优势与应用场景

惰性求值：仅在需要时计算下一个值，节省内存；
无限序列：可表示无穷数据流，如斐波那契数列；
状态保持：函数内部状态在每次 yield 后自动保留。

第三章：构建自定义数据结构的迭代器

3.1 设计支持遍历的容器类数据结构

在构建可复用的数据结构时，支持遍历是提升容器通用性的关键。通过实现迭代器模式，可以让外部代码以统一方式访问元素，而不暴露内部结构。

接口设计原则

遵循开闭原则，定义清晰的遍历接口。例如，在 Go 中可通过 `Iterator` 接口规范 `HasNext()` 和 `Next()` 方法行为。

链表容器的遍历实现

以下是一个简化版单向链表及其迭代器的实现：


type ListNode struct {
    Value interface{}
    Next  *ListNode
}

type LinkedList struct {
    Head *ListNode
}

type Iterator struct {
    Current *ListNode
}

func (l *LinkedList) GetIterator() *Iterator {
    return &Iterator{Current: l.Head}
}

func (it *Iterator) HasNext() bool {
    return it.Current != nil
}

func (it *Iterator) Next() interface{} {
    value := it.Current.Value
    it.Current = it.Current.Next
    return value
}

该实现中，`GetIterator()` 返回一个独立的迭代器实例，确保多个遍历过程互不干扰。`HasNext()` 判断是否还有元素，`Next()` 返回当前值并推进指针，符合典型惰性遍历逻辑。

3.2 在类中实现Symbol.iterator方法

通过在类中定义 `Symbol.iterator` 方法，可以使自定义对象具备可迭代能力，从而支持 `for...of` 循环和扩展运算符等语法。

基础实现方式

在类的原型上实现 Symbol.iterator，返回一个符合迭代器协议的对象：

class Counter {
  constructor(start, end) {
    this.start = start;
    this.end = end;
  }

  *[Symbol.iterator]() {
    for (let i = this.start; i <= this.end; i++) {
      yield i;
    }
  }
}

上述代码中，使用生成器函数 * 简化迭代器实现。调用时，yield 每次返回一个值，直到遍历完成。

应用场景

封装数据集合并提供统一遍历接口
实现懒加载或无限序列
与数组解构、Promise.all() 等语言特性无缝集成

3.3 实践：为链表结构添加优雅遍历能力

在现代编程实践中，为数据结构提供直观的遍历接口是提升可读性的关键。链表作为基础线性结构，可通过迭代器模式实现优雅的遍历。

迭代器设计思路

将遍历逻辑从链表本身解耦，封装独立的迭代器对象，支持 hasNext() 和 next() 方法。


type ListIterator struct {
    current *Node
}

func (it *ListIterator) Next() interface{} {
    val := it.current.Value
    it.current = it.current.Next
    return val
}

func (it *ListIterator) HasNext() bool {
    return it.current != nil
}

该实现确保遍历状态独立维护，多个迭代器可同时安全操作同一链表。

使用方式对比

传统方式：暴露指针，易引发越界访问
迭代器方式：封装内部结构，提供统一访问协议

第四章：进阶技巧与实际应用场景

4.1 实现可复用的惰性求值迭代器

在现代编程中，惰性求值是提升性能与资源利用率的关键技术。通过延迟计算直到真正需要结果，可以有效避免不必要的运算开销。

核心设计思路

惰性迭代器应封装状态与计算逻辑，仅在调用 Next() 时推进一步。使用闭包或对象保存上下文，实现可复用的遍历结构。


type Iterator[T any] struct {
    hasNext bool
    nextVal T
    compute func() (T, bool)
}

func (it *Iterator[T]) Next() (T, bool) {
    if !it.hasNext {
        it.nextVal, it.hasNext = it.compute()
    }
    return it.nextVal, it.hasNext
}

该结构体封装了当前值 nextVal 和是否还有数据的标志 hasNext，compute 函数负责按需生成下一项，实现真正的惰性求值。

应用场景

处理大型数据流，如日志行逐条解析
无限序列生成，如斐波那契数列
多阶段数据转换链，避免中间集合创建

4.2 组合多个迭代器实现数据流水线

在处理大规模数据流时，组合多个迭代器构建高效的数据流水线是一种常见模式。通过将数据处理过程分解为多个可复用的阶段，每个阶段封装特定逻辑，能够提升代码的可读性与维护性。

迭代器链的基本结构

每个迭代器负责单一职责，例如过滤、映射或聚合。它们通过接口统一抽象，形成链式调用：


func Filter(iter <-chan int, pred func(int) bool) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for val := range iter {
            if pred(val) {
                out <- val
            }
        }
    }()
    return out
}

该函数接收输入通道和判断条件，输出满足条件的元素。并发协程确保非阻塞传输。

构建多阶段流水线

可将多个迭代器串联，如先过滤偶数，再平方输出：


ch1 := make(chan int)
go func() {
    for i := 1; i <= 10; i++ {
        ch1 <- i
    }
    close(ch1)
}()

filtered := Filter(ch1, func(n int) bool { return n%2 == 0 })
squared := Map(filtered, func(n int) int { return n * n })

Map 函数类似 Filter，对每个元素执行转换操作。最终形成的流水线具备良好扩展性，便于插入日志、限流等中间层。

4.3 处理异步数据流：AsyncIterator初探

在现代异步编程中，处理连续的异步数据流变得愈发常见。传统的迭代器无法应对异步场景，而 AsyncIterator 提供了原生支持，允许我们在 `for await...of` 循环中按需消费异步生成的数据。

AsyncIterator 基本结构

一个 AsyncIterator 返回的对象必须包含一个返回 Promise 的 `next()` 方法：


async function* createAsyncGenerator() {
  yield await fetchData('/api/user');
  yield await fetchData('/api/orders');
  yield await fetchData('/api/reports');
}

// 使用方式
for await (const data of createAsyncGenerator()) {
  console.log(data);
}

上述代码定义了一个异步生成器函数，每次 `yield` 都会暂停执行，直到 Promise 解析完成。`for await...of` 自动调用 `next()` 并等待其结果，实现流畅的异步迭代。

与同步迭代器对比

同步 Iterator 返回 { value, done }，不涉及 Promise；
AsyncIterator 返回 Promise<{ value, done }>；
只能在异步上下文中使用 `for await...of` 消费。

4.4 优化性能：避免内存泄漏与过度迭代

在高并发系统中，内存泄漏和过度迭代是导致性能下降的常见原因。合理管理资源与循环逻辑至关重要。

避免内存泄漏

长期持有不再使用的对象引用会导致内存无法回收。使用延迟初始化和及时释放资源可有效缓解此问题。

type ResourceManager struct {
    data map[string]*Resource
}

func (rm *ResourceManager) Cleanup(key string) {
    delete(rm.data, key) // 显式删除引用，协助GC
}

上述代码通过显式删除 map 中的键值对，确保不再使用的资源可被垃圾回收器正确处理。

减少过度迭代

避免在循环中执行重复计算
提前退出条件满足的遍历操作
使用索引缓存提升访问效率

结合资源管理与高效遍历策略，可显著提升服务响应速度与稳定性。

第五章：总结与未来展望

技术演进的持续驱动

现代软件架构正加速向云原生和边缘计算融合的方向发展。Kubernetes 已成为容器编排的事实标准，但服务网格（如 Istio）和无服务器框架（如 Knative）正在重塑微服务通信模式。企业级应用需在高可用性与成本控制之间取得平衡。

实战中的可观测性实践

一个金融支付平台通过集成 OpenTelemetry 实现全链路追踪，显著提升故障定位效率。以下是其核心配置片段：


// 配置 OpenTelemetry Tracer
tp, err := sdktrace.NewProvider(sdktrace.WithSampler(sdktrace.AlwaysSample()),
    sdktrace.WithBatcher(exporter),
    sdktrace.WithResource(resource.NewWithAttributes(
        semconv.ServiceNameKey.String("payment-service"),
    )),
)
if err != nil {
    log.Fatal(err)
}
global.SetTraceProvider(tp)