Fatal error: Attempted to read an unowned reference but object 0x21b4f0 was already destroyed
O referință unowned indică un obiect care a fost deja eliberat din memorie, iar tu încerci să-l folosești. Folosește o referință normală (puternică) dacă obiectul trebuie să trăiască, sau weak (opțională) dacă poate dispărea.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Swift eliberează un obiect (o instanță de clasă) când nu mai are nicio referință puternică (ARC). O referință unowned nu ține obiectul în viață: e o promisiune că obiectul va exista cât timp folosești referința. Dacă promisiunea e încălcată, adică obiectul a fost eliberat și tu citești totuși unowned, programul se oprește cu acest mesaj. Adresa (0x...) diferă la fiecare rulare.
Apare tipic când singura referință puternică era o variabilă locală dintr-o funcție: la ieșirea din funcție obiectul dispare, iar obiectul care îl ținea unowned rămâne cu o referință moartă. Mai apare în closure-uri cu [unowned self] care rulează după ce ecranul a fost închis.
Regula: unowned doar când celălalt obiect trăiește garantat cel puțin cât tine. Altfel, weak var (opțional, devine nil) sau o referință normală.
De ce apare: cauzele frecvente
1Obiectul referit unowned e creat local
class Client { let nume = "Ana" }
class Comanda {
unowned let client: Client
init(client: Client) { self.client = client }
}
func creeaza() -> Comanda {
Comanda(client: Client())
}
print(creeaza().client.nume)class Client { let nume = "Ana" }
class Comanda {
let client: Client
init(client: Client) { self.client = client }
}
func creeaza() -> Comanda {
Comanda(client: Client())
}
print(creeaza().client.nume)Cu o referință puternică, comanda ține clientul în viață cât timp are nevoie de el.
2[unowned self] într-un closure care trăiește mai mult
class Ecran {
var titlu = "Profil"
func handler() -> () -> String {
return { [unowned self] in self.titlu }
}
}
let h = Ecran().handler()
print(h())class Ecran {
var titlu = "Profil"
func handler() -> () -> String {
return { [weak self] in self?.titlu ?? "închis" }
}
}
let h = Ecran().handler()
print(h())Cu weak, după eliberarea ecranului self devine nil, iar closure-ul tratează cazul fără să oprească programul.
Repară eroarea, direct în pagină
Funcția creeazaComanda creează un client și o comandă care îl reține. Programul trebuie să afișeze Client: Ana, dar se oprește cu Attempted to read an unowned reference but object ... was already destroyed, pentru că clientul dispare la ieșirea din funcție. Fă ca, în Comanda, referința la client să țină clientul în viață.
class Client {
let nume: String
init(nume: String) {
self.nume = nume
}
}
class Comanda {
unowned let client: Client
init(client: Client) {
self.client = client
}
}
func creeazaComanda() -> Comanda {
let c = Client(nume: "Ana")
return Comanda(client: c)
}
let comanda = creeazaComanda()
print("Client: \(comanda.client.nume)")Client: Ana
Indiciu
Scoate unowned de pe proprietatea client.
Reparația
class Client {
let nume: String
init(nume: String) {
self.nume = nume
}
}
class Comanda {
let client: Client
init(client: Client) {
self.client = client
}
}
func creeazaComanda() -> Comanda {
let c = Client(nume: "Ana")
return Comanda(client: c)
}
let comanda = creeazaComanda()
print("Client: \(comanda.client.nume)")De ce merge
Singura referință puternică la client era constanta locală c. La ieșirea din funcție, ARC elibera clientul, iar referința unowned din comandă rămânea fără obiect, deci citirea comanda.client oprea programul. Ca referință normală, client ține clientul în viață cât timp există comanda, iar numele se poate citi.
Alte forme ale mesajului
Fatal error: Attempted to read an unowned reference but object 0x600000c04000 was already deallocatedThread 1: Fatal error: Attempted to read an unowned reference but object 0x600000c04000 was already deallocated
Cum o eviți pe viitor
- Implicit, folosește referințe normale. Treci la
weakdoar ca să rupi un ciclu de referințe (delegate, părinte). - Folosește
unowneddoar când viața celuilalt obiect e garantat cel puțin la fel de lungă (de exemplu, un client și cardul lui). - În closure-uri care pot rula mai târziu (callback-uri de rețea, timere), preferă
[weak self].
Întrebări frecvente
Care e diferența dintre weak și unowned?
Ambele nu țin obiectul în viață. weak e mereu opțional și devine nil automat când obiectul dispare. unowned nu e opțional: dacă obiectul a dispărut, citirea oprește programul.
De ce s-ar folosi unowned, dacă e riscant?
Când știi sigur că obiectul există, unowned evită despachetarea opționalului la fiecare folosire. Dar câștigul e mic, iar riscul e o oprire bruscă, deci în caz de dubiu folosește weak.
Erori înrudite
error: 'weak' must not be applied to non-class-bound 'any Delegat'; consider adding a protocol conformance that has a class bound weak merge doar pe referințe la clase, iar protocolul tău poate fi adoptat și de struct-uri. Restrânge protocolul la clase: protocol Delegat: AnyObject { ... }. Apoi weak var delegat: Delegat? compilează. Fatal error: Unexpectedly found nil while unwrapping an Optional value Programul s-a oprit pentru că ai despachetat cu ! un opțional care era nil (o conversie Int("abc")!, o cheie lipsă dict["x"]!, first! pe o listă goală). Înlocuiește ! cu if let, guard let sau ??, ca să tratezi cazul fără valoare. error: reference to property 'valoare' in closure requires explicit use of 'self' to make capture semantics explicit Într-un closure escaping dintr-o clasă folosești o proprietate fără self. Swift cere să scrii self.valoare (sau [self] / [weak self] în lista de captură), ca să fie vizibil că closure-ul ține obiectul în viață. Învață Swift de la zero, cu exerciții la fiecare lecție
Curs Swift (iOS): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
