Introduction to the Strategy Pattern

Welcome to our first lesson on Behavioral Patterns in Go! In this lesson, we will explore the Strategy Pattern. This is a design pattern that allows you to define a family of algorithms, encapsulate each one as an object, and make them interchangeable. The Strategy Pattern lets the algorithm vary independently from the clients that use it, promoting flexible and reusable code.

In this lesson, you'll learn how to:

• Define a family of algorithms using interfaces.
• Create different strategy implementations.
• Use a context class to switch between these strategies at runtime.

Here's a small taste of what you'll be able to do by the end of the lesson. First, we define various string formatting strategies:

package main

import "strings"

// Strategy defines the method set for algorithms.
type Strategy interface {
    Format(str string) string
}

// UpperCase strategy.
type UpperCase struct{}

func (UpperCase) Format(str string) string {
    return strings.ToUpper(str)
}

// LowerCase strategy.
type LowerCase struct{}

func (LowerCase) Format(str string) string {
    return strings.ToLower(str)
}

Next, we'll define a Context that can hold a reference to any Strategy implementation and use it to format strings dynamically:

package main

// Context holds a reference to a Strategy.
type Context struct {
    strategy Strategy
}

// SetStrategy sets the strategy in the context.
func (c *Context) SetStrategy(strategy Strategy) {
    c.strategy = strategy
}

// Execute uses the set strategy to format the given string.
func (c *Context) Execute(str string) string {
    return c.strategy.Format(str)
}

With these strategies and context, you can switch between them and format strings in different ways without changing the core logic of your application. Here is how you can use these strategies dynamically:

package main

import "fmt"

func main() {
    context := &Context{}

    input := "the quick brown fox jumps over the lazy dog"

    // Set and execute UpperCase strategy.
    context.SetStrategy(UpperCase{})
    result := context.Execute(input)
    fmt.Printf("UpperCase Strategy Result: %s\n", result) // Output: THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG

    // Set and execute LowerCase strategy.
    context.SetStrategy(LowerCase{})
    result = context.Execute(input)
    fmt.Printf("LowerCase Strategy Result: %s\n", result) // Output: the quick brown fox jumps over the lazy dog
}

Let's dive into the details of the Strategy Pattern and understand its components in more depth:

• Strategy: An interface that defines the method set for algorithms. It allows multiple implementations of the same algorithm. In our example, Strategy defines the Format method for string formatting algorithms.
• Concrete Strategies: Different implementations of the Strategy interface. In our example, UpperCase and LowerCase are concrete strategies that implement the Format method.
• Context: A class that holds a reference to a Strategy object and uses it to execute the algorithm. The context class allows you to switch between different strategies at runtime. In our example, Context holds a reference to a Strategy and uses it to format strings.
• Client: The client code that uses the Context class to execute algorithms. In our example, the main function creates a Context object, sets different strategies, and executes them.