Swift-ში რა ტიპის ბმულები არსებობს?

Swift-შიში არსებობს სამი ძირითადი სახის კავშირი:

1. მტკიცე კავშირი (Strong Reference):

   • ზრდის ობიექტის მითითებების რაოდენობას.
   • აფერხებს ობიექტის დეალოკაციას მანამ, სანამ არსებობს მინიმუმ ერთი მტკიცე კავშირი.
   • არის Swift-ის მიერ განსაზღვრული კავშირის ტიპი.
   • ძირითადი მიზეზი მტკიცე კავშირების ციკლების წარმოქმნის.

2. სუსტი კავშირი (Weak Reference):

   • არ ზრდის მითითებების რაოდენობას.
   • საშუალებას აძლევს ობიექტის დეალოკაციას, თუ მასზე აღარ არის მტკიცე კავშირი.
   • გამოაცხადება weak კლავიშის გამოყენებით.
   • ყოველთვის არის ოპციონალური (Optional), რადგან სურათის ობიექტი შეიძლება იყოს nil.
   • გამოიყენება მტკიცე კავშირების ციკლების თავიდან ასაცილებლად, როდესაც ერთი ობიექტი შეიძლება არსებობდეს დამოუკიდებლად მეორისგან.

   class Person {
       let name: String
       weak var apartment: Apartment? // სუსტი კავშირი
       init(name: String) {
           self.name = name
       }
       deinit { print("\(name) დეალოკირებული") }
   }
   
   class Apartment {
       let unit: String
       var tenant: Person? // ჩვეულებრივი მტკიცე კავშირი
       init(unit: String) {
           self.unit = unit
       }
       deinit { print("კორპუსი \(unit) დეალოკირებული") }
   }
   
   var john: Person?
   var unit4A: Apartment?
   
   john = Person(name: "John Appleseed")
   unit4A = Apartment(unit: "4A")
   
   john!.apartment = unit4A
   unit4A!.tenant = john // აქ წარმოქმნილი იქნებოდა ციკლი მტკიცე კავშირების გარეშე `weak`-ის გარეშე
   
   // კავშირები ნულდება, ობიექტები დეალოკირდებიან
   john = nil
   unit4A = nil
   

3. საკუთარი კავშირი (Unowned Reference):

   • არ ზრდის მითითებების რაოდენობას.
   • საშუალებას აძლევს ობიექტის დეალოკაციას, თუ მასზე აღარ არის მტკიცე კავშირი.
   • გამოაცხადება unowned კლავიშის გამოყენებით.
   • არ არის ოპციონალური. მოსალოდნელია, რომ სურათის ობიექტი ყოველთვის იქნება არსებობაში, სანამ მასში არსებული სუსტი კავშირი არსებობს.
   • გამოყენება, როდესაც ობიექტი ყოველთვის უნდა არსებობდეს, სანამ მეორე ობიექტი არსებობს (CreditCard ყოველთვის ეკუთვნის Customer).
   • გამოყენებისას, თუ ობიექტი უკვე დეალოკირებულია, მოხდება შეცდომა (crash).
   • გამოიყენება მტკიცე კავშირების ციკლების თავიდან ასაცილებლად, როდესაც ერთი ობიექტი ყოველთვის უნდა არსებობდეს, სანამ მეორე ობიექტი არსებობს, და შეუძლებელია, რომ ერთ-ერთი nil-ში გადავიდეს (მაგ. self-ის ბმული ლამბდასახლებებში).

   class Customer {
       let name: String
       var card: CreditCard?
       init(name: String) {
           self.name = name
       }
       deinit { print("\(name) დეალოკირებული") }
   }
   
   class CreditCard {
       let number: UInt64
       unowned let customer: Customer // საკუთარი კავშირი
       init(number: UInt64, customer: Customer) {
           self.number = number
           self.customer = customer
       }
       deinit { print("ბარათი #\(number) დეალოკირებული") }
   }
   
   var john: Customer? = Customer(name: "John Appleseed")
   john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
   
   // თუ მომხმარებელი ნულდება, ბარათი, რომელიც მასზე მიუთითებს unowned-ით,
   // გახდება გაუქმებული, მაგრამ ციკლი არ შექმნის.
   john = nil // ორივე ობიექტი დეალოკირდება
   

სარჩევი weak და unowned შორის დამოკიდებულია ურთიერთობის ხასიათზე: გამოიყენეთ weak, როდესაც ერთი ობიექტი შესაძლოა არსებობდეს მეორის გარეშე (Person-ი Apartment-ის გარეშე), და unowned, როდესაც ერთი ობიექტი ყოველთვის უნდა არსებობდეს, სანამ მეორე არსებობს (CreditCard ყოველთვის ეკუთვნის Customer).