Go语言中处理带错误返回的函数迭代模式

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

for {
    element, err := producer.Produce() // 在循环内部调用一次
    if err != nil {
        // 根据错误类型处理循环终止或特定错误
        if err == io.EOF { // 例如，处理文件末尾
            fmt.Println("End of production.")
            break
        }
        // 处理其他非预期的错误
        fmt.Printf("Error producing element: %v\n", err)
        break // 或 return err
    }
    process(element) // 处理获取到的元素
}

package main

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

// Producer 定义了一个生成数据的接口
type Producer interface {
    Produce() (string, error)
}

// StringSliceProducer 是一个简单的Producer实现，从字符串切片中生成数据
type StringSliceProducer struct {
    data  []string
    index int
}

// NewStringSliceProducer 创建一个新的StringSliceProducer实例
func NewStringSliceProducer(elements []string) *StringSliceProducer {
    return &StringSliceProducer{
        data:  elements,
        index: 0,
    }
}

// Produce 方法返回切片中的下一个元素，或在没有更多元素时返回io.EOF
func (s *StringSliceProducer) Produce() (string, error) {
    if s.index >= len(s.data) {
        return "", io.EOF // 所有元素已生成，返回EOF
    }
    element := s.data[s.index]
    s.index++
    // 模拟偶尔出现的临时错误，例如在第三个元素时
    if s.index == 3 {
        return "", errors.New("simulated temporary error: cannot produce 'cherry'")
    }
    return element, nil
}

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

func main() {
    elements := []string{"apple", "banana", "cherry", "date", "elderberry"}
    producer := NewStringSliceProducer(elements)

    fmt.Println("--- Starting production with idiomatic for loop ---")
    for {
        element, err := producer.Produce()
        if err != nil {
            if err == io.EOF {
                fmt.Println("All elements processed successfully. Loop finished.")
                break // 正常终止循环
            }
            fmt.Printf("An error occurred: %v. Stopping production.\n", err)
            break // 遇到非EOF错误，异常终止循环
        }
        process(element)
    }
    fmt.Println("--- Production finished ---")

    // 此外，这种模式也适用于标准库中的类似场景，例如读取文件行：
    // import "bufio"
    // import "os"
    //
    // func readFileLines(filePath string) {
    //  file, err := os.Open(filePath)
    //  if err != nil {
    //      fmt.Printf("Error opening file: %v\n", err)
    //      return
    //  }
    //  defer file.Close() // 确保文件关闭
    //
    //  reader := bufio.NewReader(file)
    //  for {
    //      line, err := reader.ReadString('\n')
    //      if err != nil {
    //          if err == io.EOF {
    //              fmt.Println("End of file.")
    //              break
    //          }
    //          fmt.Printf("Error reading line: %v\n", err)
    //          break
    //      }
    //      fmt.Print("Read line: ", line) // line会包含换行符
    //  }
    // }
}