Strategy模式通过接口封装不同算法，使其可互换；Go中用接口和组合实现，如排序策略示例所示，支持运行时切换，提升扩展性与解耦。
在 Golang 项目中，当需要根据场景动态切换算法或行为时，Strategy（策略）模式是一种非常实用的设计模式。它将不同的算法封装成独立的策略对象，使得它们可以互相替换而不影响客户端逻辑。这种模式特别适用于需要频繁变更处理逻辑、支持扩展新算法但又不想修改已有代码的场景。
什么是 Strategy 模式？
Strategy 模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。核心思想是：把变化的算法从主业务逻辑中剥离出来，通过统一接口调用不同实现。
在 Go 中，由于没有类继承机制，我们主要依靠接口和组合来实现 Strategy 模式。
应用场景举例：排序策略切换
假设你正在开发一个数据处理模块，需要支持多种排序方式（如快速排序、归并排序、冒泡排序），并且希望运行时能灵活切换算法。
立即学习“go语言免费学习笔记（深入）”；
我们可以定义一个统一的排序策略接口：
type SortStrategy interface {
Sort([]int)
}
然后为每种排序算法实现该接口：
type QuickSort struct{}
<p>func (q QuickSort) Sort(data []int) {
if len(data) <= 1 {
return
}
quickSortHelper(data, 0, len(data)-1)
}</p><p>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)
}
}</p><p>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[high] = arr[high], arr[i+1]
return i + 1
}</p><p>type MergeSort struct{}</p><div class="aritcle_card flexRow">
<div class="artcardd flexRow">
<a class="aritcle_card_img" href="/ai/2477" title="社研通"><img
src="https://img.php.cn/upload/ai_manual/001/246/273/176766956137899.png" alt="社研通" onerror="this.onerror='';this.src='/static/lhimages/moren/morentu.png'" ></a>
<div class="aritcle_card_info flexColumn">
<a href="/ai/2477" title="社研通">社研通</a>
<p>文科研究生的学术加速器</p>
</div>
<a href="/ai/2477" title="社研通" class="aritcle_card_btn flexRow flexcenter"><b></b><span>下载</span> </a>
</div>
</div><p>func (m MergeSort) Sort(data []int) {
if len(data) <= 1 {
return
}
sorted := mergeSort(data)
copy(data, sorted)
}</p><p>func mergeSort(arr []int) []int {
if len(arr) <= 1 {
return arr
}
mid := len(arr) / 2
left := mergeSort(arr[:mid])
right := mergeSort(arr[mid:])
return merge(left, right)
}</p><p>func merge(left, right []int) []int {
result := make([]int, 0, len(left)+len(right))
i, j := 0, 0
for i < len(left) && j < len(right) {
if left[i] <= right[j] {
result = append(result, left[i])
i++
} else {
result = append(result, right[j])
j++
}
}
result = append(result, left[i:]...)
result = append(result, right[j:]...)
return result
}</p>接下来，创建一个上下文结构体来管理当前使用的策略：
type Sorter struct {
strategy SortStrategy
}
<p>func (s *Sorter) SetStrategy(strategy SortStrategy) {
s.strategy = strategy
}</p><p>func (s *Sorter) Sort(data []int) {
if s.strategy != nil {
s.strategy.Sort(data)
}
}</p>使用示例：
data := []int{5, 2, 9, 1, 5, 6}
sorter := &Sorter{}
<p>// 使用快排
sorter.SetStrategy(QuickSort{})
sorter.Sort(data)
fmt.Println("QuickSort:", data) // 输出已排序数组</p><p>// 切换为归并排序
data = []int{5, 2, 9, 1, 5, 6}
sorter.SetStrategy(MergeSort{})
sorter.Sort(data)
fmt.Println("MergeSort:", data)</p>优势与适用性
Strategy 模式带来的好处包括：
- 解耦算法与使用逻辑：主流程不关心具体算法实现，只依赖接口
- 易于扩展新策略：新增算法只需实现接口，无需改动现有代码
- 运行时可切换：支持根据配置、输入类型或性能需求动态更换策略
- 便于测试：各个策略可独立单元测试
常见适用场景还包括：
小结
在 Golang 中实践 Strategy 模式并不复杂，关键是设计好策略接口，合理封装各种算法实现，并通过上下文结构体进行调度。这种方式提升了系统的灵活性和可维护性，符合开闭原则。对于需要算法切换的业务系统来说，是一个值得推荐的架构选择。
基本上就这些。只要接口清晰、职责分明，策略模式能让代码更干净，也更容易应对未来的变化。
