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

შექმნადი:

• Singleton: გარანტიას იძლევა, რომ კლასი ერთეული იქნება და გლობალურ წვდომას უზრუნველყოფს.
• Factory Method: განსაზღვრავს ობიექტის შექმნის ინტერფეისს, მაგრამ საშუალებას აძლევს ქვესახეებს გადაწყვიტონ, რომელი კლასი უნდა შექმნან.
• Abstract Factory: უზრუნველყოფს ინტერფეისს დაკავშირებული ან დამოკიდებული ობიექტების ოჯახების შექმნისთვის, მათი კონკრეტული კლასების მითითების გარეშე.
• Builder: ნაწილებად აყოფს რთული ობიექტის კონსტრუქციას, საშუალებას აძლევს შექმნას სხვადასხვა წარმოდგენები ერთსა და იმავე კონსტრუქციის პროცესით.
• Prototype: ქმნის ობიექტებს არსებული ნიმუშის დუბლირებით, ნაცვლად კონსტრუქციის პროცესის თავიდან შესრულებისა.

სტრუქტურული:

• Adapter: გარდაქმნის ერთი კლასის ინტერფეისს სხვა ინტერფეისად, რომელიც მომხმარებლებს ელიან. საშუალებას აძლევს შეუთავსებელ ინტერფეისებს მუშაობა.
• Bridge: განცალკევებს აბსტრაქციას მისი რეალიზაციიდან, მათ დამოუკიდებლად ცვლილების საშუალებას აძლევს.
• Composite: აერთიანებს ობიექტებს ხის სტრუქტურებში, რათა წარმოადგინოს "პატივი-ყველა" იერარქიები. საშუალებას აძლევს მომხმარებლებს ერთგვაროვნად მუშაობა ინდივიდუალურ ობიექტებთან და კომპოზიციებთან.
• Decorator: დინამიურად აძლიერებს ობიექტს ახალი პასუხისმგებლობებით, მას სპეციალურ დეკორატორულ ობიექტში ჩასმით.
• Facade: უზრუნველყოფს ერთიან ინტერფეისს სუბსისტემის ინტერფეისების ნაკრებისთვის. განსაზღვრავს მაღალ დონეზე ინტერფეისს, რომელიც ამარტივებს სუბსისტემის გამოყენებას.
• Flyweight: იყენებს გაზიარებულ მდგომარეობას მცირე ობიექტებს შორის, რათა შეამციროს მეხსიერების მოხმარება და გაზარდოს შესრულება.
• Proxy: უზრუნველყოფს ობიექტის შემცვლელს, რომელიც მართავს წვდომას ორიგინალ ობიექტზე.

მოწყობის:

• Chain of Responsibility: გადმოსცემს მოთხოვნას პასუხისმგებლობის ჯაჭვში. თითოეული პასუხისმგებელი გადაწყვეტს, უნდა თუ არა მოთხოვნის დამუშავება ან გადაცემა შემდეგს.
• Command: ინკაფსულირებს მოთხოვნას როგორც ობიექტს, რაც საშუალებას აძლევს სხვადასხვა მომხმარებლებს პარამეტრიზება, რიგში დაყენება ან ლოგში ჩაწერა.
• Interpreter: განსაზღვრავს ენის გრამატიკულ წარმოდგენას და მოიცავს ინტერპრეტატორს, რათა ინტერპრეტაცია მოხდეს.
• Iterator: უზრუნველყოფს მეთოდს, რომლითაც შესაძლებელია წვდომა ყველა ელემენტზე, არ გამჟღავნოს მისი შიდა წარმოდგენა.
• Mediator: განსაზღვრავს ობიექტებს, რომლებიც მართავენ სხვა ობიექტების ურთიერთქმედებას. ხელს უწყობს სუსტი კავშირების შექმნას, რაც საშუალებას აძლევს ობიექტებს ურთიერთქმედონ უშუალოდ, გარეშე პირდაპირი კავშირის.
• Memento: უზრუნველყოფს შესაძლებლობას შეინახოს და აღადგინოს ობიექტის შიდა მდგომარეობა, ინკაფსულაციის დარღვევის გარეშე.
• Observer: განსაზღვრავს "ერთი-მრავალი" დამოკიდებულებას ობიექტებს შორის, რათა როდესაც ერთი ობიექტის მდგომარეობა იცვლება, ყველა დამოკიდებული ობიექტი იუწყება და ავტომატურად განახლდება.
• State: საშუალებას აძლევს ობიექტს შეცვალოს თავისი ქცევა მისი შიდა მდგომარეობის მიხედვით. თითოეული მდგომარეობა ინკაფსულირებულია ცალკეულ კლასში.
• Strategy: განსაზღვრავს ალგორითმების ოჯახს, ინკაფსულირებს თითოეულს და ხდის მათ ურთიერთგამომრიცხველს. საშუალებას აძლევს აირჩიოს ალგორითმი შესრულების დროს.
• Template Method: განსაზღვრავს ალგორითმის ჩარჩოს ოპერაციაში, გადადებს გარკვეულ ნაბიჯებს ქვესახეებისთვის. საშუალებას აძლევს ქვესახეებს განსაზღვრონ ალგორითმის ნაბიჯები ცვლილების გარეშე.
• Visitor: წარმოადგენს ოპერაციას, რომელიც უნდა შესრულდეს ობიექტების სტრუქტურის ელემენტებზე. საშუალებას აძლევს განსაზღვროს ახალი ოპერაცია, არ შეცვალოს ელემენტების კლასები, რომლებზე მუშაობს.

iOS განვითარების დროსაც ხშირად გამოიყენება:

• Model-View-Controller (MVC): არქიტექტურული ნიმუში, რომელიც იყოფა სამ დაკავშირებულ კომპონენტად: მოდელი (მონაცემები და ბიზნეს-ლოგიკა), ხედვა (მომხმარებლის ინტერფეისი) და კონტროლერი (მოდელისა და ხედვის შორის კავშირი).
• Delegate: საშუალებას აძლევს ერთ ობიექტს მოქმედოს სახელით ან კოორდინიროს სხვა ობიექტის მოქმედებები.
• Observer (NotificationCenter): შეტყობინებების გაგზავნის სისტემა, რომელიც საშუალებას აძლევს ობიექტებს მიიღონ შეტყობინებები უშუალო კავშირის გარეშე.
• Target-Action: მექანიზმი, რომელიც გამოიყენება შეტყობინებების გაგზავნისთვის მართვის ელემენტებიდან (მაგალითად, ღილაკებიდან) მიზნობრივ ობიექტზე.
• Coordinator: ნავიგაციის ნაკადების მართვის ნიმუში, რომელიც გამოყოფს ნავიგაციის ლოგიკას კონტროლერებიდან.
• Dependency Injection: ნიმუში, სადაც ობიექტის დამოკიდებულებები ინექცირებულია გარედან, ნაცვლად იმისა, რომ თავად შექმნას.

// Singleton-ის მაგალითი
class SettingsManager {
    static let shared = SettingsManager() // ერთი მაგალითი

    private init() {
        // პირადი ინიციალიზატორი, რათა თავიდან აიცილოს გარედან შექმნა
    }

    var appVersion: String {
        return Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "უცნობია"
    }
}

// გამოყენება
let settings = SettingsManager.shared
print("აპლიკაციის ვერსია: \(settings.appVersion)")

// Delegate-ის მაგალითი (სადაცაა)
protocol ButtonDelegate: AnyObject {
    func buttonWasTapped(_ button: UIButton)
}

class MyButton: UIButton {
    weak var delegate: ButtonDelegate? // Delegate თვისება

    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
        super.touchesEnded(touches, with: event)
        delegate?.buttonWasTapped(self) // Delegate მეთოდის გამოძახება
    }
}

class ViewController: UIViewController, ButtonDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        let myButton = MyButton(frame: CGRect(x: 50, y: 50, width: 100, height: 40))
        myButton.setTitle("დაწკაპუნეთ", for: .normal)
        myButton.backgroundColor = .blue
        myButton.delegate = self // დელეგატის დაყენება
        view.addSubview(myButton)
    }

    func buttonWasTapped(_ button: UIButton) {
        print("ბატონი დაწკაპულია ViewController-ში")
    }
}