Associated Values sa Swift: ano ito, syntax at mga halimbawa

Ano ang Associated Values?

Associated Values — ay karagdagang impormasyon na maaaring iimbak ng isang case ng enum kasama ng sarili nito. Hindi tulad ng raw values, na naayos sa antas ng deklarasyon, ang associated values ay itinatakda kapag lumilikha ng instance ng enum.

Isipin ang pagmomodelo ng isang paraan ng pagbabayad: ang case na creditCard ay maaaring mag-imbak ng huling 4 na digit at petsa ng pagkawalang-bisa, at ang case na applePay — wala. Sa associated values ito ay naipapatupad nang natural, walang mga subclass o opsyonal na field.

Ayon sa dokumentasyon ng Apple, binabago ng associated values ang enum mula sa isang simpleng set ng mga constant tungo sa isang algebraic na uri ng data (sum type), na katangian ng mga functional na wika. Ito ay makabuluhang nagpapataas ng pagpapahayag ng code.

Syntax ng associated values

Associated values ay idineklara sa mga panaklong pagkatapos ng case, na may pagbanggit ng mga pangalan at uri ng parameter, tulad ng sa mga function.

enum MediaFile {
    case image(width: Int, height: Int, format: String)
    case video(duration: Double, codec: String)
    case audio(bitrate: Int)
    case unknown
}

Kapag lumilikha ng instance, ang associated values ay ipinapasa bilang mga argumento:

let photo = MediaFile.image(width: 1920, height: 1080, format: "jpeg")
let clip = MediaFile.video(duration: 120.5, codec: "h264")

Ang Swift ay hindi nagpapataw ng mga paghihigpit sa bilang o uri ng associated values. Maaari kang gumamit ng generics, closure function, at iba pang enum sa loob ng associated values. Ginagawa nitong posible ang pagbuo ng mga kumplikadong nested na istruktura.

Ang mga pangalan ng parameter ng associated values ay ginagamit bilang mga label ng argumento kapag lumilikha ng instance — pinapabuti nito ang pagkabasa ng code. Sa pagkuha sa pamamagitan ng switch, ang mga pangalan ay nagsisilbing dokumentasyon, na nagpapaliwanag ng kahulugan ng bawat halaga. Ang ganitong diskarte ay ginagawang self-documenting ang code at binabawasan ang posibilidad ng mga error sa pagtutugma ng data. Ito ay lalong mahalaga sa pag-develop ng team ng malalaking iOS application.

Switch na may associated values

Switch — ang pangunahing paraan ng pagkuha ng associated values. Ang mga halaga ay ibinabahagi sa mga constant o variable sa pamamagitan ng let o var.

func describe(_ file: MediaFile) -> String {
    switch file {
    case .image(let w, let h, let fmt):
        return "Image \(w)x\(h) .\(fmt)"
    case .video(let duration, let codec):
        return "Video \(duration)s, \(codec)"
    case .audio(let bitrate):
        return "Audio \(bitrate)kbps"
    case .unknown:
        return "Unknown format"
    }
}

Sinusuportahan ng Swift ang partial na pagtutugma — maaaring tukuyin ang mga tiyak na halaga ng associated values:

switch file {
case .image(let w, let h, "png"):
    print("Larawang PNG \(w)x\(h)")
case .image(1920, 1080, _):
    print("Larawang Full HD")
default:
    break
}

Ang paggamit ng wildcard (_) ay nagbibigay-daan upang huwag pansinin ang mga hindi kinakailangang associated values, at ang mga constant sa case — upang suriin ang pagtutugma sa mga tiyak na halaga.

Associated Values vs Raw Values

Maraming baguhang developer ang nagkakamali ng associated values sa raw values. Ang mga ito ay magkaibang mekanismo na may magkaibang mga sitwasyon ng paggamit.

Ayon sa Swift Evolution, ang associated values ay ipinakilala sa Swift 2.0 bilang bahagi ng muling pagdisenyo ng enum. Nagbibigay sila ng algebraic na diskarte sa mga uri, kung saan ang bawat case ay isang hiwalay na constructor na may sariling lagda.

Praktikal na mga halimbawa ng associated values

Associated values ay aktibong ginagamit sa totoong iOS na mga proyekto. Tingnan natin ang tatlong tipikal na sitwasyon.

Pagmomodelo ng mga tugon ng API

enum APIResponse<T: Codable> {
    case success(data: T, cached: Bool)
    case failure(error: Error, retryAvailable: Bool)
    case loading(progress: Double)
}

UI State Machine

enum ViewState<T> {
    case idle
    case loading(message: String)
    case loaded(data: T)
    case error(message: String, retryAction: () -> Void)
}

Sa associated values, ang enum ay nagiging makapangyarihang kasangkapan para sa finite automata: bawat case — isang estado, associated values — mga parameter ng estadong iyon. Ginagarantiyahan ng compiler na ang lahat ng transition ay naproseso.

Pagkuha sa pamamagitan ng if case at guard case

Para sa pagsuri ng isang case nang walang switch gamitin ang if case o guard case. Ito ay mas compact kapag isang variant lamang ang kailangang iproseso.

let error = NetworkError.timeout(seconds: 30)

if case .timeout(let seconds) = error {
    print("Ang kahilingan ay nag-time out pagkatapos ng \(seconds)s")
}

guard case .httpError(let code, _) = error else {
    return
}
print("Error sa HTTP na may code na \(code)")