Go语言中实现可选参数与函数重载的替代方案

package main

import "fmt"

// UserOptions 定义了创建用户时可用的所有配置选项
type UserOptions struct {
    Name    string
    Age     int
    Email   string
    IsAdmin bool
}

// CreateUser 根据提供的选项创建用户
// 未设置的选项将使用其零值，或者可以在函数内部设置默认值
func CreateUser(opts UserOptions) {
    // 设置默认值
    if opts.Name == "" {
        opts.Name = "Guest"
    }
    if opts.Age == 0 { // 假设0是默认年龄，或者表示未指定
        opts.Age = 18
    }
    if opts.Email == "" {
        opts.Email = "no-email@example.com"
    }

    fmt.Printf("创建用户：姓名=%s, 年龄=%d, 邮箱=%s, 是否管理员=%t\n",
        opts.Name, opts.Age, opts.Email, opts.IsAdmin)
}

func main() {
    // 示例1: 只提供部分参数
    CreateUser(UserOptions{Name: "Alice", Age: 30})

    // 示例2: 提供其他参数
    CreateUser(UserOptions{Email: "bob@example.com", IsAdmin: true})

    // 示例3: 不提供任何参数，全部使用默认值
    CreateUser(UserOptions{})

    // 示例4: 提供所有参数
    CreateUser(UserOptions{Name: "Charlie", Age: 25, Email: "charlie@example.com", IsAdmin: false})
}

package main

import "fmt"

// Sum 计算任意数量整数的和
func Sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

// LogMessages 打印任意数量的字符串消息
func LogMessages(level string, messages ...string) {
    fmt.Printf("[%s] ", level)
    for _, msg := range messages {
        fmt.Print(msg, " ")
    }
    fmt.Println()
}

func main() {
    fmt.Println("Sum(1, 2, 3):", Sum(1, 2, 3))
    fmt.Println("Sum(10):", Sum(10))
    fmt.Println("Sum():", Sum()) // 可以接受零个参数

    LogMessages("INFO", "User logged in", "IP: 192.168.1.1")
    LogMessages("WARN", "Disk space low")
    LogMessages("DEBUG") // 只有固定参数
}

package main

import "fmt"
import "time"

// Client 定义一个需要配置的客户端结构
type Client struct {
    timeout time.Duration
    retries int
    debug   bool
}

// ClientOption 定义选项函数的类型
type ClientOption func(*Client)

// WithTimeout 创建一个设置超时时间的选项函数
func WithTimeout(t time.Duration) ClientOption {
    return func(c *Client) {
        c.timeout = t
    }
}

// WithRetries 创建一个设置重试次数的选项函数
func WithRetries(r int) ClientOption {
    return func(c *Client) {
        c.retries = r
    }
}

// WithDebug 创建一个设置调试模式的选项函数
func WithDebug(d bool) ClientOption {
    return func(c *Client) {
        c.debug = d
    }
}

// NewClient 是一个构造函数，接受多个ClientOption来配置客户端
func NewClient(opts ...ClientOption) *Client {
    // 设置默认值
    client := &Client{
        timeout: 5 * time.Second,
        retries: 3,
        debug:   false,
    }

    // 应用所有选项
    for _, opt := range opts {
        opt(client)
    }

    return client
}

func main() {
    // 创建一个使用默认配置的客户端
    client1 := NewClient()
    fmt.Printf("客户端 1: 超时=%s, 重试=%d, 调试=%t\n", client1.timeout, client1.retries, client1.debug)

    // 创建一个自定义超时和重试次数的客户端
    client2 := NewClient(
        WithTimeout(10 * time.Second),
        WithRetries(5),
    )
    fmt.Printf("客户端 2: 超时=%s, 重试=%d, 调试=%t\n", client2.timeout, client2.retries, client2.debug)

    // 创建一个启用调试模式的客户端
    client3 := NewClient(WithDebug(true))
    fmt.Printf("客户端 3: 超时=%s, 重试=%d, 调试=%t\n", client3.timeout, client3.retries, client3.debug)
}