编辑“︁Go 生成器模式”︁

{{DISPLAYTITLE:Go生成器模式}}

'''Go生成器模式'''是[[函数式编程]]中的一种设计模式，它允许开发者按需生成值序列，而无需预先计算并存储所有值。这种模式在Go语言中通过[[闭包 (计算机科学)|闭包]]和[[通道 (编程)|通道]]实现，特别适合处理[[惰性求值|惰性计算]]和[[无限序列]]的场景。

== 概念介绍 ==
生成器模式的核心思想是将序列的生成过程封装为一个函数，每次调用时返回序列中的下一个值。与直接生成完整数组不同，生成器仅在需要时才计算值，从而节省内存并提高效率。

在Go中，生成器通常通过以下方式实现：
* 使用闭包维护内部状态
* 通过通道进行值传递
* 结合goroutine实现并发生成

== 基本实现 ==
=== 闭包实现 ===
最简单的生成器可以使用闭包实现：

<syntaxhighlight lang="go">
package main

import "fmt"

// 整数生成器
func counter(start int) func() int {
    n := start
    return func() int {
        n++
        return n - 1
    }
}

func main() {
    gen := counter(0)
    fmt.Println(gen()) // 输出: 0
    fmt.Println(gen()) // 输出: 1
    fmt.Println(gen()) // 输出: 2
}
</syntaxhighlight>

=== 通道实现 ===
更常见的Go风格实现是使用通道：

<syntaxhighlight lang="go">
package main

import "fmt"

// 生成整数序列
func countGenerator(max int) <-chan int {
    ch := make(chan int)
    go func() {
        for i := 0; i < max; i++ {
            ch <- i
        }
        close(ch)
    }()
    return ch
}

func main() {
    for num := range countGenerator(5) {
        fmt.Println(num) // 依次输出: 0 1 2 3 4
    }
}
</syntaxhighlight>

== 高级应用 ==
=== 无限生成器 ===
Go生成器可以轻松表示无限序列：

<syntaxhighlight lang="go">
package main

import "fmt"

// 斐波那契数列生成器
func fibonacci() <-chan int {
    ch := make(chan int)
    go func() {
        a, b := 0, 1
        for {
            ch <- a
            a, b = b, a+b
        }
    }()
    return ch
}

func main() {
    fib := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(<-fib) // 输出前10个斐波那契数
    }
}
</syntaxhighlight>

=== 生成器管道 ===
多个生成器可以组合成处理管道：

<syntaxhighlight lang="go">
package main

import (
    "fmt"
    "math"
)

// 数字平方生成器
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

// 数字过滤生成器
func filter(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            if math.Mod(float64(n), 2) == 0 {
                out <- n
            }
        }
        close(out)
    }()
    return out
}

func main() {
    nums := countGenerator(10)       // 生成0-9
    squares := square(nums)         // 计算平方
    evens := filter(squares)        // 过滤偶数
    
    for n := range evens {
        fmt.Println(n) // 输出: 0 4 16 36 64
    }
}
</syntaxhighlight>

<mermaid>
graph LR
    A[countGenerator] --> B[square]
    B --> C[filter]
    C --> D[输出]
</mermaid>

== 实际应用案例 ==
=== 日志处理系统 ===
生成器模式非常适合处理大型日志文件：

<syntaxhighlight lang="go">
package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

// 日志行生成器
func logGenerator(filename string) <-chan string {
    ch := make(chan string)
    go func() {
        file, err := os.Open(filename)
        if err != nil {
            close(ch)
            return
        }
        defer file.Close()
        
        scanner := bufio.NewScanner(file)
        for scanner.Scan() {
            ch <- scanner.Text()
        }
        close(ch)
    }()
    return ch
}

// 错误日志过滤器
func errorFilter(in <-chan string) <-chan string {
    out := make(chan string)
    go func() {
        for line := range in {
            if strings.Contains(line, "ERROR") {
                out <- line
            }
        }
        close(out)
    }()
    return out
}

func main() {
    logs := logGenerator("app.log")
    errors := errorFilter(logs)
    
    for err := range errors {
        fmt.Println(err) // 输出所有包含ERROR的日志行
    }
}
</syntaxhighlight>

=== 并发任务调度 ===
生成器可以用于任务分发系统：

<syntaxhighlight lang="go">
package main

import (
    "fmt"
    "math/rand"
    "time"
)

// 任务生成器
func taskGenerator(count int) <-chan int {
    ch := make(chan int)
    go func() {
        for i := 0; i < count; i++ {
            ch <- i
            time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
        }
        close(ch)
    }()
    return ch
}

// 工作池
func workerPool(tasks <-chan int, workerCount int) <-chan string {
    results := make(chan string)
    for i := 0; i < workerCount; i++ {
        go func(workerID int) {
            for task := range tasks {
                time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
                results <- fmt.Sprintf("Worker %d processed task %d", workerID, task)
            }
        }(i)
    }
    return results
}

func main() {
    tasks := taskGenerator(10)
    results := workerPool(tasks, 3)
    
    for i := 0; i < 10; i++ {
        fmt.Println(<-results)
    }
}
</syntaxhighlight>

== 数学基础 ==
生成器模式在数学上可以表示为：

<math>
G(n) = \begin{cases} 
\text{初始值} & \text{当 } n = 0 \\
f(G(n-1)) & \text{当 } n > 0 
\end{cases}
</math>

其中<math>G</math>是生成器函数，<math>f</math>是状态转换函数。

== 性能考虑 ==
使用生成器模式时需注意：
* 通道操作有开销，对小数据集可能不划算
* 无限生成器需要手动控制终止条件
* 错误处理需通过额外通道实现
* 资源清理要确保生成器能正常退出

== 总结 ==
Go生成器模式提供了：
* 惰性求值能力
* 内存高效的数据流处理
* 清晰的管道式代码结构
* 天然的并发支持

这种模式特别适合处理：
* 大数据集
* 无限或未知长度的序列
* 需要多阶段处理的数据流
* 并发任务分发场景

通过合理使用生成器模式，可以编写出更高效、更易维护的Go代码。

[[Category:编程语言]]
[[Category:Go]]
[[Category:Go 函数式编程]]