Les Dictionnaires

Déclaration et Initialisation d'un Dictionnaire

Un dictionnaire en Swift est déclaré en utilisant la syntaxe suivante : [KeyType: ValueType], où KeyType est le type des clés, et ValueType est le type des valeurs.

Exemple d'un dictionnaire vide :

var emptyDictionary: [String: Int] = [:]  // Un dictionnaire vide avec des clés String et des valeurs Int

Ou en utilisant l'inférence de type :

var scores = [String: Int]()  // Un dictionnaire vide qui associe des chaînes à des entiers

Exemple avec des valeurs initiales :

var studentGrades: [String: String] = [
    "Alice": "A",
    "Bob": "B",
    "Charlie": "A"
]

Ou avec inférence de type :

var countryCodes = ["FR": "France", "US": "United States", "JP": "Japan"]

Accéder aux Valeurs d'un Dictionnaire

Pour accéder à une valeur dans un dictionnaire, vous utilisez la clé associée à cette valeur entre crochets []. Le résultat sera optionnel, car la clé peut ne pas exister.

let grade = studentGrades["Alice"]  // Retourne "A" optionnel

Vous pouvez également utiliser l'optionnelle pour accéder aux valeurs en toute sécurité :

if let aliceGrade = studentGrades["Alice"] {
    print("Alice a obtenu la note \(aliceGrade)")
} else {
    print("Pas de note trouvée pour Alice")
}

Ajouter, Modifier et Supprimer des Valeurs

Ajouter ou Modifier une Valeur :

Pour ajouter une nouvelle association ou mettre à jour une valeur existante, vous pouvez simplement utiliser l'opérateur d'affectation (=) avec la clé correspondante.

studentGrades["David"] = "C"  // Ajoute une nouvelle association
studentGrades["Bob"] = "A"    // Met à jour la valeur associée à la clé "Bob"

Supprimer une Valeur :

Pour supprimer une association, utilisez la méthode removeValue(forKey:).

studentGrades.removeValue(forKey: "Charlie")  // Supprime l'entrée pour "Charlie"

Vous pouvez également utiliser nil pour supprimer une entrée :

studentGrades["Bob"] = nil  // Supprime l'entrée pour "Bob"

Parcourir un Dictionnaire

Vous pouvez parcourir un dictionnaire en utilisant une boucle for-in, qui permet d'itérer sur les paires clé-valeur.

for (student, grade) in studentGrades {
    print("\(student) a obtenu la note \(grade)")
}

Il est également possible de parcourir uniquement les clés ou les valeurs :

for student in studentGrades.keys {
    print("Étudiant : \(student)")
}
for grade in studentGrades.values {
    print("Note : \(grade)")
}

Propriétés et Méthodes Utiles

count : Retourne le nombre de paires clé-valeur dans le dictionnaire.

print(studentGrades.count)  // Affiche le nombre d'entrées

isEmpty : Vérifie si le dictionnaire est vide.

if studentGrades.isEmpty {
    print("Le dictionnaire est vide")
}

keys et values : Retourne respectivement les clés et les valeurs sous forme de collections (non ordonnées).

let students = Array(studentGrades.keys)  // Tableau des clés (étudiants)
let grades = Array(studentGrades.values)  // Tableau des valeurs (notes)

Accès avec Valeurs par Défaut

Swift permet d'accéder à une valeur dans un dictionnaire avec une valeur par défaut en cas de clé inexistante. Cela évite d'avoir à gérer une optionnelle.

let gradeForEve = studentGrades["Eve", default: "Pas de note"]
print(gradeForEve)  // Affiche : "Pas de note"

Mise à Jour et Fusion de Dictionnaires

Mise à jour d'un dictionnaire avec un autre :

Swift permet de fusionner deux dictionnaires à l'aide de la méthode merge(_:uniquingKeysWith:). Si les deux dictionnaires ont des clés en commun, vous devez spécifier comment résoudre les conflits.

var otherGrades = ["Charlie": "B", "Eve": "A"]
studentGrades.merge(otherGrades) { (current, new) in new }
print(studentGrades)  // Fusionne les dictionnaires

Dictionnaires Immutables

Si vous déclarez un dictionnaire avec let, il devient immuable, c'est-à-dire que vous ne pouvez pas ajouter, supprimer ou modifier ses éléments.

let constantGrades = ["Alice": "A", "Bob": "B"]
// constantGrades["Alice"] = "B"  // Erreur : Impossible de modifier un dictionnaire immuable

Conversion entre Types

Vous pouvez facilement convertir un dictionnaire en tableau de clés ou de valeurs, ou manipuler les données pour une transformation spécifique. Les dictionnaires peuvent également être convertis en structures plus complexes en fonction des besoins.

let studentList = Array(studentGrades.keys)

Comparer Deux Dictionnaires

Vous pouvez vérifier si deux dictionnaires sont égaux avec l'opérateur d'égalité (==). Deux dictionnaires sont égaux s'ils contiennent exactement les mêmes paires clé-valeur.

let dictA = ["one": 1, "two": 2]
let dictB = ["two": 2, "one": 1]
if dictA == dictB {
    print("Les dictionnaires sont égaux")
}