С кои шаблони за дизайн сте запознати?

Аз съм запознат с различни шаблони за дизайн, използвани в Go. Някои от най-често срещаните са:

Създаващи шаблони:

• Singleton: Осигурява съществуването само на един екземпляр на класа и предоставя глобална точка за достъп до него. В Go често се реализира с помощта на 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
  }
  

• Фабричен метод: Определя интерфейс за създаване на обект, но подкласовете решават кой клас да инстанцират. В Go често се реализира с функции, които връщат интерфейс.

  package main
  
  type Product interface {
  	Operate()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Operate() {
  	// Реализация на операцията
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Operate() {
  	// Реализация на операцията
  }
  
  func NewProduct(productType string) Product {
  	switch productType {
  	case "A":
  		return &ConcreteProductA{}
  	case "B":
  		return &ConcreteProductB{}
  	default:
  		return nil // или грешка
  	}
  }
  

• Абстрактна фабрика: Предоставя интерфейс за създаване на семейства от свързани или зависими обекти без да се уточняват техните конкретни класове.
• Builder: Разделя процеса на конструиране на сложен обект от неговото представяне.

Структурни шаблони:

• Adapter: Преобразува интерфейса на един клас в друг, необходим за клиентите. Позволява на класове да работят заедно, които иначе биха били несъвместими.
• Decorator: Динамично добавя нови отговорности към обект. Декораторите предоставят гъвкава алтернатива на наследяването за разширяване на функционалността.
• Facade: Предоставя унифициран интерфейс към набор от интерфейси в подсистема. Определя високоуровнев интерфейс, който улеснява използването на подсистемата.
• Proxy: Предоставя заместител или запълнител за друг обект за управление на достъпа до него.

Поведенчески шаблони:

• Observer: Определя зависимост "един към много" между обекти. При промяна на състоянието на един обект, всички зависими обекти се уведомяват и автоматично се актуализират.
• Strategy: Определя семейство от алгоритми, капсулира всеки от тях и ги прави взаимозаменяеми. Позволява алгоритмите да се променят независимо от клиентите, които ги използват.

  package main
  
  type Strategy interface {
  	Execute(data string)
  }
  
  type ConcreteStrategyA struct{}
  
  func (s *ConcreteStrategyA) Execute(data string) {
  	// Реализация на стратегия A
  }
  
  type ConcreteStrategyB struct{}
  
  func (s *ConcreteStrategyB) Execute(data string) {
  	// Реализация на стратегия 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)
  }
  

• Шаблонен метод: Определя скелета на алгоритъм в операция, прехвърляйки някои стъпки към подкласове. Позволява на подкласовете да преназначават определени стъпки на алгоритъма, без да променят неговата структура.

Освен това, запознат съм с шаблоните като Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. В Go често се използват идиоми на езика, като използването на интерфейси за абстракция, горутини и канали за паралелизъм.