Dictionnaire Swift
Les dictionnaires Swift sont utilisés pour stocker des collections non ordonnées de données du même type. Les dictionnaires Swift appliquent une vérification de type sur les éléments, et une erreur se produira si les types sont différents.
Dans un dictionnaire Swift, chaque valeur est associée à une clé unique, et la clé sert d'identifiant pour les données de cette valeur dans le dictionnaire.
Contrairement aux éléments de données d'un tableau, les éléments de données d'un dictionnaire n'ont pas d'ordre spécifique. Nous utilisons un dictionnaire lorsque nous devons accéder à des données via un identifiant (clé). Cette approche est largement similaire à la façon dont nous utilisons un dictionnaire dans le monde réel pour rechercher la signification des mots.
Les clés de dictionnaire Swift n'ont aucune restriction de type et peuvent être des entiers ou des chaînes de caractères, mais elles doivent être uniques.
Si vous créez un dictionnaire et l'affectez à une variable, le dictionnaire sera modifiable. Cela signifie qu'après avoir créé le dictionnaire, vous pouvez modifier ses éléments en ajoutant, supprimant ou modifiant. Si vous affectez un dictionnaire à une constante, le dictionnaire est immuable, et ni sa taille ni son contenu ne peuvent être modifiés.
Création d'un dictionnaire
Nous pouvons utiliser la syntaxe suivante pour créer un dictionnaire vide d'un type spécifique :
var someDict = [KeyType: ValueType]()
Voici une syntaxe simple pour créer un dictionnaire vide avec des clés de type Int et des valeurs de type String :
var someDict = [Int: String]()
Voici un exemple de création d'un dictionnaire :
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
Accès à un dictionnaire
Nous pouvons accéder aux éléments d'un dictionnaire à l'aide de l'index du dictionnaire, avec la syntaxe suivante :
var someVar = someDict[key]
Nous pouvons apprendre à créer, initialiser et accéder à un dictionnaire à travers l'exemple suivant :
import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var someVar = someDict[1] print( "key = 1 的值为 \(someVar)" ) print( "key = 2 的值为 \(someDict[2])" ) print( "key = 3 的值为 \(someDict[3])" )
La sortie de l'exécution du programme ci-dessus est :
key = 1 的值为 Optional("One")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
Modifier un dictionnaire
Nous pouvons utiliserupdateValue(forKey:)pour ajouter ou mettre à jour le contenu d'un dictionnaire. Si la clé n'existe pas, la valeur est ajoutée ; si elle existe, la valeur correspondant à la clé est modifiée. La méthode updateValue(_:forKey:) renvoie une valeur Optional. Voici un exemple :
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict.updateValue("One 新的值", forKey: 1)
var someVar = someDict[1]
print( "key = 1 旧的值 \(oldVal)" )
print( "key = 1 的值为 \(someVar)" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )
La sortie de l'exécution du programme ci-dessus est :
key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
Vous pouvez également modifier la valeur dans un dictionnaire en utilisant une clé spécifiée, comme indiqué ci-dessous :
import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var oldVal = someDict[1] someDict[1] = "One 新的值" var someVar = someDict[1] print( "key = 1 旧的值 \(oldVal)" ) print( "key = 1 的值为 \(someVar)" ) print( "key = 2 的值为 \(someDict[2])" ) print( "key = 3 的值为 \(someDict[3])" )
La sortie de l'exécution du programme ci-dessus est :
key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
Suppression de paires clé-valeur
Nous pouvons utiliser la méthoderemoveValueForKey()pour supprimer une paire clé-valeur d'un dictionnaire. Si la clé existe, la méthode renvoie la valeur supprimée ; sinon, elle renvoie nil. Voici un exemple :
import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var removedValue = someDict.removeValue(forKey: 2) print( "key = 1 的值为 \(someDict[1])" ) print( "key = 2 的值为 \(someDict[2])" ) print( "key = 3 的值为 \(someDict[3])" )
La sortie de l'exécution du programme ci-dessus est :
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")
Vous pouvez également supprimer une paire clé-valeur en définissant la valeur de la clé spécifiée sur nil. Voici un exemple :
import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] someDict[2] = nil print( "key = 1 的值为 \(someDict[1])" ) print( "key = 2 的值为 \(someDict[2])" ) print( "key = 3 的值为 \(someDict[3])" )
La sortie de l'exécution du programme ci-dessus est :
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")
Itération sur un dictionnaire
Nous pouvons utiliser une bouclefor-inpour parcourir les paires clé-valeur d'un dictionnaire. Un exemple est le suivant :
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict {
print("字典 key \(key) - 字典 value \(value)")
}
La sortie de l'exécution du programme ci-dessus est :
字典 key 2 - 字典 value Two 字典 key 3 - 字典 value Three 字典 key 1 - 字典 value One
Nous pouvons également utiliser la méthode enumerate() pour parcourir un dictionnaire, qui renvoie l'indice du dictionnaire ainsi que les paires (clé, valeur). Un exemple est le suivant :
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict.enumerated() {
print("字典 key \(key) - 字典 (key, value) 对 \(value)")
}
La sortie de l'exécution du programme ci-dessus est :
字典 key 0 - 字典 (key, value) 对 (2, "Two") 字典 key 1 - 字典 (key, value) 对 (3, "Three") 字典 key 2 - 字典 (key, value) 对 (1, "One")
Conversion d'un dictionnaire en tableau
Vous pouvez extraire les paires clé-valeur d'un dictionnaire et les convertir en tableaux séparés. Un exemple est le suivant :
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)
print("输出字典的键(key)")
for (key) in dictKeys {
print("\(key)")
}
print("输出字典的值(value)")
for (value) in dictValues {
print("\(value)")
}
La sortie de l'exécution du programme ci-dessus est :
输出字典的键(key) 2 3 1 输出字典的值(value) Two Three One
La propriété count
Nous pouvons utiliser la propriété en lecture seulecountpour compter le nombre de paires clé-valeur du dictionnaire :
import Cocoa
var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
print("someDict1 含有 \(someDict1.count) 个键值对")
print("someDict2 含有 \(someDict2.count) 个键值对")
La sortie de l'exécution du programme ci-dessus est :
someDict1 含有 3 个键值对 someDict2 含有 2 个键值对
La propriété isEmpty
Nous pouvons utiliser la propriété en lecture seuleisEmptypour déterminer si le dictionnaire est vide, en renvoyant une valeur booléenne :
import Cocoa
var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
var someDict3:[Int:String] = [Int:String]()
print("someDict1 = \(someDict1.isEmpty)")
print("someDict2 = \(someDict2.isEmpty)")
print("someDict3 = \(someDict3.isEmpty)")
La sortie de l'exécution du programme ci-dessus est :
someDict1 = false someDict2 = false someDict3 = trueAutres extensions