Énumérations

Les énumérations - généralement appelées plus simplement "enum" - sont un moyen pour vous de définir votre propre type de valeur dans Swift. Dans certains langages de programmation, ce sont des petites choses toutes simples, mais Swift leur ajoute une énorme puissance si vous voulez aller au-delà des bases.

Commençons par un exemple simple utilisé précédemment :

func getHaterStatus(weather: String) -> String? {
    if weather == "sunny" {
        return nil
    } else {
        return "Hate"
    }
}

Cette fonction accepte une chaîne de caractères qui définit la météo actuelle. Le problème, c'est qu’une chaîne de caractères n'est pas le meilleur choix pour ce type de données - est-ce "pluie", "pluvieux" ou "en train de pleuvoir" ? Ou peut-être "averse", "bruine" ou "orageux" ? Pire encore, si une personne écrit "Pluie" avec un P majuscule et que quelqu'un d'autre écrit "Plie" parce qu'il n'a pas fait attention à ce qu'il a tapé ?

Les enums apportent la solution à ce problème en vous permettant de définir un nouveau type de données, puis de définir les valeurs possibles qu'il peut contenir. Par exemple, on peut dire qu'il y a cinq types de temps : soleil, nuages, pluie, vent et neige. Si nous en faisons une énumération, cela signifie que Swift n'acceptera que ces cinq valeurs. Toute autre valeur déclenchera une erreur. Et en coulisse, les enums ne sont généralement que de simples nombres, beaucoup plus rapides à traîter pour les ordinateurs que les chaînes de caractères.

Mettons cela dans du code :

enum WeatherType {
    case sun, cloud, rain, wind, snow
}

func getHaterStatus(weather: WeatherType) -> String? {
    if weather == WeatherType.sun {
        return nil
    } else {
        return "Hate"
    }
}

getHaterStatus(weather: WeatherType.cloud)

Regardez les trois premières lignes : la ligne 1 donne un nom à notre type de données, WeatherType. C'est ce que vous utiliserez à la place de String ouInt dans votre code. La ligne 2 définit les cinq valeurs possibles que peut contenir notre enum, comme je l'ai déjà exposé. Il est recommandé de faire commencer ces valeurs par une lettre minuscule, ainsi "sun" (soleil), "cloud" (nuage), etc.

Jetons maintenant un coup d'œil à la façon dont la méthode getHaterStatus() est utilisée : j'ai modifié le paramètre weather pour qu'il prenne une valeur de type WeatherType. L'instruction conditionnelle est également réécrite pour être comparée à WeatherType.sun, qui correspond à notre valeur. Rappelez-vous, cette vérification se fait juste sur un nombre en coulisses, ce qui est rapide comme l'éclair.

Maintenant, revenez en arrière et relisez ce code, car je suis sur le point de le réécrire avec deux modifications importantes. C'est fait ?

enum WeatherType {
    case sun
    case cloud
    case rain
    case wind
    case snow
}

func getHaterStatus(weather: WeatherType) -> String? {
    if weather == .sun {
        return nil
    } else {
        return "Hate"
    }
}

getHaterStatus(weather: .cloud)

J'ai fait deux modifications. Premièrement, chaque valeur définissant un type de temps est maintenant sur sa propre ligne. Cela peut sembler n'être qu'un petit changement, et en fait ça l'est dans cet exemple, mais ça deviendra important très bientôt. Le deuxième changement est que j'ai écrit if weather == .sun - je n'ai pas eu besoin de préciser que je voulais dire WeatherType.sun car Swift sait que je compare par rapport à une variable de type WeatherType, en déduisant le type de données.

Les énumérations sont particulièrement utiles pour les blocs switch/case, notamment parce que Swift connaît toutes les valeurs que votre énumération peut avoir et s'assurer que vous les couvrirez toutes. Nous pouvons par exemple essayer de réécrire la méthode getHaterStatus() comme ceci :

func getHaterStatus(weather: WeatherType) -> String? {
    switch weather {
    case .sun:
        return nil
    case .cloud, .wind:
        return "dislike"
    case .rain:
        return "hate"
    }
}

Enums avec des valeurs supplémentaires

L'une des fonctionnalités les plus puissantes de Swift est que les énumérations peuvent avoir des valeurs que vous définissez. Pour prolonger un peu plus notre exemple, je vais ajouter une valeur au cas .wind afin que nous puissions dire à quelle vitesse le vent souffle. Modifiez votre code comme ceci :

enum WeatherType {
    case sun
    case cloud
    case rain
    case wind(speed: Int)
    case snow
}

Comme vous pouvez le constater, les autres cas n’ont pas besoin de vitesse - j’ai simplement mis cela dans "wind" (vent). Passons maintenant à la vraie magie : Swift nous permet d’ajouter des conditions supplémentaires au bloc switch/case afin qu’un case ne corresponde que si ces conditions sont vraies. Il faut utiliser le mot-clé let pour accéder à la valeur dans un case, puis le mot-clé where pour définir la condition.

Voici la nouvelle fonction :

func getHaterStatus(weather: WeatherType) -> String? {
    switch weather {
    case .sun:
        return nil
    case .wind(let speed) where speed < 10:
        return "meh"
    case .cloud, .wind:
        return "dislike"
    case .rain, .snow:
        return "hate"
    }
}

getHaterStatus(weather: WeatherType.wind(speed: 5))

Vous pouvez voir que .wind y apparaît deux fois, mais la première fois n’est vrai que si le vent est inférieur à 10 kilomètres heure. Si le vent est de 10 ou plus, cela ne correspondra pas. La clé, c'est que vous utilisez let pour obtenir la valeur à l'intérieur de l'énumération (c'est-à-dire pour déclarer un nom de constante que vous pouvez utiliser), puis utilisez where pour vérifier une condition.

Swift évalue switch/case de haut en bas et s’arrête dès qu’il trouve une condition vraie. Cela signifie que si case .cloud, .wind: apparaît avant case .wind(let speed) where speed < 10:, il sera exécuté à la place - et la valeur retournée sera différente.

Alors, réfléchissez bien à l'ordre des cases !

Astuce : Les optionnels de Swift sont en fait implémentés en utilisant des énumérations avec des valeurs associées. Il y a deux cas : none et some, avec some ayant n'importe quelle valeur à l'intérieur de l'optionnel.