Enum i Swift — vad är det, syntax och användning

Vad är enum i Swift?

Enum (uppräkning) — är en användardefinierad datatyp som kombinerar en ändlig uppsättning ömsesidigt uteslutande varianter. I Swift är enum inte bara numeriska konstanter, utan en fullvärdig typ med egen logik.

Varje variant av uppräkningen kallas case. Till skillnad från Objective-C, där enum reduceras till en heltalstyp, tillåter Swift varje case att lagra egna data och ha metoder.

Enligt Apple stöder enum i Swift generics, initierare, beräknade egenskaper och implementering av protokoll — detta gör det tillämpbart för modellering av tillstånd, fel, alternativ och ändliga tillståndsmaskiner.

Använd enum överallt där du behöver representera en ändlig mängd ömsesidigt uteslutande varianter: skärmtillstånd, feltyper, riktningar, filtreringsalternativ.

Syntax för enum-deklaration

Enum deklareras med nyckelordet enum följt av namn och kropp i klammerparenteser.

enum CompassDirection {
    case north
    case south
    case east
    case west
}

Case kan deklareras på en rad med komma:

enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

För att nå ett case används punktnotation efter den kända typen:

let direction = CompassDirection.north
// Typen är känd — förkortad syntax finns tillgänglig:
var currentPlanet = .earth

Efter tilldelning till en variabel av känd enum-typ, Swift härleder automatiskt typen och namnet på uppräkningen kan utelämnas när case nås.

Raw Values i uppräkningar

Raw Values — är värden av samma typ som tilldelas varje case i enum. Till skillnad från associated values är raw values identiska i typ för alla case och ställs in vid deklaration.

enum HTTPStatusCode: Int {
    case ok = 200
    case notFound = 404
    case internalServerError = 500
}

let code = HTTPStatusCode.notFound
print(code.rawValue) // 404

För heltals raw values ökar Swift automatiskt värdena om endast det första är explicit angivet:

enum Status: Int {
    case pending = 1
    case active      // 2
    case completed   // 3
}

Raw values kan vara av typerna Int, String, Character eller vilken typ som helst som följer protokollet RawRepresentable. Swift genererar automatiskt initieraren init? för att skapa enum från raw value — detta är praktiskt vid tolkning av API-data.

Associated Values i enum

Associated Values gör det möjligt att koppla olika datatyper till varje case i uppräkningen individuellt. Till skillnad från raw values kan associated values skilja sig i typ och antal.

enum NetworkError {
    case timeout(seconds: Int)
    case httpError(code: Int, message: String)
    case noConnection
    case unknown(error: Error)
}

Vid bearbetning genom switch extraheras associated values genom bindning till variabler eller konstanter:

let error = NetworkError.httpError(code: 403, message: "Forbidden")

switch error {
case .timeout(let seconds):
    print("Timeout efter \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Ingen anslutning")
case .unknown(let err):
    print("Okänd: \(err.localizedDescription)")
}

Enligt Apples dokumentation gör associated values enum till ett uttrycksfullt verktyg för att modellera komplexa tillstånd utan att skapa separata wrapper-typer. Använd dem för Result-liknande scenarier och modellering av fel med kontext.

Rekursiv enum (indirect)

Rekursiv enum — uppräkning vars case hänvisar till själva enum-typen. Sådana case markeras med nyckelordet indirect.

indirect enum LinkedList<T> {
    case empty
    case node(value: T, next: LinkedList<T>)
}

Nyckelordet indirect före enum markerar alla case som rekursiva. Alternativt kan endast ett specifikt case markeras med indirect:

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

Swift använder indirect för att lagra rekursiva case som referenser (reference semantics) istället för värden — detta undviker oändlig storlek på enum på stacken. Rekursiva enum används i stor utsträckning vid konstruktion av träd, länkade listor och AST.

Enum och protokoll

Enum kan implementera protokoll precis som strukturer och klasser. Detta är en viktig funktion i protokollorienterad programmering i Swift.

protocol Describable {
    var description: String { get }
}

enum PaymentMethod: Describable {
    case creditCard(last4: String)
    case applePay
    case bankTransfer

    var description: String {
        switch self {
        case .creditCard(let last4):
            return "Card ending in \(last4)"
        case .applePay:
            return "Apple Pay"
        case .bankTransfer:
            return "Bank Transfer"
        }
    }
}

Enum kan också implementera Cocoa-protokoll — till exempel CaseIterable för automatisk generering av samling av alla case eller Codable för serialisering. Detta gör enum till en universell byggsten i Swift-applikationer.