Con quali pattern di progettazione sei familiare…

Conosco vari pattern di progettazione utilizzati in Go. Alcuni dei più comuni:

Pattern creazionali:

Singleton: Garantisce che esista solo un'istanza di una classe e fornisce un punto di accesso globale ad essa. In Go, spesso viene implementato 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: Definisce un'interfaccia per creare un oggetto, ma permette alle sottoclassi di decidere quale classe istanziare. In Go, spesso viene implementato usando funzioni che restituiscono interfacce.

package main

type Product interface {
	Operate()
}

type ConcreteProductA struct{}

func (p *ConcreteProductA) Operate() {
	// Implementazione dell'operazione
}

type ConcreteProductB struct{}

func (p *ConcreteProductB) Operate() {
	// Implementazione dell'operazione
}

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

Abstract Factory: Fornisce un'interfaccia per creare famiglie di oggetti correlati o dipendenti senza specificarne le classi concrete.
Builder: Separa il processo di costruzione di un oggetto complesso dalla sua rappresentazione.

Pattern strutturali:

Adapter: Converte l'interfaccia di una classe in un'altra richiesta dai clienti. Permette a classi incompatibili di lavorare insieme.
Decorator: Aggiunge responsabilità dinamicamente a un oggetto. I decoratori offrono un'alternativa flessibile all'ereditarietà per estendere le funzionalità.
Facade: Fornisce un'interfaccia unificata a un insieme di interfacce in un sottosistema. Definisce un'interfaccia di alto livello che semplifica l'uso del sottosistema.
Proxy: Fornisce un sostituto o rappresentante per un altro oggetto per controllare l'accesso.

Pattern comportamentali:

Observer: Definisce una dipendenza uno-a-molti tra oggetti. Quando uno oggetto cambia stato, tutti i suoi dipendenti vengono notificati e aggiornati automaticamente.

Strategy: Definisce una famiglia di algoritmi, incapsula ciascuno e li rende intercambiabili. Permette di variare gli algoritmi indipendentemente dai clienti che li utilizzano.

package main

type Strategy interface {
	Execute(data string)
}

type ConcreteStrategyA struct{}

func (s *ConcreteStrategyA) Execute(data string) {
	// Implementazione della strategia A
}

type ConcreteStrategyB struct{}

func (s *ConcreteStrategyB) Execute(data string) {
	// Implementazione della strategia 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: Definisce lo scheletro di un algoritmo in un'operazione, lasciando alcuni passi alle sottoclassi. Permette alle sottoclassi di ridefinire alcuni passi dell'algoritmo senza modificarne la struttura.

Oltre ai pattern sopra menzionati, conosco anche pattern come Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. In Go, vengono spesso utilizzati anche idiomi di progettazione specifici del linguaggio, come l'uso di interfacce per l'astrazione, goroutine e canali per la concorrenza.

Con quali pattern di progettazione sei familiare?