编辑“︁Go 选项模式”︁（章节）

= Go选项模式 =

'''Go选项模式'''（Options Pattern）是一种在Go语言中用于灵活配置结构体的设计模式。它通过函数式编程的思想，允许开发者以更优雅、可扩展的方式处理可选参数，避免了传统构造函数或配置方法中常见的参数膨胀问题。该模式特别适用于需要高度可配置性的场景，如初始化复杂对象或库的配置。

== 介绍 ==

在Go语言中，当构造一个对象需要多个可选参数时，常见的方式包括：
* 使用多个构造函数（NewX, NewXWithY, ...）
* 传递包含所有可能选项的配置结构体
* 使用链式调用（Builder模式）

选项模式提供了第四种方案：通过高阶函数动态修改目标对象的配置。其核心思想是：
# 定义一个选项函数类型（通常命名为`Option`）
# 创建一系列返回`Option`的工厂函数
# 在构造函数中接收可变数量的`Option`参数并依次应用

这种模式的优势在于：
* 高度可扩展：新增选项不会破坏现有代码
* 自文档化：选项函数的名称明确表达其作用
* 类型安全：编译时检查选项的有效性

== 基本实现 ==

以下是一个典型选项模式的实现示例：

<syntaxhighlight lang="go">
package main

import "fmt"

// 目标配置结构体
type ServerConfig struct {
    host    string
    port    int
    timeout int // 秒
    tls     bool
}

// 选项函数类型
type Option func(*ServerConfig)

// 选项工厂函数
func WithHost(host string) Option {
    return func(c *ServerConfig) {
        c.host = host
    }
}

func WithPort(port int) Option {
    return func(c *ServerConfig) {
        c.port = port
    }
}

func WithTimeout(timeout int) Option {
    return func(c *ServerConfig) {
        c.timeout = timeout
    }
}

func WithTLS(tls bool) Option {
    return func(c *ServerConfig) {
        c.tls = tls
    }
}

// 构造函数应用选项
func NewServerConfig(opts ...Option) *ServerConfig {
    // 设置默认值
    config := &ServerConfig{
        host:    "localhost",
        port:    8080,
        timeout: 30,
        tls:     false,
    }
    
    // 应用所有选项
    for _, opt := range opts {
        opt(config)
    }
    
    return config
}

func main() {
    // 使用默认配置
    defaultConfig := NewServerConfig()
    fmt.Printf("%+v\n", defaultConfig)
    
    // 自定义配置
    customConfig := NewServerConfig(
        WithHost("example.com"),
        WithPort(443),
        WithTimeout(60),
        WithTLS(true),
    )
    fmt.Printf("%+v\n", customConfig)
}
</syntaxhighlight>

'''输出：'''
<pre>
&{host:localhost port:8080 timeout:30 tls:false}
&{host:example.com port:443 timeout:60 tls:true}
</pre>

== 进阶应用 ==

=== 选项验证 ===
可以在选项函数中加入验证逻辑：

<syntaxhighlight lang="go">
func WithPort(port int) Option {
    return func(c *ServerConfig) {
        if port < 1 || port > 65535 {
            panic("invalid port number")
        }
        c.port = port
    }
}
</syntaxhighlight>

=== 选项依赖 ===
某些选项可能需要组合使用：

<syntaxhighlight lang="go">
func WithHTTPS(port int) Option {
    return func(c *ServerConfig) {
        c.port = port
        c.tls = true
    }
}
</syntaxhighlight>

=== 函数式组合 ===
选项可以组合成更高级的选项：

<syntaxhighlight lang="go">
func ProductionConfig() Option {
    return func(c *ServerConfig) {
        WithHost("api.example.com")(c)
        WithPort(443)(c)
        WithTLS(true)(c)
        WithTimeout(10)(c)
    }
}
</syntaxhighlight>

== 实际案例 ==

=== 数据库连接配置 ===
一个数据库客户端库可能这样使用选项模式：

<syntaxhighlight lang="go">
type DBConfig struct {
    host     string
    port     int
    user     string
    password string
    poolSize int
    sslMode  string
}

// ...选项函数定义...

func NewPostgresConnection(opts ...Option) (*sql.DB, error) {
    cfg := &DBConfig{
        host:     "localhost",
        port:     5432,
        poolSize: 10,
        sslMode:  "disable",
    }
    
    for _, opt := range opts {
        opt(cfg)
    }
    
    dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=postgres pool_size=%d sslmode=%s",
        cfg.host, cfg.port, cfg.user, cfg.password, cfg.poolSize, cfg.sslMode)
    
    return sql.Open("postgres", dsn)
}
</syntaxhighlight>

=== HTTP服务器配置 ===
HTTP服务器配置的典型应用：

<syntaxhighlight lang="go">
type HTTPServerConfig struct {
    addr         string
    readTimeout  time.Duration
    writeTimeout time.Duration
    idleTimeout  time.Duration
    tlsConfig    *tls.Config
}

// ...选项函数定义...

func NewServer(opts ...Option) *http.Server {
    cfg := &HTTPServerConfig{
        addr:         ":http",
        readTimeout:  5 * time.Second,
        writeTimeout: 10 * time.Second,
        idleTimeout:  120 * time.Second,
    }
    
    for _, opt := range opts {
        opt(cfg)
    }
    
    return &http.Server{
        Addr:         cfg.addr,
        ReadTimeout:  cfg.readTimeout,
        WriteTimeout: cfg.writeTimeout,
        IdleTimeout:  cfg.idleTimeout,
        TLSConfig:    cfg.tlsConfig,
    }
}
</syntaxhighlight>

== 模式分析 ==

<mermaid>
classDiagram
    class ServerConfig {
        -host: string
        -port: int
        -timeout: int
        -tls: bool
    }
    class Option {
        <<interface>>
        +apply(*ServerConfig)
    }
    class WithHost {
        +host: string
        +apply(*ServerConfig)
    }
    class WithPort {
        +port: int
        +apply(*ServerConfig)
    }
    
    Option <|-- WithHost
    Option <|-- WithPort
    Option ..> ServerConfig : 修改
</mermaid>

数学上，选项模式可以看作是一系列配置变换的组合。给定初始配置<math>C_0</math>和选项函数序列<math>O_1, O_2, ..., O_n</math>，最终配置为：

<math>
C_{final} = O_n(O_{n-1}(...O_1(C_0)...))
</math>

== 与其他模式对比 ==

{| class="wikitable"
|-
! 模式 !! 优点 !! 缺点
|-
| '''选项模式''' || 扩展性强，类型安全，自文档化 || 实现稍复杂，需要定义多个函数
|-
| '''Builder模式''' || 链式调用直观 || 需要维护中间状态
|-
| '''大构造函数''' || 实现简单 || 参数过多时难以维护
|-
| '''配置结构体''' || 直观明确 || 零值问题，修改配置需重建对象
|}

== 最佳实践 ==

1. '''命名约定'''：选项函数通常以`With`前缀开头（如`WithTimeout`）
2. '''不可变配置'''：应用选项后应返回新对象而非修改原对象
3. '''文档完善'''：为每个选项函数添加清晰的文档注释
4. '''默认值'''：提供合理的默认配置
5. '''错误处理'''：考虑在选项函数中返回错误而非panic

== 总结 ==

Go选项模式通过函数式编程的方式，为复杂对象的配置提供了优雅的解决方案。它特别适合：
* 需要大量可选参数的场景
* 库或框架的配置设计
* 需要高度可扩展性的代码

虽然实现上需要编写更多的代码，但在长期维护和可读性方面带来的好处往往超过初始成本。掌握这一模式可以帮助开发者编写出更灵活、更健壮的Go代码。

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