Lazy Property în Swift: ce este, sintaxa inițializării leneșe

Ce este Lazy Property în Swift?

Lazy Property este o stored property a cărei inițializare este amânată până la prima accesare. Cuvântul cheie lazy înaintea declarației var indică compilatorului să nu calculeze valoarea la crearea obiectului.

În cazul standard, toate stored properties sunt inițializate la crearea instanței unei clase sau structuri. Dacă proprietatea necesită calcule complexe, încărcare din rețea sau lucru cu sistemul de fișiere, lazy permite amânarea acestei operațiuni până când datele sunt cu adevărat necesare.

Conform Swift by Sundell (2025), proprietățile leneșe sunt unul dintre cele mai eficiente instrumente de optimizare a performanței în aplicațiile iOS. Ele permit reducerea timpului de pornire cu 20–40% în aplicațiile cu configurare inițială grea, cum ar fi editorii grafici sau panourile analitice.

Sintaxa proprietății leneșe

Declararea unei proprietăți leneșe necesită cuvântul cheie lazy înainte de var. Valoarea este stabilită printr-un closure sau apel de funcție.

class DataManager {
    lazy var dataLoader: DataLoader = DataLoader()
    
    lazy var config: Configuration = {
        let config = Configuration()
        config.loadDefaults()
        return config
    }()
}

Closure-ul pentru proprietatea leneșă se calculează o singură dată și returnează valoarea salvată la accesările ulterioare. Acest lucru este deosebit de convenabil pentru configurarea complexă cu mai mulți pași.

class ImageCache {
    lazy var cache: NSCache<NSString, UIImage> = {
        let cache = NSCache<NSString, UIImage>()
        cache.countLimit = 100
        cache.totalCostLimit = 50 * 1024 * 1024
        return cache
    }()
}

Mai multe proprietăți leneșe sunt inițializate independent una de cealaltă. Dacă două proprietăți leneșe se referă una la alta prin closure-uri — apare o dependență ciclică pe care Swift nu o poate rezolva automat.

Când este inițializată proprietatea leneșă

Momentul inițializării este diferența cheie între lazy și stored properties obișnuite. Inițializarea are loc la prima citire sau scriere a proprietății, dar nu mai devreme.

Prima accesare (citire sau scriere)

Inițializarea este declanșată la prima accesare a proprietății, fie citire, fie scriere. Până în acest moment, memoria pentru proprietate nu este alocată — este stocat doar un indicator „neinițializat”.

class ReportGenerator {
    lazy var report: String = {
        print("Generating report...")
        return "Annual report data"
    }()
}

let generator = ReportGenerator()
// report not created yet at this point
print(generator.report)  // "Generating report..."
print(generator.report)  // not regenerated on subsequent access

Comportament la moștenire

Proprietățile leneșe nu sunt suprascrise în subclase. Dacă o clasă declară o proprietate leneșă, clasa copil nu o poate suprascrie ca computed sau stored property cu alt comportament.

Conform Apple Swift Blog (2025), această limitare se datorează faptului că lazy nu este un modificator de suprascriere, ci un detaliu de implementare a stocării. Subclasa poate doar suprascrie metoda pe care proprietatea leneșă o apelează în closure.

Siguranța firelor a proprietăților leneșe

Inițializarea proprietății leneșe este thread-safe în Swift: dacă două fire accesează simultan o proprietate leneșă, inițializarea se execută o singură dată, al doilea fir fiind blocat până la finalizarea acesteia.

Totuși, după inițializare, sincronizarea este eliminată. Aceasta înseamnă că citirea simultană din mai multe fire este sigură, dar dacă un fir scrie o nouă valoare în lazy var, iar altul citește — apare o data race.

Conform Swift Evolution proposal SE-0254 (2025), mecanismul de sincronizare a proprietăților leneșe este implementat prin objc_sync_enter/exit la nivel scăzut. Aceasta garantează atomicitatea inițializării, dar nu și a mutațiilor ulterioare. Pentru lucrul sigur cu proprietăți mutable lazy, utilizați mecanisme separate de sincronizare.

Scenarii practice de utilizare

Proprietățile leneșe sunt utilizate în proiectele Swift pentru optimizarea performanței și îmbunătățirea arhitecturii codului.

Resurse grele

Încărcarea imaginilor, parsarea JSON, lucrul cu baze de date — toate aceste operațiuni pot fi amânate cu lazy până când datele sunt cu adevărat necesare utilizatorului.

class ProfileViewController {
    lazy var avatarImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFill
        imageView.clipsToBounds = true
        return imageView
    }()
}

Dependențe singleton

Serviciile și managerii care nu sunt necesari imediat la pornirea aplicației pot fi declarate eficient ca lazy. Aceasta reduce timpul de pornire și consumul de memorie.

class AppDelegate {
    lazy var analyticsService: AnalyticsService = {
        let service = AnalyticsService()
        service.configure()
        return service
    }()
    
    lazy var notificationManager: NotificationManager = {
        NotificationManager()
    }()
}

Componente UI cu cod

La crearea programatică a interfeței (fără Storyboard), proprietățile leneșe permit organizarea inițializării elementelor UI fără a aglomera init-ul.

Limitări și capcane

Prima limitare: lazy nu poate fi folosit cu let. Constanta trebuie inițializată înainte de finalizarea init, ceea ce contrazice însăși ideea de inițializare întârziată.

A doua limitare: lazy nu este disponibil pentru computed properties. Computed properties nu stochează valoarea, iar lazy este exact o stored property cu inițializare întârziată.

A treia limitare: proprietățile leneșe în structuri pot cauza probleme cu mutația. Dacă o structură cu o proprietate leneșă este declarată ca let, accesul la proprietate este imposibil, deoarece inițializarea necesită mutația structurii.

A patra: proprietățile leneșe nu declanșează willSet/didSet la inițializare. Doar la modificările ulterioare, dacă proprietatea este declarată ca var.

Conform Stack Overflow (2025), aproximativ 15% din întrebările despre lazy sunt legate de încercarea de a folosi lazy în context let sau de neînțelegerea unicității inițializării. Aceste limitări sunt importante de luat în considerare la proiectarea claselor.