Enum

Enum

Comme son nom l’indique, un enum permet d’énumérer des cas. Ça fonctionne un peu comme une struct dans le sens où c’est un type que tu crées sur mesure, mais avec une différence importante : un enum regroupe des valeurs fixes que tu définis à l’avance. On l’utilise souvent pour catégoriser des données : par exemple, des familles de catégories pour une donnée spécifique, des types d’erreurs, ou d’autres ensembles limités de choix. C’est une notion très simple à comprendre, et elle te sera très utile pour organiser et sécuriser ton code.

Introduction

enum House {
    case Gryffondor, Poufsouffle, Serdaigle, Serpentard
}

var studentHouse: House = .Gryffondor

switch studentHouse {
case .Gryffondor:
    print("Bienvenue à Gryffondor!")
case .Poufsouffle:
    print("Bienvenue à Poufsouffle!")
case .Serdaigle:
    print("Bienvenue à Serdaigle!")
case .Serpentard:
    print("Bienvenue à Serpentard!")
}

Lecture dans la console ->
Bienvenue à Gryffondor!

Ici, House est une énumération qui a quatre valeurs possibles :  .Gryffondor, .Poufsouffle, .Serdaigle, et .Serpentard.

Maintenant, supposons que tu veux stocker la maison d’un étudiant. Tu peux créer une variable de type House et lui attribuer une des valeurs de l’énumération.

Pour agir en fonction de la maison de l’étudiant, tu peux utiliser une instruction switch qui teste toutes les valeurs possibles de l’énumération. Ce code vérifie la valeur de studentHouse et affiche un message de bienvenue en fonction de la maison.

  Itération

enum House: CaseIterable {
    case Gryffondor, Poufsouffle, Serdaigle, Serpentard
}

for house in House.allCases {
    print(house)
}

 Valeurs associées

enum WizardAction {
    case castSpell(spellName: String)
    case earnHousePoints(points: Int, house: House)
    case visitPlace(place: String)
    case useObject(object: String)
}

let harryAction = WizardAction.castSpell(spellName: "Expelliarmus")
let hermioneAction = WizardAction.earnHousePoints(points: 10, house: .Gryffondor)
let ronAction = WizardAction.visitPlace(place: "La Chambre des Secrets")
let malfoyAction = WizardAction.useObject(object: "Retourneur de Temps")

Valeur brute

enum House: String {
    case Gryffondor = "🦁"
    case Poufsouffle = "🦡"
    case Serdaigle = "🦅"
    case Serpentard = "🐍"
}

let gryffondorBadge = House.Gryffondor.rawValue
print(gryffondorBadge) 

Les énumérations peuvent avoir des valeurs brutes raw values. Les valeurs brutes sont des valeurs prédéfinies que chaque cas d’énumération peut avoir, comme des chaînes de caractères, des nombres ou des caractères. Elles permettent d’assigner des valeurs spécifiques à chaque cas de l’énumération.

 Enumération imbriquées

enum Character {
    enum House {
        case Gryffondor, Poufsouffle, Serdaigle, Serpentard
    }
    enum Role {
        case student, teacher, headmaster
    }
}

struct Wizard {
    let name: String
    let house: Character.House
    let role: Character.Role
}

let harry = Wizard(name: "Harry Potter", house: .Gryffondor, role: .student)
let dumbledore = Wizard(name: "Albus Dumbledore", house: .Gryffondor, role: .headmaster)
let snape = Wizard(name: "Severus Snape", house: .Serpentard, role: .teacher)
let luna = Wizard(name: "Luna Lovegood", house: .Serdaigle, role: .student)