Go語言中的迭代器模式與安全訪問實踐

1. 迭代器模式在Go中的演進

1.1 傳統迭代器模式回顧

在傳統面向對象語言中，迭代器模式通常涉及三個核心組件：

可迭代集合接口(Iterable)
迭代器接口(Iterator)
具體實現類

// 傳統迭代器模式示例
type Iterator interface {Next() (interface{}, bool)
}type Iterable interface {Iterator() Iterator
}

1.2 Go風格的迭代器演進

Go語言采用了更符合其哲學的實現方式：

1.2.1 基于函數的迭代器

func IterateSlice(slice []int) func() (int, bool) {var i intreturn func() (val int, ok bool) {if i >= len(slice) {return 0, false}val, ok = slice[i], truei++return}
}

1.2.2 通道式迭代器

func ChanIterator(slice []int) <-chan int {ch := make(chan int)go func() {defer close(ch)for _, v := range slice {ch <- v}}()return ch
}

1.2.3 泛型迭代器(Go 1.18+)

type Iterator[T any] interface {Next() (T, bool)
}type SliceIter[T any] struct {slice []Tindex int
}func (s *SliceIter[T]) Next() (T, bool) {if s.index >= len(s.slice) {var zero Treturn zero, false}val := s.slice[s.index]s.index++return val, true
}

2. 安全訪問模式

2.1 邊界安全

2.1.1 切片訪問安全模式

// 不安全訪問
value := slice[index] // 可能panic// 安全訪問模式
func SafeGet[T any](slice []T, index int) (T, bool) {if index < 0 || index >= len(slice) {var zero Treturn zero, false}return slice[index], true
}

2.1.2 并發安全迭代器

type SafeIterator[T any] struct {mu    sync.RWMutexitems []Tindex int
}func (s *SafeIterator[T]) Next() (T, bool) {s.mu.RLock()defer s.mu.RUnlock()if s.index >= len(s.items) {var zero Treturn zero, false}val := s.items[s.index]s.index++return val, true
}

2.2 資源安全

2.2.1 自動關閉迭代器

type FileLineIterator struct {file *os.Filescan *bufio.Scanner
}func NewFileLineIterator(path string) (*FileLineIterator, error) {file, err := os.Open(path)if err != nil {return nil, err}return &FileLineIterator{file: file,scan: bufio.NewScanner(file),}, nil
}func (f *FileLineIterator) Next() (string, bool) {if f.scan.Scan() {return f.scan.Text(), true}return "", false
}func (f *FileLineIterator) Close() error {return f.file.Close()
}// 使用defer確保資源釋放
iter, err := NewFileLineIterator("data.txt")
if err != nil {log.Fatal(err)
}
defer iter.Close()

2.2.2 使用finalizer增強資源安全

func NewResourceIterator() *ResourceIterator {ri := &ResourceIterator{...}runtime.SetFinalizer(ri, func(ri *ResourceIterator) {ri.Close()})return ri
}

3. 現代Go迭代器模式

3.1 生成器模式(Generator Pattern)

func Generator[T any](items []T) <-chan T {ch := make(chan T)go func() {defer close(ch)for _, item := range items {select {case ch <- item:case <-time.After(5 * time.Second):return // 防止阻塞超時}}}()return ch
}

3.2 可取消迭代器

func CancelableIterator[T any](ctx context.Context, items []T) <-chan T {ch := make(chan T)go func() {defer close(ch)for _, item := range items {select {case <-ctx.Done():returncase ch <- item:}}}()return ch
}

3.3 異步批處理迭代器

func BatchIterator[T any](items []T, batchSize int) <-chan []T {ch := make(chan []T)go func() {defer close(ch)for i := 0; i < len(items); i += batchSize {end := i + batchSizeif end > len(items) {end = len(items)}ch <- items[i:end]}}()return ch
}

4. 錯誤處理與恢復

4.1 帶錯誤傳播的迭代器

type Result[T any] struct {Value TErr   error
}func SafeTransformIterator[T any, R any](iter Iterator[T],transform func(T) (R, error),
) Iterator[Result[R]] {return &transformIterator[T, R]{source:   iter,transform: transform,}
}type transformIterator[T any, R any] struct {source    Iterator[T]transform func(T) (R, error)
}func (t *transformIterator[T, R]) Next() (Result[R], bool) {val, ok := t.source.Next()if !ok {return Result[R]{}, false}result, err := t.transform(val)return Result[R]{Value: result, Err: err}, true
}

4.2 迭代器中的panic恢復

func RecoverIterator[T any](iter Iterator[T]) Iterator[T] {return &recoverIter[T]{iter: iter}
}type recoverIter[T any] struct {iter Iterator[T]err  error
}func (r *recoverIter[T]) Next() (T, bool) {defer func() {if p := recover(); p != nil {r.err = fmt.Errorf("iterator panic: %v", p)}}()if r.err != nil {var zero Treturn zero, false}return r.iter.Next()
}func (r *recoverIter[T]) Err() error {return r.err
}

5. 性能優化技術

5.1 迭代器池化

var iterPool = sync.Pool{New: func() interface{} {return &SliceIter[int]{}},
}func NewPooledSliceIter[T any](slice []T) Iterator[T] {iter := iterPool.Get().(*SliceIter[T])iter.slice = sliceiter.index = 0return iter
}func ReleaseSliceIter[T any](iter *SliceIter[T]) {iter.slice = niliter.index = 0iterPool.Put(iter)
}

5.2 零分配迭代器

type NoAllocIter[T any] struct {slice []Tindex int
}// 通過指針接收器避免值拷貝
func (n *NoAllocIter[T]) Next(out *T) bool {if n.index >= len(n.slice) {return false}*out = n.slice[n.index]n.index++return true
}

5.3 SIMD優化迭代器

// 使用匯編或SIMD指令優化批量處理
func (s *SIMDIterator) NextBatch(dst []int) int {// 使用AVX2等指令集優化批量拷貝
}

6. 函數式編程風格擴展

6.1 高階迭代器操作

func MapIter[T any, R any](iter Iterator[T], fn func(T) R) Iterator[R] {return &mapIter[T, R]{iter: iter, fn: fn}
}func FilterIter[T any](iter Iterator[T], predicate func(T) bool) Iterator[T] {return &filterIter[T]{iter: iter, predicate: predicate}
}func Reduce[T any, R any](iter Iterator[T], initial R, reducer func(R, T) R) R {result := initialfor val, ok := iter.Next(); ok; val, ok = iter.Next() {result = reducer(result, val)}return result
}

6.2 惰性求值迭代器

type LazyIter[T any] struct {next func() (T, bool)
}func (l *LazyIter[T]) Next() (T, bool) {return l.next()
}func FromGenerator[T any](gen func(yield func(T) bool)) Iterator[T] {next := make(chan T)stop := make(chan struct{})go func() {defer close(next)gen(func(v T) bool {select {case next <- v:return truecase <-stop:return false}})}()return &LazyIter[T]{next: func() (T, bool) {select {case v, ok := <-next:return v, okcase <-stop:var zero Treturn zero, false}},}
}

7. 實際應用案例

7.1 數據庫結果集迭代器

type RowsIterator struct {rows *sql.Rowscols []stringerr  error
}func (r *RowsIterator) Next(dest map[string]interface{}) bool {if r.err != nil {return false}if !r.rows.Next() {r.err = r.rows.Err()return false}values := make([]interface{}, len(r.cols))for i := range values {values[i] = new(interface{})}if err := r.rows.Scan(values...); err != nil {r.err = errreturn false}for i, col := range r.cols {dest[col] = *(values[i].(*interface{}))}return true
}func (r *RowsIterator) Err() error {return r.err
}func (r *RowsIterator) Close() error {return r.rows.Close()
}

7.2 分布式系統分頁迭代器

type PagedIterator[T any] struct {client     *APIClientpageSize   intcurrent    []TnextToken  stringerr        error
}func (p *PagedIterator[T]) Next() (T, bool) {for {if len(p.current) > 0 {val := p.current[0]p.current = p.current[1:]return val, true}if p.nextToken == "" && len(p.current) == 0 {var zero Treturn zero, false}result, err := p.client.ListItems(p.pageSize, p.nextToken)if err != nil {p.err = errvar zero Treturn zero, false}p.current = result.Itemsp.nextToken = result.NextToken}
}func (p *PagedIterator[T]) Err() error {return p.err
}

8. 測試與驗證

8.1 迭代器測試模式

func TestIterator(t *testing.T) {tests := []struct {name    stringinput   []intwant    []intwantErr bool}{{"empty", []int{}, []int{}, false},{"single", []int{1}, []int{1}, false},{"multiple", []int{1, 2, 3}, []int{1, 2, 3}, false},}for _, tt := range tests {t.Run(tt.name, func(t *testing.T) {iter := NewSliceIter(tt.input)var got []intfor val, ok := iter.Next(); ok; val, ok = iter.Next() {got = append(got, val)}if (iter.Err() != nil) != tt.wantErr {t.Errorf("Err() = %v, wantErr %v", iter.Err(), tt.wantErr)}if !reflect.DeepEqual(got, tt.want) {t.Errorf("got = %v, want %v", got, tt.want)}})}
}

8.2 競態檢測

func TestConcurrentIteration(t *testing.T) {iter := NewSafeIterator([]int{1, 2, 3, 4, 5})var wg sync.WaitGroupfor i := 0; i < 10; i++ {wg.Add(1)go func() {defer wg.Done()for val, ok := iter.Next(); ok; val, ok = iter.Next() {t.Logf("Value: %d", val)}}()}wg.Wait()
}

9. 未來展望

9.1 Go 2.0迭代器提案

目前Go社區正在討論更完善的迭代器支持，可能包括：

?內置迭代器協議?：

// 提案中的可能語法
type Iterable interface {iterate() iterator
}type iterator interface {next() (value any, ok bool)
}

?range over函數?：

// 允許自定義類型支持range循環
func (i *MyIter) Range() func() (int, bool) {// 返回迭代函數
}

?更完善的泛型迭代器支持?：

type Iterator[T any] interface {Next() Option[T]
}type Option[T any] interface {IsSome() boolUnwrap() T
}

9.2 與泛型結合的高級模式

// 可能的高級迭代器組合
func ComposeIterators[T any, R any, S any](iter1 Iterator[T],iter2 Iterator[R],combiner func(T, R) S,
) Iterator[S] {return &composedIter[T, R, S]{iter1:    iter1,iter2:    iter2,combiner: combiner,}
}

10. 總結與最佳實踐

10.1 迭代器選擇指南

使用場景	推薦模式	優點	缺點
簡單遍歷	直接range循環	簡單高效	功能有限
復雜轉換	泛型迭代器	類型安全，可組合	稍復雜
并發訪問	通道迭代器	天然并發安全	性能開銷
資源管理	帶Close的迭代器	明確資源釋放	需手動管理
大數據集	批處理迭代器	內存友好	實現復雜