Enum en Swift — ce que c'est, syntaxe et utilisation

Qu'est-ce qu'un enum en Swift ?

Enum (énumération) est un type de données personnalisé qui regroupe un ensemble fini de variantes mutuellement exclusives. En Swift, enum n'est pas simplement des constantes numériques, mais un type à part entière avec sa propre logique.

Chaque variante de l'énumération est appelée un cas. Contrairement à Objective-C, où enum se réduit à un type entier, Swift permet à chaque cas de stocker ses propres données et d'avoir des méthodes.

Selon Apple, enum en Swift prend en charge les génériques, les initialiseurs, les propriétés calculées et la conformité aux protocoles — ce qui le rend applicable pour modéliser des états, des erreurs, des options et des machines à états finis.

Utilisez enum partout où vous devez représenter un ensemble fini de variantes mutuellement exclusives : états d'écran, types d'erreur, directions, options de filtrage.

Syntaxe de déclaration d'enum

Enum se déclare avec le mot-clé enum suivi d'un nom et d'un corps entre accolades.

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

Les cas peuvent être déclarés sur une seule ligne séparés par une virgule :

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

Pour accéder à un cas, utilisez la syntaxe pointée après le type connu :

let direction = CompassDirection.north
// Type connu — syntaxe abrégée disponible :
var currentPlanet = .earth

Une fois qu'une variable se voit attribuer un type enum connu, Swift déduit automatiquement le type, permettant d'omettre le nom de l'énumération lors de l'accès aux cas.

Raw Values dans les énumérations

Raw Values sont des valeurs d'un seul type attribuées à chaque cas d'enum. Contrairement aux associated values, les raw values sont du même type pour tous les cas et sont définies au moment de la déclaration.

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

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

Pour les raw values entières, Swift incrémente automatiquement les valeurs si seule la première est définie explicitement :

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

Les raw values peuvent être de types Int, String, Character ou tout type conforme au protocole RawRepresentable. Swift génère automatiquement l'initialiseur init? pour créer un enum à partir d'une raw value — pratique pour analyser des données provenant d'API.

Associated Values dans enum

Associated Values permettent de lier différents types de données à chaque cas d'enum individuellement. Contrairement aux raw values, les associated values peuvent différer en type et en quantité.

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

Lors du traitement avec switch, les associated values sont extraites via la liaison à des variables ou constantes :

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

switch error {
case .timeout(let seconds):
    print("Délai d'attente dépassé après \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Pas de connexion")
case .unknown(let err):
    print("Inconnu : \(err.localizedDescription)")
}

Selon la documentation Apple, les associated values font d'enum un outil expressif pour modéliser des états complexes sans créer de types wrapper séparés. Utilisez-les pour des scénarios de type Result et la modélisation d'erreurs avec contexte.

Enum récursif (indirect)

Enum récursif — une énumération dont les cas référencent le type enum lui-même. Ces cas sont marqués avec le mot-clé indirect.

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

Utiliser indirect avant enum marque tous les cas comme récursifs. Sinon, vous pouvez marquer uniquement un cas spécifique avec indirect :

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

Swift utilise indirect pour stocker les cas récursifs comme des références (sémantique de référence) au lieu de valeurs — cela évite une taille infinie de l'enum sur la pile. Les enums récursifs sont largement utilisés dans la construction d'arbres, de listes chaînées et d'AST.

Enum et protocoles

Enum peut être conforme aux protocoles tout comme les structures et les classes. C'est une fonctionnalité clé de la programmation orientée protocole en 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 peut également être conforme aux protocoles Cocoa — par exemple, CaseIterable pour la génération automatique d'une collection de tous les cas, ou Codable pour la sérialisation. Cela fait d'enum un élément de construction polyvalent dans les applications Swift.