Golang Strategy策略模式算法切换实践-Golang-PHP中文网

Golang Strategy策略模式算法切换实践

P粉602998670

发布： 2025-10-07 14:16:02

原创

130人浏览过

Strategy模式通过接口封装不同算法，使其可互换；Go中用接口和组合实现，如排序策略示例所示，支持运行时切换，提升扩展性与解耦。

golang strategy策略模式算法切换实践

在 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">
                        <a class="aritcle_card_img" href="/ai/1974">
                            <img src="https://img.php.cn/upload/ai_manual/000/000/000/175680017717850.png" alt="降重鸟">
                        </a>
                        <div class="aritcle_card_info">
                            <a href="/ai/1974">降重鸟</a>
                            <p>要想效果好，就用降重鸟。AI改写智能降低AIGC率和重复率。</p>
                            <div class="">
                                <img src="/static/images/card_xiazai.png" alt="降重鸟">
                                <span>308</span>
                            </div>
                        </div>
                        <a href="/ai/1974" class="aritcle_card_btn">
                            <span>查看详情</span>
                            <img src="/static/images/cardxiayige-3.png" alt="降重鸟">
                        </a>
                    </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>

登录后复制