Fil d'Ariane
Mis à jour le vendredi 27 janvier 2017
  • 15 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Ce cours existe en eBook.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Les énumérations

Connectez-vous ou inscrivez-vous pour bénéficier de toutes les fonctionnalités de ce cours !

Une énumération permet de définir un type commun pour une liste de valeurs personnalisées. Par cette méthode, vous travaillerez avec plus de sécurité.

Les valeurs d’une énumération peuvent être de même type ou de type différent, c’est à votre goût. Par exemple, dans la suite de ce chapitre, nous allons créer une énumérationLangage qui comprendra plusieurs valeurs comme : Swift, Java, PHP, C. L’énumération ne pourra donc prendre en compte que ces valeurs, et aucune autre.

Avant les énumérations

Vous aurez sans doute besoin, un jour ou l'autre, de données permettant de savoir ce que vous devez faire.

Prenons un cas pour mieux expliquer :

class AvantEnumeration {

    let PARAMETRE1 = 1
    let PARAMETRE2 = 2

    func fait(parametre: Int) {
        if parametre == PARAMETRE1 {
            print("Fait à la façon numéro 1.")
        }

        if parametre == PARAMETRE2 {
            print("Fait à la façon numéro 2.")
        }
    }
}

J’ai ici créé une nouvelle classeAvantEnumeration. Cette classe dispose de deux attributs : les données sur lesquelles on souhaite interagir. Elle dispose aussi d’une fonction permettant d’exécuter une action selon la donnée que l’on passe en paramètre. Dans cet exemple, on souhaiterait obtenir comme donnée soitPARAMETRE1, soitPARAMETRE2.

Seulement, une erreur subsiste ici. On n'a peut-être que deux attributs dans notre objetAvantEnumeration, mais ce qu’attend comme paramètre à la méthodefait() n’est rien d’autre qu’un nombre de typeInt. On pourrait donc passer autre chose que le nombre 1 ou 2. Et c’est bien ce que l’on ne souhaite pas vu que dans la méthode, on ne traite que le cas avec 1 ou 2.

Écrivez donc ceci dans votre main :

let ae = AvantEnumeration()

ae.fait(parametre: 1)
ae.fait(parametre: 2)
ae.fait(parametre: 4)

Exécutez ce code et constatez le résultat dans la console. La méthode a bien exécuté le cas n°1 et le cas n°2. Mais qu’en est-il du cas n°4 ? C’est un nombre qu’on n’attendait pas, rien n’a donc été exécuté selon la méthode, mais aucune erreur n’est déclenchée non plus par le biais de ce paramètre inattendu. Rien de méchant, soit !

On pourrait résoudre ce problème en créant un nouvel objet. Et cet objet pourrait être demandé en paramètre à la méthode plutôt qu’unInt. C’est tout simplement à cela que servent les énumérations ! Ils vont permettre de créer ce genre d’objet mais de façon beaucoup plus rapide et plus simple surtout.

L’énumération avec enum

La déclaration d’une énumération est similaire à celle d'une classe. On utilise le mot cléenum, on indique le nom de notre énumération et on définit les cas entre accolades. Pour le nom, par convention on choisit un nom singulier qui permettra une lecture plus logique du code, on débute aussi par une majuscule. Voici la syntaxe :

enum NomEnumeration {

    // Liste des différents cas ici

}

Si on prend notre exemple deLangage, on souhaiterait avoir quatre cas que voici :

enum Langage {
    case Swift
    case Java
    case Php
    case C
}

Il est possible de déclarer plusieurs cas sur une même ligne en séparant par des virgules :

enum Langage {
    case Swift, Java, Php, C
}

On utilise donc le mot-clécase pour énumérer les cas possibles. Pour cet exemple, c’est comme si vous aviez un ObjetSwift, un objetJava, un objetPhp et un objetC

Utiliser un enum

Pour l’utilisation, rendez-vous dans votre main. Une variable peut être de type du nom de votre énumération. Swift saura de lui-même déduire le type.

var langageUtilise = Langage.Swift

Une fois le type déduit, il est inutile lors des prochains changement de valeurs de votre variable de spécifier le nom de votre énumération. Par exemple :

var langageUtilise = Langage.Swift

langageUtilise = .Java

// Mais cette façon marche aussi ;)
langageUtilise = Langage.Java

Traiter les cas

Pour connaître la valeur de votre variable, l’utilisation du switch peut s’avérer pratique :

var langageUtilise = Langage.Swift

switch langageUtilise {
    
case .Swift:
    print("J'utilise le langage Swift.")

case .Java:
    print("J'utilise le Java.")

case .Php:
    print("J'utilise le PHP.")

case .C:
    print("J'utilise le C.")
    
}

Dans cet exemple, le switch fonctionne parfaitement. C’est le cas, car vous avez traité tous les cas de votre énumération. Il suffit de volontairement en oublier une pour que le switch ne fonctionne plus. Xcode vous demandera alors de définir le cas par défaut grâce au mot clédefault:

Valeurs associées

Il est parfois utile de pouvoir stocker des valeurs dans chacun de ces cas. Cela permet de stocker des valeurs en plus de votre valeur initiale.

Je m’explique par ce code :

enum Langage {
    case Swift (String, String)
    case Java (String)
    case Php (String)
    case C (String)
}

Par cette déclaration, il vous faudra préciser les valeurs supplémentaires :

var langageUtilise = Langage.Swift("Le langage Swift", "Le langage que vous apprenez dans ce cours")

langageUtilise = .Java("Le langage Java")

À vous de respecter la syntaxe que vous avez fournie. Vous pouvez définir un nombre différent de types à préciser et les types peuvent être différents entre eux. C'est pour ça que j'ai précisé deuxStringpour le cas Swift, et un seul pour les autres cas. Vous êtes libres de choisir. On aurait très bien pu avoir :

enum Langage {
    case Swift (String, String)
    case Java (Int)
    case Php (Float, Float, Float)
    case C (String)
}

Pour traiter les cas, le précédent code avec le switch ne pourra plus fonctionner. Néanmoins, on va pouvoir extraire les données que l’on souhaite et profiter de la puissance de l’énumération :

var langageUtilise = Langage.Swift("Le langage Swift.", "Le langage que vous apprenez dans ce cours.")

langageUtilise = .Java("Le langage Java.")

switch langageUtilise {

case let .Swift(descriptionLangage, langageDuCours):
    print(descriptionLangage + " " + langageDuCours)

case var .Java(descriptionLangage):
    print(descriptionLangage)

default:
    print("Je n'ai pas traité les autres cas")
    
}

Cette fois-ci, après lecase, on précise si on souhaite extraire les données sous forme de constantes ou de variables. Ensuite, on précise le cas à traiter et on nomme entre parenthèses et dans l’ordre le nom de nos constantes ou variables.

Après l’énumération

Maintenant que je vous ai expliqué les énumérations en Swift, il serait sympa d'optimiser le code que j'ai fourni au tout début. On va bien sûr utiliser les énumérations ! :p 

Reprenons notre tout premier exemple et prenons d’abord cette énumération :

enum Langage {
    case Swift, Java, Php, C
}

Créez ensuite cette classe :

class ApresEnumeration {

    func fait(parametre: Langage) { // On précise le type des valeurs attendus, ici : l'énumération Langage
        if parametre == Langage.Swift {
            print("Fait à la façon numéro 1")
        }

        if parametre == Langage.Java {
            print("Fait à la façon numéro 2")
        }
    }
}

Nous pouvons maintenant modifier le main comme ceci :

let ae = ApresEnumeration()

ae.fait(parametre: Langage.Swift)
ae.fait(parametre: Langage.Java)
ae.fait(parametre: 4)

Maintenant, nous avons une erreur que Xcode nous sort. C’est normal, car on n'a pas précisé une valeur qu’on souhaite traiter, à savoir ici le 4 qui est un typeInt et nonLangage.

Pour résumer

  • Une énumération permet de préciser une liste de cas possibles pour traiter une valeur.

  • On utilise le mot clé ‌enum pour déclarer une énumération. 

  • Il est possible d’ajouter des valeurs supplémentaires aux cas d’une énumération.

Exemple de certificat de réussite
Exemple de certificat de réussite