Go中策略模式的自然表达是直接用func类型作为一等公民承载可替换行为，无需接口或多态；定义统一函数类型如PaymentStrategy，各实现严格匹配签名，支持闭包捕获变量、运行时传值切换、装饰器组合及nil安全检查。

什么是策略模式在 Go 里的自然表达

Go 没有类和继承，所以“策略模式”不是靠接口+多态实现的，而是直接用 func 类型作为一等公民来承载行为。策略本质就是“可替换的函数”，只要签名一致，就能互相替换——不需要包装结构体、也不必定义空接口。

定义统一策略类型并传入不同实现

关键在于先声明一个函数类型，再让不同逻辑满足该签名。常见错误是把策略写成闭包后忘了类型匹配，或误用指针导致调用 panic。

• type PaymentStrategy func(amount float64) error 是最简策略类型定义
• 每个具体策略必须严格符合该签名，不能多参数、不能少返回值
• 策略函数内部可捕获外部变量（如 API key），但要注意生命周期，避免意外引用已释放的内存

type PaymentStrategy func(amount float64) error
func CreditCardPayment(cardNum string) PaymentStrategy {
return func(amount float64) error {
fmt.Printf("Charging $%.2f to card %s\n", amount, cardNum)
return nil
}
}
func PayPalPayment(token string) PaymentStrategy {
return func(amount float64) error {
fmt.Printf("PayPal payment: $%.2f with token %s\n", amount, token)
return nil
}
}

运行时切换策略：传函数值，不是传函数名

调用方接收的是 PaymentStrategy 类型变量，不是字符串标识符。容易踩的坑是传了未初始化的 nil 函数，导致运行时报 panic: call of nil function。

• 必须检查函数变量是否为 nil，尤其从 map 或配置加载策略时
• 不建议用字符串映射到策略（如 map[string]PaymentStrategy），除非你明确需要动态注册
• 测试时可直接传匿名函数，无需构造完整实现

func ProcessOrder(strategy PaymentStrategy, total float64) error {
    if strategy == nil {
        return errors.New("no payment strategy provided")
    }
    return strategy(total)
}
// 使用示例
err := ProcessOrder(CreditCardPayment("4123-XXXX"), 99.99)
if err != nil {
log.Fatal(err)
}

策略组合与装饰：用函数链增强行为

Go 的函数类型天然支持装饰器模式。比如加日志、重试、限流，都可以用高阶函数包装原始策略，而不用修改原有逻辑。

立即学习“go语言免费学习笔记（深入）”；

• 装饰函数返回新的 PaymentStrategy，保持类型兼容
• 注意装饰顺序：WithRetry(WithLogging(strat)) 和反过来效果不同
• 避免在装饰器里做阻塞操作（如同步 HTTP 调用），否则影响主流程响应性

func WithLogging(next PaymentStrategy) PaymentStrategy {
    return func(amount float64) error {
        log.Printf("Starting payment for $%.2f", amount)
        err := next(amount)
        log.Printf("Payment completed: %v", err)
        return err
    }
}
func WithRetry(maxRetries int, next PaymentStrategy) PaymentStrategy {
return func(amount float64) error {
var lastErr error
for i := 0; i <= maxRetries; i++ {
lastErr = next(amount)
if lastErr == nil {
return nil
}
time.Sleep(time.Second * time.Duration(i+1))
}
return lastErr
}
}

策略的核心不在“模式”二字，而在你是否真的把函数当数据来传递和组合。最容易被忽略的是 nil 检查和闭包变量生命周期——它们不会报编译错误，但会在某个并发请求里突然崩掉。