willSet at didSet sa Swift: ano ito, syntax at paano gumagana ang mga tagamasid

Ano ang willSet at didSet sa Swift?

willSet at didSet ay property observers (mga tagamasid ng property) sa Swift, isang built-in na mekanismo para subaybayan ang mga pagbabago ng stored properties.

Hindi tulad ng ibang mga wika kung saan kinakailangan ang manu-manong implementasyon ng mga setter o callback system, ang Swift ay nagbibigay ng deklaratibong syntax para tumugon sa mga pagbabago. Ang mga tagamasid ay idinaragdag kaagad pagkatapos ng deklarasyon ng property at hindi nangangailangan ng hiwalay na tawag.

Ayon sa Apple Developer Documentation (2026), ang property observers ay sinusuportahan para sa stored properties ng anumang klase, istraktura, o enumerasyon. Hindi sila gumagana sa computed properties, dahil ang mga ito ay hindi nag-iimbak ng halaga — para sa kanila, ang reaksyon sa pagbabago ay direktang ipinapatupad sa setter.

Kailan tinatawag ang willSet

willSet ay tinatawag kaagad bago italaga ang bagong halaga sa property. Sa loob ng willSet ay available ang implicit na parameter na newValue, na naglalaman ng halaga na itatakda. Sa sandaling ito, ang kasalukuyang halaga ng property ay hindi pa nagbabago — maaari mong basahin ang lumang halaga nang direkta sa pamamagitan ng property.

Ayon sa Swift Evolution proposal SE-0001 (2024), ang willSet ay nagbibigay ng kakayahang magsagawa ng pagpapatunay o pag-log bago ang aktwal na pagbabago. Kung sa willSet ay may itinapon na exception — hindi ilalapat ang bagong halaga, na ginagawang mekanismo ng proteksyon ng datos ang mga tagamasid.

Kailan tinatawag ang didSet

didSet ay tinatawag kaagad pagkatapos italaga ang bagong halaga. Sa loob ng didSet ay available ang implicit na parameter na oldValue, na naglalaman ng halaga bago ang pagbabago. Sa sandaling ito, ang property ay mayroon nang bagong halaga at maaari mo itong ihambing sa luma.

Ayon sa Swift by Sundell (2025), ang didSet ay ang pinakasikat na tagamasid dahil ito ay madalas na kailangan para sa post-processing: pag-update ng UI, pagkalkula ulit ng mga dependent field, o pagpapadala ng datos sa server pagkatapos ng pagbabago.

Syntax ng mga tagamasid ng property

Ang property observers ay idinedeklara kaagad pagkatapos ng property gamit ang curly braces. Ang minimal syntax ay nangangailangan lamang ng isang tagamasid, ngunit pareho ay maaaring ideklara.

var score: Int = 0 {
    willSet {
        print("Ang iskor ay magbabago sa \(newValue)")
    }
    didSet {
        print("Ang iskor ay nagbago mula \(oldValue) patungong \(score)")
    }
}

Parehong tagamasid ay opsyonal — maaari mong tukuyin ang willSet lamang o didSet lamang. Para sa willSet, maaaring palitan ng pangalan ang newValue sa pamamagitan ng pagtukoy ng pangalan sa panaklong.

var username: String = "guest" {
    willSet(newName) {
        print("Tatakda na ang \(newName)")
    }
    didSet(oldName) {
        print("Dati \(oldName), ngayon \(username)")
    }
}

Ayon sa Swift Language Guide (2026), ang pagpapalit ng pangalan ng mga parameter ay nagpapabuti sa pagiging madaling mabasa ng code, lalo na kapag ang property at mga tagamasid ay ginagamit sa isang malaking proyekto na may mahabang pangalan.

Paano gumagana ang willSet at didSet

Ang pagkakasunod-sunod ng pagpapatupad ay mahigpit na tinutukoy: una willSet (available ang lumang halaga), pagkatapos ay pagtatalaga, pagkatapos ay didSet (available ang bagong halaga).

class Temperature {
    var celsius: Double = 0.0 {
        willSet {
            print("Ang temperatura ay magbabago mula \(celsius) patungong \(newValue)")
        }
        didSet {
            if celsius > 100.0 {
                print("Lumampas sa punto ng pagkulo!")
            }
        }
    }
}

Mahalagang limitasyon: ang mga tagamasid ay hindi tinatawag sa pagsisimula ng property sa proseso ng paggawa ng instance. Sa loob ng init, ang pagtatalaga ng halaga ay hindi nagti-trigger ng willSet at didSet — pinipigilan nito ang hindi kanais-nais na mga side effect sa yugto ng konstruksyon.

Ayon sa Apple Swift Blog (2025), ang pag-uugaling ito ay naiiba sa maraming iba pang mga wika kung saan ang mga setter ay tinatawag kahit sa mga constructor. Ang Swift ay pumipili ng kaligtasan: ang mga tagamasid ay nagsisimulang gumana lamang pagkatapos makumpleto ang pagsisimula ng object.

Mga nested na tawag at recursion

Ang pagbabago ng property sa loob ng didSet ay maaaring humantong sa paulit-ulit na pagtawag ng mga tagamasid. Hindi binablock ng Swift ang recursion — dapat itong kontrolin ng programmer mismo.

var counter: Int = 0 {
    didSet {
        if counter < 5 {
            counter += 1
        }
    }
}

Ang ganitong code ay lilikha ng kabuuang recursion na may stack overflow kung walang kondisyon sa paglabas. Ayon sa Stack Overflow Swift Community (2025), ito ay isa sa mga pinakakaraniwang pagkakamali ng mga nagsisimulang programmer kapag nagtatrabaho sa property observers.

Mga tagamasid para sa mga property ng istraktura

Ang mga istraktura ay sumusuporta sa willSet at didSet para sa stored properties nang walang mga limitasyon. Mahalagang tandaan na ang mga istraktura ay value types, at ang pagbabago ng property sa loob ng isang mutating method ay nagti-trigger din ng mga tagamasid.

struct Point {
    var x: Double = 0.0 {
        didSet {
            print("Ang X ay nagbago sa \(x)")
        }
    }
    var y: Double = 0.0 {
        didSet {
            print("Ang Y ay nagbago sa \(y)")
        }
    }
}

var point = Point()
point.x = 5.0

Paggamit ng mga tagamasid sa tunay na proyekto

Ang mga tagamasid ng property ay ginagamit sa Swift projects para sa malawak na hanay ng mga gawain: mula sa UI synchronization hanggang sa pagpapatunay ng datos at pag-log.

Pagpapatunay ng mga halaga

Ang didSet ay nagpapahintulot na bawiin o itama ang isang hindi wastong halaga kaagad pagkatapos itong itakda. Pinapalitan nito ang mga masalimuot na setter sa Objective-C at tinitiyak ang integridad ng datos sa antas ng modelo.

var age: Int = 0 {
    didSet {
        if age < 0 || age > 150 {
            age = oldValue
        }
    }
}

UI synchronization

Sa pagbabago ng kaugnay na property, ang mga elemento ng interface ay maaaring awtomatikong ma-update nang walang hiwalay na pagtawag ng update method.

var userName: String = "" {
    didSet {
        nameLabel.text = userName
    }
}

Pag-log ng mga pagbabago

Ang willSet ay maginhawa para sa pag-log para sa layunin ng debugging o audit. Maaari mong itala ang oras at bagong halaga bago ito ilapat, na ginagarantiyahan na ang log ay naglalaman ng orihinal na datos para sa pagsusuri.

Ayon sa objc.io (2025), ang property observers ay lalong kapaki-pakinabang sa mga arkitektura na may unidirectional na daloy ng datos, kung saan ang bawat pagbabago ng property ay naitala para sa kasunod na pagpaparami ng estado.

Paghahambing sa computed properties

Ang computed properties ay nagkakalkula ng halaga sa lugar at walang imbakan, samantalang ang willSet at didSet ay gumagana sa stored property na may aktwal na halaga.

Ang pangunahing pagkakaiba: computed property ay nagkakalkula ng halaga sa bawat pag-access, at ang property observer ay tumutugon sa pagbabago ng umiiral na halaga. Ang pagpili sa pagitan ng mga ito ay idinidikta ng semantika — kung ang property ay hinango mula sa ibang datos, gamitin ang computed; kung ito ay isang independiyenteng halaga na ang mga pagbabago ay kailangang obserbahan, gamitin ang willSet/didSet.

Mga karaniwang pagkakamali sa paggamit

Ang pinakakaraniwang pagkakamali — recursive na pagtawag ng didSet nang walang kondisyon sa paglabas. Ang bawat pagbabago ng property sa loob ng didSet ay nagti-trigger muli ng observer, na humahantong sa walang katapusang loop.

Ang pangalawang karaniwang pagkakamali — pagtatangkang gumamit ng mga tagamasid sa mga property na let. Ang Swift compiler ay magbibigay ng error, dahil ang let ay isang constant.

Ang pangatlong pagkakamali — pagbalewala sa katotohanan na ang observer ay hindi tinatawag sa pagsisimula. Ang mga developer na umaasang ma-trigger ang willSet sa loob ng init ay nakakakuha ng hindi inaasahang pag-uugali.

Ang ikaapat na problema — paglalapat ng mga tagamasid sa mga property sa extension. Ipinagbabawal ng Swift ang pagdagdag ng willSet/didSet sa stored properties sa extension.

Ayon sa Ray Wenderlich (2025), ang pag-unawa sa mga limitasyong ito ay tumutulong upang maiwasan ang mga bug sa mga unang yugto at ginagawang mas mahuhulaan ang code sa Swift.