struct — ano ito, mga pangunahing konsepto at syntax sa Swift

Ano ang struct sa Swift?

Struct (istruktura) — ay isang pinagsamang uri ng data sa Swift na nagpapangkat ng mga kaugnay na property at method sa iisang entity. Hindi tulad ng mga klase, ang mga istruktura ay value types: kapag ipinasa sa isang function o itinalaga sa isang bagong variable, isang malayang kopya ng istruktura ang ginagawa, hindi isang sanggunian sa orihinal na bagay.

Gumagamit ang Swift ng mga istruktura para sa lahat ng primitive na uri: Int, Double, String, Bool, Array, Dictionary at Set. Nangangahulugan ito na kahit ang pangunahing bilang na Int ay kumikilos bilang isang istruktura — kapag itinalaga, isang kopya ang ginagawa. Maaaring tukuyin ng developer ang kanyang sariling istruktura na may anumang hanay ng mga property at method.

Ayon sa Swift Evolution (SE-0143), ang desisyon na ipatupad ang mga standard na uri bilang mga istruktura ay udyok ng pagganap at predictability. Ang value types ay hindi lumilikha ng mga reference cycle, hindi nangangailangan ng ARC reference counting at ginagarantiyahan na ang pagbabago sa kopya ay hindi makakaapekto sa orihinal — ito ay kritikal para sa immutability ng data sa mga multi-threaded na senaryo.

Struct bilang value type

Value type semantics — ang pangunahing pagkakaiba sa pagitan ng struct at class. Kapag nagtalaga ka ng istruktura sa isang bagong variable o ipinasa ito sa isang function, lumilikha ang Swift ng malayang kopya ng lahat ng data. Anumang pagbabago sa kopya ay hindi makakaapekto sa orihinal, na nag-aalis ng mga side effect na katangian ng mga reference type.

// Halimbawa ng semantika ng value type
struct Point {
    var x: Double
    var y: Double
}

var p1 = Point(x: 10, y: 20)
var p2 = p1        // Ang p2 ay isang malayang kopya ng p1
p2.x = 99            // Ang p2 lamang ang nagbabago
print(p1.x)         // 10 — p1 hindi nagbago
print(p2.x)         // 99

Copy-on-Write optimisasyon

Gumagamit ang Swift ng Copy-on-Write (COW) upang i-optimize ang pagkopya. Kung maraming variable ang tumutukoy sa parehong istruktura, ngunit wala sa kanila ang nagbabago ng data, ang aktwal na pagkopya ay hindi nangyayari. Ibinabahagi ng Swift ang memorya sa pagitan ng mga variable hanggang sa unang mutation — pagkatapos ay ginagawa ang isang tunay na kopya. Pinipigilan nito ang mga labis na operasyon ng alokasyon at pinapabilis ang pagtatrabaho sa mga koleksyon.

Pagbabago at mga mutating method

Bilang default, ang mga method ng istruktura ay hindi maaaring baguhin ang mga property nito — nangangailangan ang Swift ng malinaw na indikasyon ng mutating para sa mga method na gumagawa ng mga pagbabago. Ang paghihigpit na ito ay nagpoprotekta laban sa aksidenteng mutation at ginagawang predictable ang code: kung ang isang method ay hindi minarkahan ng mutating, garantisadong hindi mo babaguhin ang istruktura.

Mutating sa aksyon

Kapag idinagdag mo ang keyword na mutating bago ang method, nakakakuha ang Swift ng kakayahang magsulat ng mga bagong halaga sa mga property ng istruktura. Sa katunayan, ang method ay maaaring ganap na palitan ang instance ng istruktura ng bago sa pamamagitan ng self = . Ang mekanismong ito ay ginagamit, halimbawa, sa mga uri ng Option at Result.

// Struct na may mutating method
struct Counter {
    private var value: Int = 0

    // Mutating method — maaaring baguhin ang mga property
    mutating func increment() {
        value += 1
    }

    // Mutating method ay maaaring ganap na palitan ang self
    mutating func reset() {
        self = Counter()
    }

    // Non-mutating method — para lamang sa pagbasa
    func currentValue() -> Int {
        return value
    }
}

var counter = Counter()
counter.increment()
print(counter.currentValue())  // 1
counter.reset()
print(counter.currentValue())  // 0

Mga patakaran para sa mutating: ang istruktura ay dapat ideklara sa pamamagitan ng var, hindi let — ang isang constant na istruktura ay hindi maaaring tumawag ng mutating method. Sinusuri ito ng compiler sa yugto ng kompilasyon: ang pagtatangkang tumawag ng mutating method sa isang let constant ay magdudulot ng error sa kompilasyon.

Struct vs Class: paghahambing

Ang pagpili sa pagitan ng struct at class — isa sa mga pangunahing desisyon sa Swift. Ang parehong uri ay maaaring maglaman ng mga property, method, initializer at magpatupad ng mga protocol, ngunit may mga pangunahing pagkakaiba sa semantika ng memorya, pamana at pamamahala ng siklo ng buhay.

Mas gusto ang mga istruktura kapag ang data ay hindi nangangailangan ng pamana, hindi dapat magkaroon ng nakabahaging pagkakakilanlan (halimbawa, mga coordinate, sukat, configuration) at ipinapasa sa pagitan ng mga modyul. Pinipili ang mga klase para sa mga bahagi ng UI (UIView, UIViewController), singleton at mga bagay na may nakabahaging pagkakakilanlan.

Kailan pumili ng struct

Inirerekomenda ng Apple ang paggamit ng struct bilang default na uri para sa pagmomodelo ng data sa Swift. Ang mga istruktura ay angkop para sa karamihan ng mga senaryo dahil sa predictable na semantika ng pagkopya at kawalan ng overhead para sa pagbibilang ng sanggunian. Tingnan natin ang mga karaniwang kaso kung kailan ang struct ay pinakamainam na pagpipilian.

Mga modelo ng data nang walang pamana

Kung ang entity ay naglalaman ng data nang walang pangangailangan ng pamana (Product, User, Order, Point), gamitin ang struct. Awtomatikong bumubuo ang compiler ng memberwise initializer — hindi mo kailangang sumulat ng init nang manu-mano. Ang Equatable at Hashable ay awtomatiko ring ipinatutupad para sa mga istruktura na ang lahat ng property ay nakakatugon sa mga protocol na ito.

Hindi nababagong (immutable) data

Para sa mga configuration, setting at flag na hindi nagbabago pagkatapos ng paggawa, ang struct ay mas gusto kaysa class. Ang isang constant (let) na istruktura ay ginagarantiyahan ang immutability ng lahat ng nested field — sa class ito ay nauukol lamang sa sanggunian, hindi sa nilalaman ng bagay.

Multi-threaded code

Ang mga istruktura ay ligtas sa multi-threaded na kapaligiran dahil sa value semantics. Ang bawat thread ay tumatanggap ng malayang kopya ng data at hindi nakakaapekto sa iba pang mga thread. Ang race condition sa pagitan ng mga thread ay imposible para sa value types, na ginagawang struct ang mas gustong pagpipilian para sa mga modelo sa SwiftUI (ObservableObject ay nangangailangan ng class, ngunit ang @State ay gumagamit ng struct).

// Halimbawa ng paggamit ng struct para sa modelo ng data
struct User: Codable, Identifiable {
    let id: UUID
    var name: String
    var email: String
    var isPremium: Bool

    // Computed property — non-mutating
    var displayName: String {
        isPremium ? "\(name) ⭐️" : name
    }
}

// Awtomatikong memberwise initializer
let user = User(
    id: UUID(),
    name: "Alice",
    email: "alice@example.com",
    isPremium: true
)

// Ang pagkopya ay ligtas para sa multi-threading
var userCopy = user
userCopy.isPremium = false
// Ang user.isPremium ay nananatiling true

Gamitin ang class kapag kailangan mo ng pamana (mga bahagi ng UIKit/AppKit), nakabahaging pagkakakilanlan (delegate, observer) o kontroladong siklo ng buhay ng mga bagay (deinit). Para sa lahat ng iba pa — struct.