首先定义统一策略接口，再通过上下文结构体持有并动态切换具体策略；支持基于条件或配置自动选择策略，也可用函数式编程简化实现，提升灵活性与可维护性。
在Golang中实现策略模式并支持动态切换策略，关键在于将算法或行为封装为独立的类型，并通过接口进行调用。这样可以在运行时根据条件灵活替换具体策略，提升代码的可扩展性和可维护性。
定义统一的策略接口
策略模式的核心是定义一个公共接口，所有具体策略都实现该接口。这使得调用方无需关心具体实现，只需面向接口编程。
示例：假设我们要实现不同的排序策略：
```go type SortStrategy interface { Sort([]int) []int }type BubbleSort struct{}
立即学习“go语言免费学习笔记（深入）”；
func (b BubbleSort) Sort(data []int) []int { // 简化实现 n := len(data) for i := 0; i < n-1; i++ { for j := 0; j < n-i-1; j++ { if data[j] > data[j+1] { data[j], data[j+1] = data[j+1], data[j] } } } return data }
type QuickSort struct{}
func (q QuickSort) Sort(data []int) []int { if len(data) <= 1 { return data } pivot := data[0] var less, greater []int for _, v := range data[1:] { if v <= pivot { less = append(less, v) } else { greater = append(greater, v) } } return append(append(q.Sort(less), pivot), q.Sort(greater)...) }
<H3><strong>使用上下文管理当前策略</strong></H3>
<p>通过一个上下文结构体持有当前策略实例，提供设置和执行方法，实现运行时动态切换。</p>
<p>这是实现“动态切换”的关键步骤。</p>
```go
type Sorter struct {
strategy SortStrategy
}
func (s *Sorter) SetStrategy(strategy SortStrategy) {
s.strategy = strategy
}
func (s *Sorter) Execute(data []int) []int {
if s.strategy == nil {
panic("未设置策略")
}
return s.strategy.Sort(data)
}使用方式：
```go data := []int{5, 2, 9, 1, 5}sorter := &Sorter{} sorter.SetStrategy(BubbleSort{}) sorted1 := sorter.Execute(data)
sorter.SetStrategy(QuickSort{}) sorted2 := sorter.Execute(data)
<H3><strong>基于配置或条件自动切换策略</strong></H3>
<p>在实际应用中，常根据输入数据特征或外部配置决定使用哪种策略。</p>
<p>例如：小数据用冒泡，大数据用快排</p>
```go
func ChooseStrategy(n int) SortStrategy {
if n < 10 {
return BubbleSort{}
}
return QuickSort{}
}
// 使用
data := []int{3, 1, 4}
sorter := &Sorter{}
sorter.SetStrategy(ChooseStrategy(len(data)))
result := sorter.Execute(data)也可以从环境变量、配置文件读取策略名称，配合映射表动态创建：
```go var strategies = map[string]SortStrategy{ "bubble": BubbleSort{}, "quick": QuickSort{}, }// 根据配置选择 name := os.Getenv("SORT_STRATEGY") // 如 "quick" if strategy, ok := strategies[name]; ok { sorter.SetStrategy(strategy) }
<H3><strong>函数式策略：使用函数替代接口</strong></H3>
<p>Golang支持函数作为一等公民，可以用函数类型简化策略模式。</p>
```go
type StrategyFunc func([]int) []int
func (f StrategyFunc) Sort(data []int) []int {
return f(data)
}
// 定义具体函数
func bubbleSortFunc(data []int) []int { /* 实现 */ }
func quickSortFunc(data []int) []int { /* 实现 */ }
// 使用
sorter := &Sorter{}
sorter.SetStrategy(StrategyFunc(bubbleSortFunc))这种方式更轻量，适合逻辑简单的场景。
基本上就这些。Golang虽无类与继承，但通过接口、结构体和函数，能简洁高效地实现策略模式并支持动态切换。关键是把变化的算法封装好，运行时注入即可。不复杂但容易忽略细节，比如空指针判断和并发安全（若多协程修改策略需加锁）。
