Enum w Swift — co to jest, składnia i użycie

Co to jest enum w Swift?

Enum (wyliczenie) — to użytkowniczy typ danych, który łączy skończony zestaw wzajemnie wykluczających się wariantów. W Swift enum to nie tylko stałe numeryczne, ale pełnoprawny typ z własną logiką.

Każdy wariant wyliczenia nazywa się case'em. W przeciwieństwie do Objective-C, gdzie enum sprowadza się do typu całkowitoliczbowego, Swift pozwala każdemu case'owi przechowywać własne dane i mieć metody.

Według danych Apple, enum w Swift wspiera generyki, inicjalizatory, właściwości obliczane i implementację protokołów — czyni to go przydatnym do modelowania stanów, błędów, opcji i automatów skończonych.

Używaj enum wszędzie, gdzie trzeba przedstawić skończony zbiór wzajemnie wykluczających się wariantów: stany ekranu, typy błędów, kierunki, opcje filtrowania.

Składnia deklaracji enum

Enum deklaruje się słowem kluczowym enum z następującą nazwą i ciałem w nawiasach klamrowych.

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

Case'y można deklarować w jednej linii przez przecinek:

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

Do odwołania się do case'a używa się składni kropkowej po znanym typie:

let direction = CompassDirection.north
// Typ jest znany — dostępna jest skrócona składnia:
var currentPlanet = .earth

Po przypisaniu zmiennej znanego typu enum Swift automatycznie wnioskuje typ i można pominąć nazwę wyliczenia przy odwoływaniu się do case'ów.

Raw Values w wyliczeniach

Raw Values — to wartości jednego typu, które są przypisywane każdemu case'owi enum. W przeciwieństwie do associated values, raw values są jednakowe pod względem typu dla wszystkich case'ów i są określane przy deklaracji.

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

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

Dla całkowitoliczbowych raw values Swift automatycznie inkrementuje wartości, jeśli jawnie określono tylko pierwszy:

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

Raw values mogą być typów Int, String, Character lub dowolnego typu zgodnego z protokołem RawRepresentable. Swift automatycznie generuje inicjalizator init? do tworzenia enum z raw value — jest to wygodne przy parsowaniu danych z API.

Associated Values w enum

Associated Values pozwalają przypisać różne typy danych do każdego case'a wyliczenia indywidualnie. W przeciwieństwie do raw values, associated values mogą różnić się typem i ilością.

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

Przy przetwarzaniu przez switch associated values są wyodrębniane poprzez powiązanie ze zmiennymi lub stałymi:

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

switch error {
case .timeout(let seconds):
    print("Przekroczenie czasu po \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Brak połączenia")
case .unknown(let err):
    print("Nieznany: \(err.localizedDescription)")
}

Według danych dokumentacji Apple, associated values czynią enum wyrazistym narzędziem do modelowania złożonych stanów bez tworzenia osobnych typów-opakowań. Używaj ich do scenariuszy Result-podobnych i modelowania błędów z kontekstem.

Rekurencyjne enum (indirect)

Rekurencyjne enum — wyliczenie, którego case'y odnoszą się do samego typu enum. Takie case'y oznacza się słowem kluczowym indirect.

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

Słowo kluczowe indirect przed enum oznacza wszystkie case'y jako rekurencyjne. Alternatywnie można oznaczyć indirect tylko konkretny case:

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

Swift używa indirect do przechowywania rekurencyjnych case'ów jako referencji (reference semantics) zamiast wartości — pozwala to uniknąć nieskończonego rozmiaru enum na stosie. Rekurencyjne enum są szeroko stosowane przy budowaniu drzew, list połączonych i AST.

Enum i protokoły

Enum może implementować protokoły tak samo jak struktury i klasy. To kluczowa możliwość programowania zorientowanego protokołowo w 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 może również implementować protokoły Cocoa — na przykład CaseIterable do automatycznego generowania kolekcji wszystkich case'ów lub Codable do serializacji. To czyni enum uniwersalnym blokiem budulcowym w aplikacjach Swift.