Wat is unowned in Swift en hoe wordt het gebruikt…

Onowned referentie (zwakke indirecte eigendom) in Swift wordt gebruikt om sterke eigendomscycli (retain cycles) te voorkomen, wanneer twee objecten elkaar sterk verwijzen, waardoor ze niet uit het geheugen worden vrijgegeven.

Kenmerken van unowned:

Garandeert dat het object waarnaar wordt verwezen door de unowned-referentie altijd bestaat tot het moment dat die referentie wordt gebruikt.
Als je probeert toegang te krijgen tot de unowned-referentie nadat het gerelateerde object is vrijgegeven, zal er een runtime crash optreden.
Wordt gebruikt wanneer de levensduur van het verwijzende object niet langer is dan die van het object waarnaar wordt verwezen. Met andere woorden, de unowned-referentie maakt het object niet sterker.

Voorbeeld van gebruik in een sluiting:

class Customer {
    let name: String
    var card: CreditCard?

    init(name: String) {
        self.name = name
    }

    deinit {
        print("\(name) wordt gedeinitialiseerd")
    }
}

class CreditCard {
    let number: UInt64
    unowned let customer: Customer // Unowned referentie naar Customer

    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }

    deinit {
        print("Kaart #\(number) wordt gedeinitialiseerd")
    }
}

var john: Customer? // Optioneel Customer om vrij te geven
john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

// Toewijzing van nil aan john zal leiden tot het vrijgeven van Customer en Card,
// omdat er geen sterke eigendomscyclus is
john = nil

Nog een voorbeeld - gebruik van unowned in een sluitingslijst:

class HTMLElement {
    let name: String
    let text: String?

    lazy var asHTML: () -> String = { [unowned self] in // Gebruik van unowned self
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) wordt gedeinitialiseerd")
    }
}

var paragraph: HTMLElement? // Optioneel HTML-element
paragraph = HTMLElement(name: "p", text: "hallo wereld")
print(paragraph!.asHTML())

// Toewijzing van nil zal HTMLElement vrijgeven, omdat de sluiting het niet sterk vasthoudt
paragraph = nil

De keuze tussen unowned en weak hangt af van of de referentie nil kan worden tijdens de levensduur van het object. Als de referentie nooit nil kan worden vóór het object wordt vrijgegeven, gebruik dan unowned. Als dat wel kan, gebruik dan weak.

Wat is unowned in Swift en hoe wordt het gebruikt?