Enum în Swift — ce este, sintaxa și utilizarea

Ce este enum în Swift?

Enum (enumerare) — este un tip de date definit de utilizator care combină un set finit de variante care se exclud reciproc. În Swift, enum nu este doar constante numerice, ci un tip complet cu propria logică.

Fiecare variantă a enumerării se numește caz. Spre deosebire de Objective-C, unde enum se reduce la un tip întreg, Swift permite fiecărui caz să stocheze propriile date și să aibă metode.

Conform Apple, enum în Swift suportă generice, inițializatoare, proprietăți calculate și implementarea protocoalelor — aceasta îl face aplicabil pentru modelarea stărilor, erorilor, opțiunilor și automatelor finite.

Folosiți enum oriunde este necesar să reprezentați o mulțime finită de variante care se exclud reciproc: stări ale ecranului, tipuri de erori, direcții, opțiuni de filtrare.

Sintaxa declarării enum

Enum se declară cu cuvântul cheie enum urmat de nume și corpul între acolade.

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

Cazurile pot fi declarate pe o singură linie cu virgulă:

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

Pentru a accesa un caz se folosește sintaxa cu punct după tipul cunoscut:

let direction = CompassDirection.north
// Tipul este cunoscut — sintaxa prescurtată este disponibilă:
var currentPlanet = .earth

După atribuirea variabilei unui tip enum cunoscut, Swift deduce automat tipul și se poate omite numele enumerării la accesarea cazurilor.

Raw Values în enumerări

Raw Values — sunt valori de același tip care sunt atribuite fiecărui caz al enum. Spre deosebire de associated values, raw values sunt identice ca tip pentru toate cazurile și se stabilesc la declarare.

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

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

Pentru raw values întregi, Swift incrementează automat valorile dacă doar primul este specificat explicit:

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

Raw values pot fi de tipurile Int, String, Character sau orice tip care se conformează protocolului RawRepresentable. Swift generează automat inițializatorul init? pentru crearea unui enum dintr-o raw value — util la parsarea datelor din API.

Associated Values în enum

Associated Values permit atașarea diferitelor tipuri de date la fiecare caz al enumerării individual. Spre deosebire de raw values, associated values pot diferi ca tip și cantitate.

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

La procesarea prin switch, associated values se extrag prin legarea la variabile sau constante:

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

switch error {
case .timeout(let seconds):
    print("Timeout după \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Fără conexiune")
case .unknown(let err):
    print("Necunoscut: \(err.localizedDescription)")
}

Conform documentației Apple, associated values fac din enum un instrument expresiv pentru modelarea stărilor complexe fără a crea tipuri wrapper separate. Folosiți-le pentru scenarii de tip Result și modelarea erorilor cu context.

Enum recursiv (indirect)

Enum recursiv — enumerare ale cărei cazuri se referă la însuși tipul enum. Astfel de cazuri se marchează cu cuvântul cheie indirect.

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

Cuvântul cheie indirect înainte de enum marchează toate cazurile ca recursive. Alternativ, se poate marca doar un anumit caz cu indirect:

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

Swift folosește indirect pentru a stoca cazurile recursive ca referințe (reference semantics) în loc de valori — aceasta evită dimensiunea infinită a enum pe stivă. Enumerările recursive sunt utilizate pe scară largă la construirea arborilor, listelor înlănțuite și AST.

Enum și protocoale

Enum poate implementa protocoale la fel ca structurile și clasele. Aceasta este o capacitate cheie a programării orientate pe protocoale în 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 poate implementa și protocoale Cocoa — de exemplu, CaseIterable pentru generarea automată a colecției tuturor cazurilor sau Codable pentru serializare. Acest lucru face din enum un bloc de construcție universal în aplicațiile Swift.