Ի՞նչ տեսակների հղումներ կան Swift-ում։

Swift- ում կա երեք հիմնական տեսակի հղումներ դասի օրինակների վրա:

1. ուժեղ հղում (Strong Reference):

   • Դա հղման կանխադրված տեսակն է:
   • Ուժեղ հղումը ավելացնում է օբյեկտի հղումների հաշվիչը:
   • Օբյեկտը չի ազատվի հիշողությունից, քանի դեռ կա առնվազն մեկ ուժեղ հղում:
   • Հիմնական պատճառը հիշողության արտահոսքն է ուժեղ հղումային ցիկլերի դեպքում:

   class Person {
       let name: String
       init(name: String) { self.name = name }
       deinit { print("\(name) is being deinitialized") }
   }
   
   var reference1: Person? = Person(name: "John")
   // reference1 այժմ ուժեղ հղում է, `Person`-ի հղումների հաշվիչը ավելանում է
   

2. թույլ հղում (Weak Reference):

   • Հռչակվում է weak բառով:
   • Թույլ հղումը չի ավելացնում օբյեկտի հղումների հաշվիչը:
   • Օգտագործվում է strong reference cycles-ից խուսափելու համար:
   • Միշտ օպցիոնալ է (Optional), քանի որ հղվող օբյեկտը կարող է ցանկացած ժամանակ deinitialize լինել:
   • Դեինիցիալիզացիայի ժամանակ թույլ հղումը ավտոմատ կերպով դառնում է nil:

   class Apartment {
       let unit: String
       weak var tenant: Person? // Թույլ հղում
       init(unit: String) { self.unit = unit }
       deinit { print("Apartment \(unit) is being deinitialized") }
   }
   
   var john: Person? = Person(name: "John")
   var unit4A: Apartment? = Apartment(unit: "4A")
   
   john?.apartment = unit4A // Եթե `Apartment`-ը ունենար ուժեղ հղում `Person`-ին
   unit4A?.tenant = john   // Թույլ հղում
   
   // Հետո, երբ ուժեղ հղումները կչեղարկվեն, օբյեկտները deinitialize կկատարվեն
   john = nil
   unit4A = nil
   // Արտածում՝ "John is being deinitialized", "Apartment 4A is being deinitialized"
   // Եթե tenant-ը լիներ ուժեղ հղում, տեղի կունենար հիշողության արտահոսք (strong cycle)
   

3. անհատական հղում (Unowned Reference):

   • Հռչակվում է unowned բառով:
   • Ինչպես թույլ հղումը, չի ավելացնում օբյեկտի հղումների հաշվիչը:
   • Օգտագործվում է strong reference cycles-ից խուսափելու համար:
   • Վերաբերում է այն դեպքերին, երբ հղվող օբյեկտը միշտ գոյություն ունի, երբ հղում ունեցողը կա, և հակառակը չի:
   • Օրինակ՝ "մայր-երեխա" հարաբերություն, որտեղ մայրը տիրապետում է երեխային, բայց ոչ հակառակը:

   class Customer {
       let name: String
       var card: CreditCard?
       init(name: String) { self.name = name }
       deinit { print("\(name) is being deinitialized") }
   }
   
   class CreditCard {
       let number: Int
       unowned let customer: Customer // Անհատական հղում
   
       init(number: Int, customer: Customer) {
           self.number = number
           self.customer = customer // Անհատական հղում ապահով է init-ում
       }
       deinit { print("Card #\(number) is being deinitialized") }
   }
   
   var john: Customer? = Customer(name: "John Doe")
   john?.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
   
   // Ուղղում՝ ուժեղ հղում Customer-ին
   john = nil
   // Արտածում՝ "John Doe is being deinitialized", "Card #1234567890123456 is being deinitialized"
   // Անհատական հղումը `customer`-ին `CreditCard`-ում եղել է գործող, քանի դեռ `customer` գոյություն ուներ:
   // Եթե `CreditCard`-ը երկար ապրեր, քան `Customer`, և մենք փորձեինք հասնել `customer`-ին `unowned` հղումով, տեղի կունենար սխալ:
   

Հիմնական տարբերությունը weak և unowned-ի միջև:

• weak: օբյեկտը կարող է լինել nil. Օգտագործեք, երբ օբյեկտների կյանքը չի կապված խիստ (մեկը կարող է գոյություն ունենալ առանց մյուսի):
• unowned: օբյեկտը չի կարող լինել nil հետո ինիցիալիզացիա. Օգտագործեք, երբ վստահ եք, որ հղվող օբյեկտը գոյություն կունենա առնվազն մինչև այն ժամանակ, երբ գոյություն կունենա հղում ունեցողը։