Enum ve Swiftu — co to je, syntaxe a použití

Co je enum ve Swiftu?

Enum (výčet) — je uživatelsky definovaný datový typ, který spojuje konečnou sadu vzájemně se vylučujících variant. Ve Swiftu enum není jen numerické konstanty, ale plnohodnotný typ s vlastní logikou.

Každá varianta výčtu se nazývá případ. Na rozdíl od Objective-C, kde je enum redukován na celočíselný typ, Swift umožňuje každému případu ukládat vlastní data a mít metody.

Podle Apple enum ve Swiftu podporuje generika, inicializátory, vypočítávané vlastnosti a implementaci protokolů — to ho činí použitelným pro modelování stavů, chyb, možností a konečných automatů.

Používejte enum všude, kde potřebujete reprezentovat konečnou množinu vzájemně se vylučujících variant: stavy obrazovky, typy chyb, směry, možnosti filtrování.

Syntaxe deklarace enum

Enum se deklaruje klíčovým slovem enum následovaným názvem a tělem ve složených závorkách.

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

Případy lze deklarovat na jednom řádku s čárkou:

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

Pro přístup k případu se používá tečková notace za známým typem:

let direction = CompassDirection.north
// Typ je znám — zkrácená syntaxe je k dispozici:
var currentPlanet = .earth

Po přiřazení proměnné známého typu enum Swift automaticky odvodí typ a název výčtu lze při přístupu k případům vynechat.

Raw Values ve výčtech

Raw Values — jsou hodnoty stejného typu, které jsou přiřazeny každému případu enum. Na rozdíl od associated values jsou raw values typově stejné pro všechny případy a nastavují se při deklaraci.

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

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

Pro celočíselné raw values Swift automaticky inkrementuje hodnoty, pokud je explicitně zadán pouze první:

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

Raw values mohou být typů Int, String, Character nebo jakéhokoli typu vyhovujícího protokolu RawRepresentable. Swift automaticky generuje inicializátor init? pro vytvoření enum z raw value — to je užitečné při parsování dat z API.

Associated Values v enum

Associated Values umožňují připojit různé datové typy ke každému případu výčtu jednotlivě. Na rozdíl od raw values se associated values mohou lišit typem i množstvím.

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

Při zpracování přes switch jsou associated values extrahovány vázáním na proměnné nebo konstanty:

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

switch error {
case .timeout(let seconds):
    print("Časový limit po \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Žádné připojení")
case .unknown(let err):
    print("Neznámý: \(err.localizedDescription)")
}

Podle dokumentace Apple dělají associated values z enumu expresivní nástroj pro modelování složitých stavů bez vytváření samostatných obalových typů. Používejte je pro scénáře podobné Result a modelování chyb s kontextem.

Rekurzivní enum (indirect)

Rekurzivní enum — výčet, jehož případy odkazují na samotný typ enum. Takové případy se označují klíčovým slovem indirect.

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

Klíčové slovo indirect před enum označuje všechny případy jako rekurzivní. Alternativně lze označit indirect pouze konkrétní případ:

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

Swift používá indirect k ukládání rekurzivních případů jako referencí (reference semantics) místo hodnot — to zabraňuje nekonečné velikosti enum na zásobníku. Rekurzivní enumy jsou široce používány při vytváření stromů, lineárních seznamů a AST.

Enum a protokoly

Enum může implementovat protokoly stejně jako struktury a třídy. To je klíčová schopnost protokolově orientovaného programování ve Swiftu.

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 také může implementovat Cocoa protokoly — například CaseIterable pro automatické generování kolekce všech případů nebo Codable pro serializaci. To činí z enumu univerzální stavební blok ve Swift aplikacích.