Ի՞նչ նախագծման մոդելների եք ծանոթ:

Ես ծանոթ եմ 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-ում հաճախ օգտագործվում են լեզվի հատուկ իդեոմներ՝ օրինակ՝ ինտերֆեյսների կիրառումը աբստրակցիայ համար, գորուտիներ և ալիքներ՝ համաժամանակեցման համար։