Go Strategy Pattern 🎯

Welcome to our deep dive into the Go Strategy Pattern! This pattern is a behavioral design pattern that helps us define a family of algorithms, encapsulate each one, and make them interchangeable. Let's explore how we can use it to make our code more flexible and maintainable.

Understanding the Strategy Pattern 📝

In simple terms, the Strategy Pattern allows us to define a set of interchangeable algorithms or behaviors. It provides a way to encapsulate a family of algorithms and make them interchangeable within the context of an object.

Why is it useful?

Code reuse: We can reuse existing algorithms without duplicating code.
Polymorphism: We can switch between different algorithms at runtime.
Improved maintainability: Changes to a strategy can be made independently without affecting the client code.

Go Implementation 💡

In Go, we can implement the Strategy Pattern by defining an interface for our strategies and structs that implement these interfaces. Let's see an example of a Sorting Strategy.

// Strategy interface
type SortStrategy interface {
    Sort(data []int) []int
}

// Sorting algorithm implementation
type BubbleSort struct{}

func (s *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
}

Now we can create an instance of our BubbleSort strategy and use it to sort our data:

func main() {
    data := []int{64, 34, 25, 12, 22, 11, 90}

    // Create a BubbleSort strategy
    bubbleSort := &BubbleSort{}

    // Use the strategy to sort our data
    sortedData := bubbleSort.Sort(data)
    fmt.Println(sortedData) // Output: [11 12 22 25 34 64 90]
}

Encapsulating Multiple Strategies 💡

To encapsulate multiple strategies, we can create a Strategy struct that holds a function pointer to a strategy's Sort method and a method to change the strategy at runtime.

type Strategy struct {
    sortStrategy SortStrategy
}

func (s *Strategy) Sort(data []int) []int {
    return s.sortStrategy.Sort(data)
}

func (s *Strategy) SetSortStrategy(sortStrategy SortStrategy) {
    s.sortStrategy = sortStrategy
}

Now we can create multiple strategies and switch between them at runtime:

func main() {
    data := []int{64, 34, 25, 12, 22, 11, 90}

    // Create strategies
    bubbleSort := &BubbleSort{}
    quickSort := &QuickSort{}

    // Initialize Strategy with BubbleSort
    strategy := &Strategy{sortStrategy: bubbleSort}

    // Use the strategy to sort our data
    sortedData := strategy.Sort(data)
    fmt.Println(sortedData) // Output: [11 12 22 25 34 64 90]

    // Switch to QuickSort strategy
    strategy.SetSortStrategy(quickSort)

    // Use the strategy to sort our data again
    sortedData = strategy.Sort(data)
    fmt.Println(sortedData) // Output: [11 12 22 25 34 64 90] (but QuickSort should be faster)
}

Quiz 🎯

Happy coding! 🚀