Milliste disainimustritega olete tuttav?

Ma tean erinevaid disainimustreid, mida kasutatakse Go-s. Mõned kõige sagedamini kasutatavad:

Loomise mustrid:

• Singleton: Tagab, et eksisteerib ainult üks klassi eksemplar ja pakub sellele globaalse juurdepääsu. Go-s realiseeritakse sageli sync.Once abil.

  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: Määratleb liidese objekti loomiseks, kuid võimaldab alamtasanditel otsustada, millist klassi instantsida. Go-s realiseeritakse sageli funktsioonide abil, mis tagastavad liidese.

  package main
  
  type Product interface {
  	Operate()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Operate() {
  	// Operatsiooni realiseerimine
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Operate() {
  	// Operatsiooni realiseerimine
  }
  
  func NewProduct(productType string) Product {
  	switch productType {
  	case "A":
  		return &ConcreteProductA{}
  	case "B":
  		return &ConcreteProductB{}
  	default:
  		return nil // Või viga
  	}
  }
  

• Abstract Factory: Pakub liidest seotud või sõltuvate objektide seeria loomiseks ilma nende konkreetsete klasside määratlemata.
• Builder: Eraldab keeruka objekti konstrueerimisprotsessi selle esitamisest.

Struktuursed mustrid:

• Adapter: Muudab ühe klassi liidese teiseks, mida kliendid vajavad. Annab klassidele võimaluse koos töötada, mis muidu oleksid sobimatud.
• Decorator: Dynaamiliselt lisab objektile uusi vastutusi. Dekoraatorid pakuvad paindlikumat alternatiivi pärimisele funktsionaalsuse laiendamiseks.
• Facade: Pakub ühtset liidest alam-süsteemide liidestele. Määratleb kõrgema taseme liidese, mis lihtsustab alam-süsteemi kasutamist.
• Proxy: Pakub asendajat või täitjat teisele objektile juurdepääsu haldamiseks.

Käitumismustrid:

• Observer: Määratleb "üks mitme" sõltuvuse objektide vahel. Kui ühe objekti olek muutub, teavitab see kõik sõltuvad objektid ja uuendatakse automaatselt.
• Strategy: Määratleb algoritmide perekonna, inkapsuleerib igaühe ja muudab need vahetatavateks. Annab algoritmidele võimaluse muutuda sõltumatult klientidest, kes neid kasutavad.

  package main
  
  type Strategy interface {
  	Execute(data string)
  }
  
  type ConcreteStrategyA struct{}
  
  func (s *ConcreteStrategyA) Execute(data string) {
  	// Strateegia A realiseerimine
  }
  
  type ConcreteStrategyB struct{}
  
  func (s *ConcreteStrategyB) Execute(data string) {
  	// Strateegia B realiseerimine
  }
  
  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: Määratleb algoritmi raami operatsioonis, viies mõned sammud alamtasandile. Annab alamtasanditele võimaluse muuta algoritmi teatud samme, mitte selle struktuuri.

Lisaks loetletud, tean ka selliseid nagu Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. Go-s kasutatakse sageli ka keele spetsiifilisi disainidiome, näiteks liideste kasutamist abstraktsiooniks, gorutinasid ja kanaleid paralleelimiseks.