Milyen tervezési mintákkal vagy ismerős?

Ismerem a Go-ban használt különböző tervezési mintákat. Néhány a leggyakoribbak közül:

Kezdeményező minták:

• Singleton: Biztosítja, hogy csak egy példány létezik egy osztályból, és globális hozzáférési pontot biztosít hozzá. Go-ban gyakran a sync.Once segítségével valósítják meg.

  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: Egy interfészt határoz meg az objektum létrehozására, de az alosztályok döntenek arról, hogy melyik osztály példányosítódik. Go-ban gyakran függvényekkel valósítják meg, amelyek interfészt adnak vissza.

  package main
  
  type Product interface {
  	Operate()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Operate() {
  	// Művelet megvalósítása
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Operate() {
  	// Művelet megvalósítása
  }
  
  func NewProduct(productType string) Product {
  	switch productType {
  	case "A":
  		return &ConcreteProductA{}
  	case "B":
  		return &ConcreteProductB{}
  	default:
  		return nil // vagy hiba
  	}
  }
  

• Abstract Factory: Egy interfészt biztosít a kapcsolódó vagy függő objektumok családjainak létrehozásához anélkül, hogy megadná azok konkrét osztályait.
• Builder: Elkülöníti egy összetett objektum építési folyamatát annak reprezentációjától.

Szerkezeti minták:

• Adapter: Átalakítja egy osztály interfészét egy másikra, amit a kliensek igényelnek. Lehetővé teszi, hogy osztályok együttműködjenek, amelyek egyébként inkompatibilisek lennének.
• Decorator: Dinamikusan hozzáad új felelősségeket egy objektumhoz. A dekorátorok rugalmas alternatívát kínálnak az öröklés helyett a funkcionalitás bővítésére.
• Facade: Egységes interfészt biztosít egy alrendszerhez tartozó interfészek halmazához. Magas szintű interfészt határoz meg, amely megkönnyíti az alrendszer használatát.
• Proxy: Egy másik objektum helyettesítője vagy helykitöltője, amely az hozzáférés kezelését végzi.

Viselkedési minták:

• Observer: Egy-egy függőséget határoz meg az objektumok között "egy a sokhoz". Amikor egy objektum állapota megváltozik, minden függő objektum értesítést kap és automatikusan frissül.
• Strategy: Egy algoritmus családját határozza meg, mindegyiket kapszulázza, és egymással cserélhetővé teszi. Lehetővé teszi az algoritmusok független változtatását a használóktól.

  package main
  
  type Strategy interface {
  	Execute(data string)
  }
  
  type ConcreteStrategyA struct{}
  
  func (s *ConcreteStrategyA) Execute(data string) {
  	// Stratégia A megvalósítása
  }
  
  type ConcreteStrategyB struct{}
  
  func (s *ConcreteStrategyB) Execute(data string) {
  	// Stratégia B megvalósítása
  }
  
  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: Meghatározza egy algoritmus vázát egy műveletben, bizonyos lépéseket pedig alosztályokra bízza. Lehetővé teszi az alosztályoknak, hogy újra definiálják az algoritmus bizonyos lépéseit anélkül, hogy megváltoztatnák annak szerkezetét.

Ezen kívül ismerem a Command, Responsibility Chain, Iterator, Mediator, Memento, State, Visitor mintákat. Go-ban gyakran alkalmazott nyelvi idiomák közé tartozik az interfészek használata absztrakcióra, gorutinok és csatornák a párhuzamosításban.