Dictionnaire rapide
Le dictionnaire Swift est utilisé pour stocker des collections non ordonnées de données du même type. Le dictionnaire Swift détectera avec force le type d'éléments et signalera une erreur si les types sont différents.
Chaque valeur du dictionnaire Swift est associée à une clé unique, et la clé sert d'identifiant des données de valeur dans le dictionnaire.
Contrairement aux éléments de données du tableau, les éléments de données du dictionnaire n'ont pas d'ordre spécifique. Nous utilisons des dictionnaires lorsque nous avons besoin d'accéder à des données via des identifiants (clés). Cette méthode est en grande partie la même que la façon dont nous utilisons des dictionnaires pour rechercher la signification des mots dans le monde réel.
Les clés du dictionnaire Swift peuvent être des entiers ou des chaînes sans aucune restriction de type, mais elles doivent être uniques.
Si vous créez un dictionnaire et l'attribuez à une variable, le dictionnaire créé peut être modifié. Cela signifie qu'après la création d'un dictionnaire, les éléments du dictionnaire peuvent être modifiés en ajoutant, supprimant ou modifiant. Si vous affectez un dictionnaire à une constante, le dictionnaire ne peut pas être modifié, et ni la taille ni le contenu du dictionnaire ne peuvent être modifiés.
Créer un dictionnaire
Nous pouvons utiliser la syntaxe suivante pour créer un dictionnaire vide d'un type spécifique :
var someDict = [KeyType: ValueType]()
Ce qui suit consiste à créer un dictionnaire vide avec des clés de type Int , la syntaxe simple du type valeur est 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 au dictionnaire
On peut en fonction de l'index du dictionnaire Pour accéder aux éléments du tableau, la syntaxe est la suivante :
var someVar = someDict[key]
On peut apprendre à créer, initialiser et accéder au dictionnaire à travers les exemples suivants :
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])" )
Le résultat de sortie de l'exécution du programme ci-dessus est :
key = 1 的值为 Optional("One")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")Modifier le dictionnaire
Nous pouvons utiliser updateValue(forKey:) pour ajouter ou mettre à jour le contenu du dictionnaire. Si la clé n'existe pas, ajoutez la valeur. Si elle existe, modifiez la valeur correspondant à la clé. La méthode updateValue(_:forKey:) renvoie la valeur facultative. Un exemple est le suivant :
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])" )Le résultat 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 du dictionnaire en spécifiant la clé, 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])" )
Le programme ci-dessus Le résultat de l'exécution est :
key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")Supprimer la paire clé-valeur
Nous pouvons utiliser la méthode removeValueForKey() pour supprimer le paire clé-valeur de dictionnaire. Cette méthode renvoie la valeur supprimée si la clé existe, ou nil si elle n'existe pas. Un exemple est le suivant :
import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var removedValue = someDict.removeValueForKey(2) print( "key = 1 的值为 \(someDict[1])" ) print( "key = 2 的值为 \(someDict[2])" ) print( "key = 3 的值为 \(someDict[3])" )
Le résultat de l'exécution du programme ci-dessus est :
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")Vous pouvez également supprimer les paires clé-valeur (clé-valeur) en spécifiant la valeur de la clé comme nulle. . L'exemple est le suivant :
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])" )
Le résultat de sortie de l'exécution du programme ci-dessus est :
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")Parcours du dictionnaire
On peut utiliser le <🎜 Boucle >for-in pour parcourir les paires clé-valeur dans 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)")
} Le résultat de l'exécution du programme ci-dessus est : 字典 key 2 - 字典 value Two 字典 key 3 - 字典 value Three 字典 key 1 - 字典 value OneNous pouvons également utiliser la méthode enumerate() pour effectuer une traversée du dictionnaire, qui renvoie l'index du dictionnaire et ( key, value) paire, l'exemple est le suivant :
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict.enumerate() {
print("字典 key \(key) - 字典 (key, value) 对 \(value)")
}Le résultat 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")
Le dictionnaire est converti en tableau Vous pouvez extraire la valeur-clé du dictionnaire Oui et la convertir en un tableau séparé. L'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)")
}Le résultat de sortie de l'exécution du programme ci-dessus est : 输出字典的键(key) 2 3 1 输出字典的值(value) Two Three One
attribut count
Nous pouvons utiliser l'attribut count en lecture seule pour 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) 个键值对")Le sortie d'exécution du programme ci-dessus Le résultat est :
someDict1 含有 3 个键值对 someDict2 含有 2 个键值对
attribut isEmpty
Y Nous pouvons utiliser l'attribut en lecture seule isEmpty pour déterminer si le dictionnaire est vide et renvoie 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)") Le résultat de sortie de l'exécution du programme ci-dessus est :
someDict1 = false someDict2 = false someDict3 = true
