Enum in Swift — was es ist, Syntax und Verwendung

Was ist enum in Swift?

Enum (Aufzählung) ist ein benutzerdefinierter Datentyp, der eine endliche Menge sich gegenseitig ausschließender Varianten vereint. In Swift ist enum nicht nur ein numerischer Konstantensatz, sondern ein vollwertiger Typ mit eigener Logik.

Jede Variante einer Aufzählung wird als Fall bezeichnet. Anders als in Objective-C, wo enum auf einen Integer-Typ reduziert wird, erlaubt Swift jedem Fall, eigene Daten zu speichern und Methoden zu haben.

Laut Apple unterstützt enum in Swift Generics, Initialisierer, berechnete Eigenschaften und Protokollkonformität — was es für die Modellierung von Zuständen, Fehlern, Optionen und endlichen Zustandsmaschinen anwendbar macht.

Verwenden Sie enum überall dort, wo Sie eine endliche Menge sich gegenseitig ausschließender Varianten darstellen müssen: Bildschirmzustände, Fehlertypen, Richtungen, Filteroptionen.

Syntax der Enum-Deklaration

Enum wird mit dem Schlüsselwort enum gefolgt von einem Namen und einem Körper in geschweiften Klammern deklariert.

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

Fälle können in einer einzigen Zeile, durch Komma getrennt, deklariert werden:

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

Um auf einen Fall zuzugreifen, verwenden Sie die Punkt-Syntax nach dem bekannten Typ:

let direction = CompassDirection.north
// Typ bekannt — Kurzschreibweise verfügbar:
var currentPlanet = .earth

Sobald einer Variable ein bekannter enum-Typ zugewiesen wurde, leitet Swift den Typ automatisch ab, sodass der Aufzählungsname beim Zugriff auf Fälle weggelassen werden kann.

Raw Values in Aufzählungen

Raw Values sind Werte eines einzigen Typs, die jedem enum-Fall zugewiesen werden. Im Gegensatz zu associated values sind raw values für alle Fälle vom gleichen Typ und werden bei der Deklaration festgelegt.

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

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

Bei ganzzahligen raw values inkrementiert Swift die Werte automatisch, wenn nur der erste explizit gesetzt wurde:

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

Raw values können von den Typen Int, String, Character oder jedem Typ sein, der dem Protokoll RawRepresentable entspricht. Swift generiert automatisch den Initialisierer init?, um einen enum aus einem raw value zu erstellen — praktisch zum Parsen von Daten aus APIs.

Associated Values in enum

Associated Values ermöglichen es, jedem enum-Fall individuell unterschiedliche Datentypen zuzuordnen. Anders als raw values können sich associated values in Typ und Anzahl unterscheiden.

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

Bei der Verarbeitung mit switch werden associated values durch Bindung an Variablen oder Konstanten extrahiert:

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

switch error {
case .timeout(let seconds):
    print("Zeitüberschreitung nach \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Keine Verbindung")
case .unknown(let err):
    print("Unbekannt: \(err.localizedDescription)")
}

Laut Apple-Dokumentation machen associated values enum zu einem ausdrucksstarken Werkzeug für die Modellierung komplexer Zustände, ohne separate Wrapper-Typen erstellen zu müssen. Verwenden Sie sie für Result-ähnliche Szenarien und die Modellierung von Fehlern mit Kontext.

Rekursive Enum (indirect)

Rekursive Enum — eine Aufzählung, deren Fälle auf den enum-Typ selbst verweisen. Solche Fälle werden mit dem Schlüsselwort indirect markiert.

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

Die Verwendung von indirect vor enum markiert alle Fälle als rekursiv. Alternativ kann nur ein bestimmter Fall mit indirect markiert werden:

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

Swift verwendet indirect, um rekursive Fälle als Referenzen (Referenzsemantik) statt als Werte zu speichern — dies verhindert eine unendliche Größe des enum auf dem Stack. Rekursive enums werden häufig beim Erstellen von Bäumen, verketteten Listen und ASTs verwendet.

Enum und Protokolle

Enum kann genau wie Strukturen und Klassen Protokollen entsprechen. Dies ist eine Schlüsselfunktion der protokollorientierten Programmierung in 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 kann auch Cocoa-Protokollen entsprechen — zum Beispiel CaseIterable zur automatischen Generierung einer Sammlung aller Fälle oder Codable zur Serialisierung. Dies macht enum zu einem vielseitigen Baustein in Swift-Anwendungen.