Go语言中迭代函数返回值的惯用模式与错误处理

for element, err := producer.Produce(); err == nil; element, err = producer.Produce() {
    process(element)
}

for {
    element, err := producer.Produce() // 调用生产函数获取值和错误
    if err != nil {
        // 检查错误，并根据错误类型决定是否终止循环
        // 例如，对于文件读取，io.EOF表示文件结束，是正常的终止条件
        // 其他错误可能需要进一步处理或报告
        if err == io.EOF {
            break // 正常结束循环
        }
        // 处理其他非EOF错误，例如打印日志或返回错误
        fmt.Printf("Error producing element: %v\n", err)
        break // 遇到严重错误时终止循环
    }
    // 成功获取到值，进行处理
    process(element)
}

package main

import (
    "errors"
    "fmt"
    "io"
    "strconv"
)

// Producer 模拟一个数据生产者
type Producer struct {
    count int
    limit int
}

// NewProducer 创建一个新的生产者实例
func NewProducer(limit int) *Producer {
    return &Producer{limit: limit}
}

// Produce 模拟生产一个字符串，并在达到限制后返回io.EOF
func (p *Producer) Produce() (string, error) {
    if p.count >= p.limit {
        return "", io.EOF // 达到限制，返回EOF表示结束
    }
    p.count++
    if p.count == 3 { // 模拟一个临时错误
        return "", errors.New("simulated temporary error at count 3")
    }
    return "Item " + strconv.Itoa(p.count), nil
}

// process 模拟对生产出的元素进行处理
func process(item string) {
    fmt.Printf("Processing: %s\n", item)
}

func main() {
    producer := NewProducer(5) // 设置生产5个元素

    fmt.Println("Starting iteration using idiomatic Go pattern:")
    for {
        element, err := producer.Produce()
        if err != nil {
            if err == io.EOF {
                fmt.Println("End of production (EOF).")
                break // 正常结束循环
            }
            fmt.Printf("An error occurred: %v. Stopping iteration.\n", err)
            break // 遇到其他错误时终止循环
        }
        process(element)
    }
    fmt.Println("Iteration finished.")
}

Starting iteration using idiomatic Go pattern:
Processing: Item 1
Processing: Item 2
An error occurred: simulated temporary error at count 3. Stopping iteration.
Iteration finished.