Les enum

La clé pour organiser vos données qui ont un nombre de cas bien défini.

Les énumérations, ou enums, en Swift sont des types de données qui permettent de définir un groupe de valeurs liées sous un même type. Les enums en Swift sont très puissantes et peuvent contenir non seulement des valeurs mais aussi des méthodes, des propriétés, et des fonctionnalités associées. Elles sont utilisées pour représenter un ensemble fixe de valeurs qui sont généralement des choix ou des états.

1. Définition de Base

Une énumération de base en Swift est définie avec le mot-clé enum suivi du nom de l'enum. Chaque valeur possible de l'enum est appelée un membre de l'enum.

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

let direction = CompassDirection.north

2. Valeurs Associées

Les enums peuvent avoir des valeurs associées, ce qui permet de stocker des informations supplémentaires avec chaque valeur de l'enum. Les valeurs associées sont définies lors de l'initialisation de l'enum.

enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}

var productBarcode = Barcode.upc(8, 85909, 51226, 3)
productBarcode = .qrCode("HELLO123")

3. Raw Values (Valeurs Brutes)

Les enums en Swift peuvent aussi utiliser des valeurs brutes (raw values) pour chaque membre. Les valeurs brutes doivent être toutes du même type, comme Int, String, ou d'autres types primitifs. Swift fournit automatiquement une valeur brute par défaut lors de l'initialisation si les valeurs brutes sont spécifiées.

enum Planet: Int {
    case mercury = 1
    case venus
    case earth
    case mars
    case jupiter
    case saturn
    case uranus
    case neptune
}

let earthOrder = Planet.earth.rawValue
print("La Terre est la \(earthOrder)ème planète.")  // Affiche : "La Terre est la 3ème planète."

4. Initialisation avec Valeurs Brutes

Vous pouvez initialiser une instance d'une enum avec une valeur brute en utilisant un initialiseur failable (init?), qui retourne nil si la valeur brute n'existe pas dans l'enum.

if let planet = Planet(rawValue: 3) {
    print("La planète est \(planet).")  // Affiche : "La planète est earth."
} else {
    print("Valeur brute invalide.")
}

5. Méthodes et Propriétés dans les Enums

Les enums en Swift peuvent également contenir des méthodes et des propriétés. Cela permet de rajouter des comportements associés à chaque valeur de l'enum.

enum Vehicle {
    case car(model: String, year: Int)
    case bike(type: String)

    func description() -> String {
        switch self {
        case .car(let model, let year):
            return "Voiture: \(model), \(year)"
        case .bike(let type):
            return "Vélo: \(type)"
        }
    }
}

let myCar = Vehicle.car(model: "Toyota Corolla", year: 2022)
print(myCar.description())  // Affiche : "Voiture: Toyota Corolla, 2022"

6. Enums avec Associated Values et Switch

Les enums avec valeurs associées sont souvent utilisés avec les instructions switch pour gérer différentes valeurs et états de manière sûre et structurée. Cela permet de traiter chaque cas de manière spécifique.

enum Result {
    case success(T)
    case failure(Error)
}

func handleResult(result: Result) {
    switch result {
    case .success(let value):
        print("Succès avec la valeur : \(value)")
    case .failure(let error):
        print("Échec avec l'erreur : \(error.localizedDescription)")
    }
}

enum MyError: Error {
    case networkError
    case dataNotFound
}

let successResult = Result.success("Données chargées avec succès.")
let failureResult = Result.failure(MyError.networkError)

handleResult(result: successResult)  // Affiche : "Succès avec la valeur : Données chargées avec succès."
handleResult(result: failureResult)  // Affiche : "Échec avec l'erreur : The network error occurred"

7. Énumérations et Protocoles

Les enums peuvent adopter des protocoles pour garantir qu'ils implémentent certaines méthodes ou propriétés. Cela permet aux enums d'intégrer des comportements spécifiques requis par le protocole.

protocol Describable {
    var description: String { get }
}

enum Weather: Describable {
    case sunny
    case cloudy
    case rainy

    var description: String {
        switch self {
        case .sunny:
            return "Ensoleillé"
        case .cloudy:
            return "Nuageux"
        case .rainy:
            return "Pluvieux"
        }
    }
}

let currentWeather = Weather.sunny
print(currentWeather.description)  // Affiche : "Ensoleillé"

8. Enumérations et Optionals

Les enums sont souvent utilisés pour représenter des valeurs optionnelles, en utilisant Optional qui est un enum intégré en Swift avec deux cas : some (contenant une valeur) et none (absence de valeur).

var name: String? = "Alice"
if let unwrappedName = name {
    print("Nom : \(unwrappedName)")
} else {
    print("Pas de nom.")
}