策略模式通过接口定义算法族，具体实现如BubbleSort和QuickSort分别封装不同排序逻辑，Sorter上下文动态设置strategy并执行Sort方法，运行时可切换算法而不影响客户端调用。
在Go语言中，策略模式是一种行为设计模式，它允许你定义一系列算法，并将每种算法分别放入独立的结构体中，使算法的变化独立于使用它的客户端。通过接口抽象，可以在运行时动态切换不同的实现，非常适合需要根据不同场景选择不同处理逻辑的场景。
定义策略接口
策略模式的核心是定义一个统一的接口，所有具体算法都实现这个接口。这样调用方只需依赖接口，而无需关心具体实现。
例如，假设我们要实现不同的排序算法，可以先定义一个排序策略接口：
type SortStrategy interface {
Sort([]int) []int
}这个接口声明了一个 Sort 方法，接收一个整型切片并返回排序后的结果。任何符合该接口的类型都可以作为“排序策略”被使用。
实现具体策略
接下来，我们实现几种具体的排序算法，比如冒泡排序和快速排序：
type BubbleSort struct{}
func (b *BubbleSort) Sort(data []int) []int {
n := len(data)
sorted := make([]int, n)
copy(sorted, data)
for i := 0; i < n-1; i++ {
for j := 0; j < n-i-1; j++ {
if sorted[j] > sorted[j+1] {
sorted[j], sorted[j+1] = sorted[j+1], sorted[j]
}
}
}
return sorted
}
type QuickSort struct{}
func (q *QuickSort) Sort(data []int) []int {
if len(data) <= 1 {
return data
}
sorted := make([]int, len(data))
copy(sorted, data)
quickSortHelper(sorted, 0, len(sorted)-1)
return sorted
}
func quickSortHelper(arr []int, low, high int) {
if low < high {
pi := partition(arr, low, high)
quickSortHelper(arr, low, pi-1)
quickSortHelper(arr, pi+1, high)
}
}
func partition(arr []int, low, high int) int {
pivot := arr[high]
i := low - 1
for j := low; j < high; j++ {
if arr[j] <= pivot {
i++
arr[i], arr[j] = arr[j], arr[i]
}
}
arr[i+1], arr[h
igh] = arr[high], arr[i+1]
return i + 1
}
igh] = arr[high], arr[i+1]
return i + 1
}现在我们有两个实现了 SortStrategy 接口的具体类型：BubbleSort 和 QuickSort。它们封装了不同的算法逻辑。
上下文使用策略
创建一个上下文结构体来持有当前策略，并提供方法切换或执行策略：
type Sorter struct {
strategy SortStrategy
}
func (s *Sorter) SetStrategy(strategy SortStrategy) {
s.strategy = strategy
}
func (s *Sorter) ExecuteSort(data []int) []int {
if s.strategy == nil {
panic("no strategy set")
}
return s.strategy.Sort(data)
}
Sorter 结构体包含一个策略字段，可以通过 SetStrategy 动态更换算法。调用 ExecuteSort 时会使用当前设置的策略进行排序。
运行时动态切换示例
下面是使用示例，展示如何在运行时切换不同算法：
func main() {
data := []int{64, 34, 25, 12, 22, 11, 90}
sorter := &Sorter{}
// 使用冒泡排序
sorter.SetStrategy(&BubbleSort{})
result1 := sorter.ExecuteSort(data)
fmt.Println("Bubble Sort:", result1)
// 切换为快速排序
sorter.SetStrategy(&QuickSort{})
result2 := sorter.ExecuteSort(data)
fmt.Println("Quick Sort:", result2)}
输出结果：
Bubble Sort: [11 12 22 25 34 64 90]
Quick Sort: [11 12 22 25 34 64 90]
可以看到，同一个 Sorter 实例在不改变调用方式的情况下，执行了不同的排序逻辑。
基本上就这些。Golang通过接口和组合轻松支持策略模式，让算法替换变得灵活且可扩展。实际项目中可用于日志策略、支付方式、缓存策略等多变场景。
