რომელ დიზაინის ნიმუშებს იცნობთ?

მე ვიცი სხვადასხვა დიზაინის ნიმუშები, რომლებიც გამოიყენება 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
  }
  

• Factory Method: განსაზღვრავს ინტერფეისს ობიექტის შექმნისთვის, მაგრამ საშუალებას აძლევს ქვესახეებს გადაწყვიტონ, რა კლასი უნდა შექმნან. 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 // ან შეცდომა
  	}
  }
  

• Abstract Factory: უზრუნველყოფს ინტერფეისს დაკავშირებული ან დამოკიდებული ობიექტების სერიის შექმნისთვის, გარეშე მათი კონკრეტული კლასების მითითების.
• 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)
  }
  

• Template Method: განსაზღვრავს ალგორითმის ჩარჩოს ოპერაციაში, ზოგიერთი ნაბიჯი გადადის ქვესახეებზე. საშუალებას აძლევს ქვესახეებს შეცვალონ ალგორითმის გარკვეული ნაბიჯები, არ შეცვალონ მისი სტრუქტურა.

გარდა ჩამოთვლილი ნიმუშებისა, ვიცი ისეთი როგორც Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. Go-ში ხშირად გამოიყენება ასევე ენის სპეციფიკური დიზაინის იდეომები, მაგალითად, ინტერფეისების გამოყენება აბსტრაქციისთვის, გორუტინებისა და არხების გამოყენება პარალელიზმისთვის.