Introduction
Les dictionnaires sont l'un des principaux types de collection de Swift.
Un dictionnaire stocke des associations non ordonnées entre des clés uniques et les valeurs correspondantes.
Toutes les clés d'un dictionnaire doivent être du même type, et toutes les valeurs doivent elles aussi partager le même type.
Les littéraux de dictionnaire s'écrivent sous la forme de paires key: value séparées par des virgules et entourées de crochets :
var addresses: Dictionary<String, String> = [
"The Munsters": "1313 Mockingbird Lane",
"The Simpsons": "742 Evergreen Terrace",
"Buffy Summers": "1630 Revello Drive"
]
var sequences: [String: [Int]] = [
"Euler's totient": [1, 1, 2, 2, 4, 2, 6, 4],
"Lazy caterer": [1, 2, 4, 7, 11, 16, 22, 29, 37],
"Carmichael": [561, 1105, 1729, 2465, 2821, 6601, 8911, 10585, 15841]
]
let constants = [
"pi": 3.14159,
"e": 2.71828,
"phi": 1.618033,
"avogadro": 6.02214076e23
]
Les types de dictionnaire peuvent s'écrire explicitement de deux manières : Dictionary<Key, Value> ou la syntaxe abrégée [Key: Value].
Pour créer un dictionnaire vide, précise explicitement les types de ses clés et de ses valeurs :
var emptyDict1: [Int: Int] = [:]
var emptyDict2 = [Character: String]()
var emptyDict3 = Dictionary<Int, Double>()
Accède aux valeurs
On peut accéder aux valeurs à l'aide de la notation par indice : place la clé entre crochets après le nom du dictionnaire.
Comme une clé peut ne pas exister dans le dictionnaire, l'accès par indice renvoie une valeur optionnelle (Value?).
Si la clé est présente, Swift renvoie la valeur encapsulée ; sinon, il renvoie nil :
let munster: String? = addresses["The Munsters"]
// Returns Optional("1313 Mockingbird Lane")
let carmichael = sequences["Carmichael"]
// Returns Optional([561, 1105, 1729, 2465, 2821, 6601, 8911, 10585, 15841])
let planck = constants["planck"]
// Returns nil
Pour éviter de manipuler des optionnels, on peut fournir une valeur par défaut à l'aide du paramètre default :
let e: Double = constants["e", default: 0]
// Returns 2.71828
let hoagie: [Int] = sequences["Hoagie", default: []]
// Returns []
let betty = addresses["Betty Cooper", default: "Address unknown"]
// Returns "Address unknown"
Modifie les dictionnaires
Pour les dictionnaires mutables déclarés avec var, tu peux ajouter ou mettre à jour des paires clé-valeur à l'aide d'une affectation par indice :
sequences["Euler's totient"]?.append(contentsOf: [6, 4])
// sequences["Euler's totient"] is now [1, 1, 2, 2, 4, 2, 6, 4, 6, 4]
addresses["Betty Cooper"] = "111 Queens Ave."
addresses["Betty Cooper", default: "Address unknown"]
// Returns "111 Queens Ave."
constants["Gelfond's"] = 23.140692
// Compiler error: Cannot assign through subscript: 'constants' is a 'let' constant
Parcours un dictionnaire
On peut parcourir chaque paire clé-valeur d'un dictionnaire à l'aide d'une boucle for-in.
Chaque élément est fourni sous forme de tuple (key, value) :
for (name, address) in addresses {
print("\(name) lives at \(address)")
}
Trie les dictionnaires
Comme les dictionnaires ne sont pas ordonnés, les trier produit un tableau de paires clé-valeur.
On peut passer une closure à la méthode sorted(by:) qui compare deux tuples (key, value) et renvoie true si le premier tuple doit apparaître avant le second :
func sortByNameLengthThenValue(_ lhs: (key: String, value: Double), _ rhs: (key: String, value: Double)) -> Bool {
let left = lhs.value + Double(lhs.key.count)
let right = rhs.value + Double(rhs.key.count)
return left < right
}
let sortedConstants = constants.sorted(by: sortByNameLengthThenValue)
Instructions
Dans cet exercice, tu vas mettre en place un moyen de suivre les meilleurs scores du jeu le plus populaire de la salle d'arcade de ta ville.
Tu as 7 fonctions à implémenter, toutes liées au renvoi et à la manipulation d'un dictionnaire de données de meilleurs scores.
1. Définis un nouveau dictionnaire des meilleurs scores
Crée une fonction newScoreBoard() qui ne prend aucun paramètre et qui renvoie un nouveau dictionnaire des meilleurs scores, dont les clés sont de type String et les valeurs de type Int.
2. Ajoute des joueurs au dictionnaire des meilleurs scores
Pour ajouter un joueur au dictionnaire des meilleurs scores, définis addPlayer(_:_:_:), une fonction qui prend 3 paramètres :
- Le premier paramètre est le dictionnaire des scores.
Il doit s'agir d'un paramètre in-out.
- Le deuxième paramètre est le nom d'un joueur, sous forme de string.
- Le troisième paramètre est le score, sous forme de nombre entier.
Ce paramètre est facultatif, implémente le troisième paramètre avec une valeur par défaut de 0.
var highScores = newScoreBoard()
addPlayer(&highScores, "Dave Thomas")
// Returns ["Dave Thomas": 0]
addPlayer(&highScores, "José Valim", 486_373)
// Returns ["Dave Thomas": 0, "José Valim": 486_373]
3. Supprime des joueurs du dictionnaire des scores
Pour supprimer un joueur du dictionnaire des meilleurs scores, définis removePlayer(_:_:), qui prend 2 paramètres :
- Le premier paramètre est le dictionnaire des scores.
Il doit s'agir d'un paramètre in-out.
- Le deuxième paramètre est le nom du joueur, sous forme de string.
Cette fonction doit supprimer le joueur du dictionnaire s'il s'y trouve, et ne rien faire dans le cas contraire.
var highScores = ["Dave Thomas": 0, "José Valim": 486_373]
removePlayer(&highScores, "Dave Thomas")
// Returns ["José Valim": 486_373]
removePlayer(&highScores, "Rose Fanaras")
// Returns ["José Valim": 486_373]
4. Réinitialise le score d'un joueur
Pour réinitialiser le score d'un joueur, définis resetPlayer(_:_:), qui prend 2 paramètres :
- Le premier paramètre est le dictionnaire des scores.
Il doit s'agir d'un paramètre in-out.
- Le deuxième paramètre est le nom du joueur dont tu souhaites réinitialiser le score, sous forme de string.
La fonction met le score du joueur à 0.
Si le joueur n'est pas dans le dictionnaire, il ne doit rien se passer.
var highScores = ["Dave Thomas": 486_373, "José Valim": 10]
resetScore(&highScores, "Dave Thomas")
// Returns ["Dave Thomas": 0, "José Valim": 10]
5. Mets à jour le score d'un joueur
Pour mettre à jour le score d'un joueur en l'ajoutant au score précédent, définis updateScore, qui prend 3 paramètres :
- Le premier paramètre est le dictionnaire des scores. Il doit s'agir d'un paramètre in-out.
- Le deuxième paramètre est le nom du joueur dont tu souhaites mettre à jour le score, sous forme de string.
- Le troisième paramètre est le score que tu souhaites ajouter au meilleur score enregistré.
var highScores = ["Dave Thomas": 0, "José Valim": 486_373]
addPlayer(&highScores, "Freyja Ćirić", 12_771_008)
updateScore(&highScores, "Freyja Ćirić", 73)
// Returns ["Dave Thomas": 0, "José Valim": 486_373, "Freyja Ćirić": 12_771_081]
6. Récupère la liste des joueurs triés par nom
Définis la fonction orderByPlayers, qui prend 1 paramètre :
- Le premier paramètre est le dictionnaire des scores.
La fonction renvoie un tableau de tuples (String, Int), à savoir les joueurs et leurs meilleurs scores, triés par ordre croissant du nom du joueur.
var highScores = ["Dave Thomas": 0, "José Valim": 486_373, "Freyja Ćirić": 12_771_091]
orderByPlayers(highScores)
// Returns [("Dave Thomas", 0), ("Freyja Ćirić", 12_771_091), ("José Valim", 486_373)]
7. Récupère la liste des joueurs classés par score décroissant
Pour obtenir la liste des joueurs classés par score décroissant, définis orderByScores, qui prend 1 paramètre :
- Le premier paramètre est le dictionnaire des scores.
La fonction renvoie un tableau de tuples (String, Int), à savoir les joueurs et leurs meilleurs scores, triés par ordre décroissant du score du joueur.
var highScores = ["Dave Thomas": 0, "José Valim": 486_373, "Freyja Ćirić": 12_771_091]
orderByScores(highScores)
// Returns [("Freyja Ćirić", 12_771_091), ("José Valim", 486_373), ("Dave Thomas", 0)]
Exercice d'apprentissage
