¿Con qué patrones de diseño estás familiarizado…

Estoy familiarizado con varios patrones de diseño utilizados en Go. Algunos de los más comunes:

Patrones creacionales:

Singleton: Asegura que exista solo una instancia de una clase y proporciona un punto de acceso global a ella. En Go, a menudo se implementa usando sync.Once.

package main

import (
	"sync"
)

type singleton struct{}

var instance *singleton
var once sync.Once

func GetInstance() *singleton {
	once.Do(func() {
		instance = &singleton{}
	})
	return instance
}

Factory Method: Define una interfaz para crear un objeto, pero permite a las subclases decidir qué clase instanciar. En Go, a menudo se implementa usando funciones que devuelven interfaces.

package main

type Product interface {
	Operate()
}

type ConcreteProductA struct{}

func (p *ConcreteProductA) Operate() {
	// Implementación de la operación
}

type ConcreteProductB struct{}

func (p *ConcreteProductB) Operate() {
	// Implementación de la operación
}

func NewProduct(productType string) Product {
	switch productType {
	case "A":
		return &ConcreteProductA{}
	case "B":
		return &ConcreteProductB{}
	default:
		return nil // O error
	}
}

Abstract Factory: Proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.
Builder: Separa el proceso de construcción de un objeto complejo de su representación.

Patrones estructurales:

Adapter: Convierte la interfaz de una clase en otra que los clientes esperan. Permite que clases incompatibles trabajen juntas.
Decorator: Añade responsabilidades adicionales a un objeto dinámicamente. Los decoradores ofrecen una alternativa flexible a la herencia para extender funcionalidades.
Facade: Proporciona una interfaz unificada a un conjunto de interfaces en un subsistema. Define una interfaz de alto nivel que hace más fácil usar el subsistema.
Proxy: Proporciona un sustituto o representante para otro objeto para controlar el acceso a él.

Patrones de comportamiento:

Observer: Define una dependencia de uno a muchos entre objetos, de modo que cuando un objeto cambia su estado, todos sus dependientes son notificados y actualizados automáticamente.

Strategy: Define una familia de algoritmos, encapsula cada uno y los hace intercambiables. Permite que los algoritmos varíen independientemente de los clientes que los utilizan.

package main

type Strategy interface {
	Execute(data string)
}

type ConcreteStrategyA struct{}

func (s *ConcreteStrategyA) Execute(data string) {
	// Implementación de la estrategia A
}

type ConcreteStrategyB struct{}

func (s *ConcreteStrategyB) Execute(data string) {
	// Implementación de la estrategia B
}

type Context struct {
	strategy Strategy
}

func (c *Context) SetStrategy(strategy Strategy) {
	c.strategy = strategy
}

func (c *Context) ExecuteStrategy(data string) {
	c.strategy.Execute(data)
}

Template Method: Define el esqueleto de un algoritmo en una operación, dejando algunos pasos a las subclases. Permite a las subclases redefinir ciertos pasos de un algoritmo sin cambiar su estructura.

Además de los patrones mencionados, también conozco patrones como Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. En Go, también se utilizan frecuentemente idioms de diseño específicos del lenguaje, como el uso de interfaces para abstracción, goroutines y canales para concurrencia.

¿Con qué patrones de diseño estás familiarizado?