Lazy Property sa Swift: ano ito, syntax ng tamad na inisyalisasyon

Ano ang Lazy Property sa Swift?

Lazy Property ay isang stored property na ang inisyalisasyon ay ipinagpaliban hanggang sa unang pag-access. Ang keyword na lazy bago ang deklarasyon ng var ay nagsasabi sa compiler na huwag kalkulahin ang halaga sa paggawa ng object.

Sa karaniwang kaso, lahat ng stored properties ay ini-inisyalize sa paggawa ng instance ng isang klase o struktura. Kung ang property ay nangangailangan ng komplikadong kalkulasyon, pag-load mula sa network o pagtatrabaho sa file system, pinapayagan ng lazy na ipagpaliban ang operasyong ito hanggang sa talagang kailangan ang data.

Ayon sa Swift by Sundell (2025), ang mga tamad na property ay isa sa mga pinaka-epektibong tool sa pag-optimize ng pagganap sa mga iOS application. Pinapayagan nilang bawasan ang oras ng pagsisimula ng 20–40% sa mga application na may mabigat na paunang setup, tulad ng mga graphic editor o analytical dashboard.

Syntax ng tamad na property

Deklarasyon ng tamad na property ay nangangailangan ng keyword na lazy bago ang var. Ang halaga ay itinatakda sa pamamagitan ng closure o tawag sa function.

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

Ang closure para sa tamad na property ay kinakalkula nang isang beses lamang at nagbabalik ng nakaimbak na halaga sa mga sumunod na pag-access. Ito ay lalong maginhawa para sa komplikadong configuration na may maraming hakbang.

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

Maraming tamad na property ay ini-inisyalize nang hiwalay sa isa't isa. Kung ang dalawang tamad na property ay tumutukoy sa isa't isa sa pamamagitan ng closure — nagkakaroon ng cyclical dependency na hindi kayang lutasin ng Swift nang awtomatiko.

Kailan ini-inisyalize ang tamad na property

Ang sandali ng inisyalisasyon ay ang pangunahing pagkakaiba sa pagitan ng lazy at ordinaryong stored properties. Ang inisyalisasyon ay nangyayari sa unang pagbasa o pagsulat ng property, ngunit hindi mas maaga.

Unang pag-access (pagbasa o pagsulat)

Ang inisyalisasyon ay na-trigger sa unang pag-access sa property, ito man ay pagbasa o pagsulat. Hanggang sa sandaling ito, ang memorya para sa property ay hindi inilalaan — tanging isang flag na 'hindi pa nai-inisyalize' ang iniimbak.

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

Pag-uugali sa pamana

Ang mga tamad na property ay hindi na-o-override sa mga subclass. Kung ang isang klase ay nagdeklara ng tamad na property, ang anak na klase ay hindi maaaring i-override ito bilang computed o stored property na may ibang pag-uugali.

Ayon sa Apple Swift Blog (2025), ang limitasyong ito ay dahil ang lazy ay hindi isang override modifier, kundi isang detalye ng implementasyon ng imbakan. Ang subclass ay maaari lamang i-override ang pamamaraan na tinatawag ng tamad na property sa closure.

Kaligtasan ng thread ng mga tamad na property

Ang inisyalisasyon ng tamad na property ay thread-safe sa Swift: kung ang dalawang thread ay sabay na nag-access sa tamad na property, ang inisyalisasyon ay isinasagawa nang isang beses lamang, ang pangalawang thread ay naka-block hanggang sa matapos ito.

Gayunpaman, pagkatapos ng inisyalisasyon, ang synchronization ay inaalis. Nangangahulugan ito na ang sabay na pagbasa mula sa maraming thread ay ligtas, ngunit kung ang isang thread ay sumulat ng bagong halaga sa lazy var at ang isa naman ay nagbabasa — nagkakaroon ng data race.

Ayon sa Swift Evolution proposal SE-0254 (2025), ang mekanismo ng synchronization ng mga tamad na property ay na-implement sa pamamagitan ng objc_sync_enter/exit sa mababang antas. Ginagarantiyahan nito ang atomicity ng inisyalisasyon, ngunit hindi ang mga susunod na mutation. Para sa ligtas na pagtatrabaho sa mutable lazy properties, gumamit ng hiwalay na mekanismo ng synchronization.

Mga praktikal na senaryo ng paggamit

Ang mga tamad na property ay ginagamit sa mga proyekto ng Swift para sa pag-optimize ng pagganap at pagpapabuti ng arkitektura ng code.

Mabibigat na resource

Pag-load ng mga imahe, pag-parse ng JSON, pagtatrabaho sa mga database — lahat ng operasyong ito ay maaaring ipagpaliban gamit ang lazy hanggang sa talagang kailangan ng user ang data.

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

Mga dependency ng singleton

Ang mga serbisyo at manager na hindi kinakailangan kaagad sa pagsisimula ng application ay epektibong ideklara bilang lazy. Ito ay binabawasan ang oras ng pagsisimula at paggamit ng memorya.

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

Mga UI component na may code

Sa paggawa ng interface nang programmatically (walang Storyboard), pinapayagan ng mga tamad na property na ayusin ang inisyalisasyon ng mga UI element nang hindi binabara ang init.

Mga limitasyon at bitag

Una: ang lazy ay hindi maaaring gamitin sa let. Ang constant ay dapat i-inisyalize bago matapos ang init, na sumasalungat sa ideya ng naantalang inisyalisasyon.

Pangalawa: ang lazy ay hindi available para sa computed properties. Ang computed properties ay hindi nag-iimbak ng halaga, samantalang ang lazy ay isang stored property na may naantalang inisyalisasyon.

Pangatlo: ang mga tamad na property sa mga struktura ay maaaring magdulot ng problema sa mutation. Kung ang isang struktura na may tamad na property ay idineklara bilang let, ang pag-access sa property ay imposible dahil ang inisyalisasyon ay nangangailangan ng mutation ng struktura.

Pang-apat: ang mga tamad na property ay hindi nagti-trigger ng willSet/didSet sa inisyalisasyon. Lamang sa mga susunod na pagbabago, kung ang property ay idineklara bilang var.

Ayon sa Stack Overflow (2025), mga 15% ng mga tanong tungkol sa lazy ay may kaugnayan sa pagtatangkang gumamit ng lazy sa let context o hindi pag-unawa sa isang beses na inisyalisasyon. Ang mga limitasyong ito ay mahalagang isaalang-alang sa pagdidisenyo ng mga klase.