Associated Values i Swift: vad är det, syntax och exempel

Vad är Associated Values?

Associated Values — är ytterligare information som ett enum-case kan lagra tillsammans med sig själv. Till skillnad från raw values, som är fasta på deklarationsnivå, bestäms associated values när en enum-instans skapas.

Föreställ dig modellering av en betalningsmetod: case creditCard kan lagra de sista 4 siffrorna och utgångsdatumet, och case applePay — ingenting. Med associated values implementeras detta naturligt, utan underklasser eller valfria fält.

Enligt Apples dokumentation omvandlar associated values enum från en enkel uppsättning konstanter till en algebraisk datatyp (sum type), karakteristisk för funktionella språk. Detta ökar kodens uttrycksfullhet avsevärt.

Syntax för associated values

Associated values deklareras inom parentes efter case, med angivande av parameternamn och typer, som i funktioner.

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

När en instans skapas skickas associated values som argument:

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

Swift lägger inga begränsningar på antalet eller typerna av associated values. Du kan använda generics, closure-funktioner och andra enum inom associated values. Detta gör det möjligt att bygga komplexa nästlade strukturer.

Parameternamnen för associated values används som argumentetiketter när en instans skapas — detta förbättrar kodens läsbarhet. Vid extraktion via switch fungerar namnen som dokumentation och förklarar innebörden av varje värde. Ett sådant tillvägagångssätt gör koden självdokumenterande och minskar sannolikheten för fel vid datamatchning. Detta är särskilt värdefullt vid teamutveckling av stora iOS-applikationer.

Switch med associated values

Switch — det huvudsakliga sättet att extrahera associated values. Värden binds till konstanter eller variabler via let eller 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"
    }
}

Swift stöder delvis matchning — specifika värden för associated values kan anges:

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

Användning av wildcard (_) gör det möjligt att ignorera onödiga associated values, och konstanter i case — att kontrollera överensstämmelse med specifika värden.

Associated Values vs Raw Values

Många nybörjarutvecklare förväxlar associated values med raw values. Det är olika mekanismer med olika användningsscenarier.

Enligt Swift Evolution introducerades associated values i Swift 2.0 som en del av omdesignen av enum. De ger ett algebraiskt förhållningssätt till typer, där varje case är en separat konstruktor med egen signatur.

Praktiska exempel på associated values

Associated values används aktivt i verkliga iOS-projekt. Låt oss titta på tre typiska scenarier.

Modellering av API-svar

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)
}

Med associated values blir enum ett kraftfullt verktyg för finita automater: varje case — ett tillstånd, associated values — parametrarna för det tillståndet. Kompilatorn garanterar att alla övergångar bearbetas.

Extraktion via if case och guard case

För att kontrollera ett enskilt case utan switch använd if case eller guard case. Det är mer kompakt när endast en variant behöver bearbetas.

let error = NetworkError.timeout(seconds: 30)

if case .timeout(let seconds) = error {
    print("Begäran tog timeout efter \(seconds)s")
}

guard case .httpError(let code, _) = error else {
    return
}
print("HTTP-fel med kod \(code)")