Dans ce chapitre, nous allons parler des dictionnaires ! Rassurez-vous, nous allons laisser nos amis Robert, Larousse et compagnie tranquilles.
Car notre programme commence à vraiment prendre forme, mais il y a quelque chose qui me chiffonne. Cette histoire de tableau, c'est bien. Mais il y a quelque chose qui n'est pas très pratique ici :
// La grange de Joe : [lait, blé, laine]
var barn = [0, 0, 0]
Sans le commentaire au-dessus, il est difficile de savoir à quelle marchandise correspond chaque zéro. Dans le code, on n’a que trois zéros à la suite l'un de l'autre. Pire encore, il est très facile de se tromper :
// Joe moissonne
barn[1] += 100
Ici, j'aurais très facilement pu écrire barn[2]
, et me tromper sans m'en rendre compte. On va découvrir ensemble comment les dictionnaires vont nous permettre de clarifier tout ça !
Découvrez les dictionnaires
Un dictionnaire est une collection. Pour rappel, il y a trois types de collections différents en Swift :
Les tableaux qui n'ont plus de secrets pour vous.
Les dictionnaires que nous allons découvrir tout de suite.
Les sets que nous verrons dans un autre cours.
Un dictionnaire est une liste organisée par clé. En fait, ça fonctionne comme un vrai dictionnaire. Dans un vrai dictionnaire, à chaque mot correspond une définition. Dans un dictionnaire en Swift, à chaque clé correspond une valeur.
C'est quoi cette histoire de clé ?
J'y viens ! Prenons un exemple pour comprendre. Pour créer un dictionnaire, on va utiliser la syntaxe suivante :
var ages: [String: Int] = ["Michel": 34, "Paul": 22, "Fred": 67, "Jean": 15]
Dans le dictionnaire précédent, je stocke les âges de mes amis Michel, Paul, Fred et Jean. Contrairement aux tableaux où j'aurais juste écrit les âges les uns à la suite des autres, là je crée une clé pour chaque âge qui correspond au nom de l'ami concerné. C'est avec cette clé que je vais pouvoir récupérer mes valeurs.
Le programme va stocker les informations comme ceci :
C'est ce qu'on appelle une association clé-valeur. La clé ici étant le prénom, et la valeur, l'âge.
La syntaxe générique de création d'un dictionnaire est donc :
[clé1: valeur1, clé2: valeur2]
On utilise les deux-points :
pour séparer la clé et la valeur.
Le type des dictionnaires
Si vous faites attention, vous remarquerez qu'un dictionnaire est la combinaison de deux types : un type pour la clé, et un type pour la valeur. On note le type d'un dictionnaire comme ceci : [TypeDeLaClé: TypeDeLaValeur]
. Dans notre exemple, ce serait : [String: Int]
. Les prénoms sont des chaînes de caractères, et les âges des nombres entiers.
Comme pour les tableaux et les variables, on ne peut pas faire n'importe quoi avec les dictionnaires. En particulier :
Les types de la clé et de la valeur ne peuvent pas être modifiés.
Les types de la clé et de la valeur sont toujours connus.
Il n'y a qu'un seul type de clé et qu'un seul type de valeur dans un même dictionnaire.
Vous commencez à comprendre que de manière générale en Swift, les types, ça ne bouge pas !
var metiers: [String: String] = ["Pierre": "Boulanger", "Fred": "Plombier"]
[true: "C'est vrai !", false: "C'est faux !"] // A pour type [Bool: String]
À vous de jouer
Le contenu de l’exercice se trouve dans le dossier Github P3C2.1.
Ouvrez un nouveau Playground Xcode.
Copiez le contenu du fichier “main.swift” dans votre Playground.
Suivez les instructions.
Jouez avec les dictionnaires !
Déclarez un dictionnaire vide
Maintenant que l'on sait écrire le type d'un dictionnaire, le plus simple pour déclarer un dictionnaire vide, c'est d'utiliser son type comme ceci :
var monDictionnaireVide: [String: Int] = [:]
Modifiez et accédez aux données
Dans un tableau, on récupérait les valeurs en utilisant l'index comme ceci :
barn[1] // Contient le nombre de bottes de blé stocké
Dans un dictionnaire, on récupère les valeurs en utilisant une clé, par exemple comme ceci :
barn["wheat"] // Contient le nombre de bottes de blé
Pour modifier les données, il suffit comme pour les tableaux d'attribuer une nouvelle valeur, cette fois en utilisant la clé.
barn["wheat"] = 100 // La clé "wheat" contient maintenant la valeur 100
Définissez la mutabilité des dictionnaires
Je sais que vous le savez, mais je vous le dis quand même : pour déclarer un dictionnaire modifiable, on utilise var
; si on veut qu'il soit constant, on utilise let
.
Dans un dictionnaire constant, on ne peut rien modifier : aucun ajout/modification/suppression de couple clé-valeur.
Ajoutez et supprimez des éléments
Pour ajouter des éléments, rien de plus simple ! On utilise la même syntaxe que pour modifier un élément. Il suffit de prendre une clé non utilisée. Exemple :
var countries: [String: String] = ["FR": "France", "IT": "Italie", "UK": "United King"]
// Je modifie la valeur, car la clé "UK" existe déjà
countries["UK"] = "United Kingdom"
// J'ajoute une valeur, car la clé "ES" n'existe pas
countries["ES"] = "Espagne"
Pour supprimer des éléments, on utilise la fonction remove
comme ceci :
countries.removeValue(forKey: "ES")
// L'association "ES": "Espagne" est supprimée
Comptez les éléments
Pour compter les éléments dans un dictionnaire, on utilise la même propriété que pour les tableaux : count
.
countries.count // Renvoie 3
Parcourez un dictionnaire
Vous vous souvenez de la boucle for pour parcourir les tableaux ? On peut faire la même chose avec les dictionnaires ! Seulement, un dictionnaire, contrairement à un tableau, contient deux types de données : la clé et la valeur. Donc pour accéder aux deux, Swift propose une syntaxe spécifique :
for (cle, valeur) in dictionnaire {
// Dans le code, on peut utiliser la clé et la valeur
}
Par exemple, avec notre dictionnaire pays
, on pourrait écrire :
for (code, country) in countries {
print("Le pays \(country) a pour code \(code)")
}
Je vous propose le petit exercice suivant. En utilisant un dictionnaire, rédigez un programme qui permet d'afficher les tailles des membres de votre famille, et qui donne à la fin la taille cumulée de tout le monde. Dans la console, vous devriez avoir quelque chose de ce type :
Papa mesure 1.78m Céleste mesure 1.73m Iris mesure 1.64m Ambroise mesure 1.81m Maman mesure 1.71m Si on montait sur les épaules les uns des autres, on mesurerait 8.66m.
À vous de jouer ! Avant de regarder la solution ci-dessous, essayez par vous-même.
var family: [String: Int] = ["Papa": 1.78, "Maman": 1.71, "Iris": 1.64, "Céleste": 1.73, "Ambroise": 1.81]
var cumulatedSize = 0.0
for (name, size) in family {
print("\(name) mesure \(size)m")
cumulatedSize += size
}
print("Si on montait sur les épaules les uns des autres, on mesurerait \(cumulatedSize)m.")
C'est le moment où vous êtes impatient de modifier votre programme ! Et on ne va pas le faire...
Je sais, vous êtes déçu. Moi aussi. Mais si je vous laisse partir tête baissée avec votre dictionnaire, vous risquez de vous planter... Vous pouvez essayer, d'ailleurs !
Pour réussir, vous avez besoin de connaître les optionnels. Ça tombe bien, c'est le sujet du prochain chapitre ! Elle est pas belle la vie ?
En résumé
Pour vous consoler, je vous ai fait un magnifique tableau pour résumer ce que vous savez sur les tableaux et les dictionnaires. Sympa le type.
| Tableau | Dictionnaire |
Syntaxe | [element 1, element 2] | [clé1: valeur1, clé2: valeur 2] |
Syntaxe du type | [Type] | [TypeDeLaClé: TypeDeLaValeur] |
Création de l’objet vide | [Type] = [] Si le type est connu: [] | [TypeDeLaClé: TypeDeLaValeur] = [:] Si le type est connu: [:] |
Accéder aux données | monTableau[0] On utilise l’index | monDictionnaire[clé] On utilise la clé |
Modifier les données | monTableau[0] = 12 On utilise l’index | monDictionnaire[clé] = 12 On utilise la clé |
Ajouter une donnée | monTableau.append(23) | monDictionnaire[nouvelleClé] = 23 |
Supprimer une donnée | monTableau.remove(at: 1) | monDictionnaire.removeValue(for key: clé) |
Compter les données | monTableau.count | monDictionnaire.count |
Parcourir | for element in monTableau { | for (clé, valeur) in monDictionnaire { |
Maintenant que vous savez utiliser les dictionnaires afin de manipuler vos données, je vous invite à passer au chapitre suivant !