Enum a Swift-ben — mi ez, szintaxis és használat

Mi az enum a Swift-ben?

Enum (felsorolás) — egy felhasználó által definiált adattípus, amely véges, egymást kizáró variánsok halmazát egyesíti. A Swift-ben az enum nem csak numerikus konstans, hanem teljes értékű típus saját logikával.

A felsorolás minden variánsát esetnek (case) nevezzük. Ellentétben az Objective-C-vel, ahol az enum egy egész típusra redukálódik, a Swift lehetővé teszi, hogy minden eset saját adatokat tároljon és metódusokkal rendelkezzen.

Az Apple szerint az enum a Swift-ben támogatja a generikusokat, inicializálókat, számított tulajdonságokat és protokollok implementációját — ez alkalmassá teszi állapotok, hibák, opciók és véges automaták modellezésére.

Használja az enum-ot mindenhol, ahol véges halmazt kell reprezentálni egymást kizáró variánsokból: képernyőállapotok, hibatípusok, irányok, szűrési opciók.

Az enum deklarálásának szintaxisa

Enum deklarálása a enum kulcsszóval történik, amelyet a név és a kapcsos zárójelekben lévő törzs követ.

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

Az esetek egy sorban is deklarálhatók vesszővel elválasztva:

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

Egy eset eléréséhez pont szintaxis használatos az ismert típus után:

let direction = CompassDirection.north
// A típus ismert — a rövidített szintaxis elérhető:
var currentPlanet = .earth

Miután hozzárendeltük egy ismert enum típusú változóhoz, a Swift automatikusan kikövetkezteti a típust, és a felsorolás neve elhagyható az esetek elérésekor.

Raw Values a felsorolásokban

Raw Values — egy típusú értékek, amelyek az enum minden esetéhez hozzá vannak rendelve. Ellentétben az associated values-szel, a raw values típusa azonos minden esetnél és deklaráláskor kerül beállításra.

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

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

Egész raw values esetén a Swift automatikusan növeli az értékeket, ha csak az első van explicit módon megadva:

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

A raw values lehetnek Int, String, Character vagy bármilyen típus, amely megfelel a RawRepresentable protokollnak. A Swift automatikusan létrehozza az init? inicializálót az enum raw value-ból történő létrehozásához — ez hasznos API adatok feldolgozásakor.

Associated Values az enum-ban

Associated Values lehetővé teszik különböző adattípusok hozzárendelését a felsorolás minden esetéhez egyedileg. Ellentétben a raw values-szel, az associated values típusban és mennyiségben is eltérhetnek.

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

Switch segítségével történő feldolgozáskor az associated values változókhoz vagy konstansokhoz kötéssel kerülnek kinyerésre:

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

switch error {
case .timeout(let seconds):
    print("Időtúllépés \(seconds)s után")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Nincs kapcsolat")
case .unknown(let err):
    print("Ismeretlen: \(err.localizedDescription)")
}

Az Apple dokumentáció szerint az associated values az enum-ot kifejező eszközzé teszi összetett állapotok modellezéséhez anélkül, hogy külön wrapper típusokat kellene létrehozni. Használja őket Result-szerű forgatókönyvekhez és hibák kontextussal történő modellezéséhez.

Rekurzív enum (indirect)

Rekurzív enum — olyan felsorolás, amelynek esetei magára az enum típusra hivatkoznak. Az ilyen esetek az indirect kulcsszóval vannak megjelölve.

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

Az indirect kulcsszó az enum előtt az összes esetet rekurzívként jelöli meg. Alternatívaként csak egy adott eset jelölhető meg indirect-tel:

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

A Swift az indirect használja a rekurzív esetek referenciákként (reference semantics) történő tárolására értékek helyett — ez elkerüli az enum végtelen méretét a veremben. A rekurzív enum-okat széles körben használják fák, láncolt listák és AST építésénél.

Enum és protokollok

Enum implementálhat protokollokat ugyanúgy, mint a struktúrák és osztályok. Ez a protokoll-orientált programozás egyik kulcsképessége a Swift-ben.

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

Az enum implementálhat Cocoa protokollokat is — például CaseIterable az összes eset gyűjteményének automatikus létrehozásához vagy Codable a szerializációhoz. Ez az enum-ot univerzális építőelemvé teszi a Swift alkalmazásokban.