Swift-Dictionary
Swift-Dictionaries werden verwendet, um ungeordnete Sammlungen von Daten desselben Typs zu speichern. Swift-Dictionaries erzwingen die Typprüfung bei Elementen, und ein Fehler tritt auf, wenn die Typen unterschiedlich sind.
In einem Swift-Dictionary ist jeder Wert einem eindeutigen Schlüssel zugeordnet, und der Schlüssel dient als Bezeichner für die Daten dieses Werts im Dictionary.
Im Gegensatz zu Datenelementen in einem Array haben Datenelemente in einem Dictionary keine bestimmte Reihenfolge. Wir verwenden ein Dictionary, wenn wir über einen Bezeichner (Schlüssel) auf Daten zugreifen müssen. Dieser Ansatz ist weitgehend ähnlich dazu, wie wir ein Wörterbuch in der realen Welt verwenden, um Wortbedeutungen nachzuschlagen.
Schlüssel in Swift-Dictionaries haben keine Typbeschränkung und können Ganzzahlen oder Strings sein, müssen aber eindeutig sein.
Wenn Sie ein Dictionary erstellen und es einer Variablen zuweisen, ist das Dictionary veränderbar. Das bedeutet, dass Sie nach dem Erstellen des Dictionaries seine Elemente ändern können, indem Sie sie hinzufügen, entfernen oder ändern. Wenn Sie ein Dictionary einer Konstanten zuweisen, ist das Dictionary unveränderbar, und sowohl seine Größe als auch sein Inhalt können nicht geändert werden.
Ein Dictionary erstellen
Wir können die folgende Syntax verwenden, um ein leeres Dictionary eines bestimmten Typs zu erstellen:
var someDict = [KeyType: ValueType]()
Das Folgende ist eine einfache Syntax zum Erstellen eines leeren Dictionaries mit Schlüsseln vom Typ Int und Werten vom Typ String:
var someDict = [Int: String]()
Das Folgende ist ein Beispiel für das Erstellen eines Dictionaries:
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
Zugriff auf ein Dictionary
Wir können auf Elemente eines Dictionarys über den Index des Dictionarys zugreifen, die Syntax lautet wie folgt:
var someVar = someDict[key]
Wir können anhand des folgenden Beispiels lernen, wie man ein Dictionary erstellt, initialisiert und darauf zugreift:
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])" )
Die Ausgabe der obigen Programmausführung ist:
key = 1 的值为 Optional("One")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
Ändern eines Dictionary
Wir könnenupdateValue(forKey:)verwenden, um den Inhalt eines Dictionarys hinzuzufügen oder zu aktualisieren. Wenn der Schlüssel nicht existiert, wird der Wert hinzugefügt; wenn er existiert, wird der dem Schlüssel entsprechende Wert geändert. Die Methode updateValue(_:forKey:) gibt einen Optional-Wert zurück. Ein Beispiel ist wie folgt:
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])" )
Die Ausgabe der obigen Programmausführung ist:
key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
Sie können den Wert in einem Dictionary auch mithilfe eines angegebenen Schlüssels ändern, wie unten gezeigt:
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])" )
Die Ausgabe der obigen Programmausführung ist:
key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")
Entfernen von Schlüssel-Wert-Paaren
Wir können die MethoderemoveValueForKey()verwenden, um ein Schlüssel-Wert-Paar aus einem Dictionary zu entfernen. Wenn der Schlüssel existiert, gibt die Methode den entfernten Wert zurück; wenn nicht, gibt sie nil zurück. Ein Beispiel ist wie folgt:
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])" )
Die Ausgabe der obigen Programmausführung ist:
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")
Sie können ein Schlüssel-Wert-Paar auch entfernen, indem Sie den Wert des angegebenen Schlüssels auf nil setzen. Ein Beispiel ist wie folgt:
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])" )
Die Ausgabe der obigen Programmausführung ist:
key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")
Iterieren über ein Dictionary
Wir können einefor-in-Schleife verwenden, um über die Schlüssel-Wert-Paare in einem Dictionary zu iterieren. Ein Beispiel ist wie folgt:
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict {
print("字典 key \(key) - 字典 value \(value)")
}
Die Ausgabe der obigen Programmausführung ist:
字典 key 2 - 字典 value Two 字典 key 3 - 字典 value Three 字典 key 1 - 字典 value One
Wir können auch die Methode enumerate() verwenden, um über ein Dictionary zu iterieren; sie gibt den Index des Dictionarys zusammen mit (Schlüssel, Wert)-Paaren zurück. Ein Beispiel ist wie folgt:
import Cocoa
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict.enumerated() {
print("字典 key \(key) - 字典 (key, value) 对 \(value)")
}
Die Ausgabe der obigen Programmausführung ist:
字典 key 0 - 字典 (key, value) 对 (2, "Two") 字典 key 1 - 字典 (key, value) 对 (3, "Three") 字典 key 2 - 字典 (key, value) 对 (1, "One")
Konvertieren eines Dictionarys in ein Array
Sie können die Schlüssel-Wert-Paare eines Dictionarys extrahieren und in separate Arrays konvertieren. Ein Beispiel ist wie folgt:
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)")
}
Die Ausgabe der obigen Programmausführung ist:
输出字典的键(key) 2 3 1 输出字典的值(value) Two Three One
Die count-Eigenschaft
Wir können die schreibgeschütztecount-Eigenschaft verwenden, um zu zählen, wie viele Schlüssel-Wert-Paare das Dictionary hat:
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) 个键值对")
Die Ausgabe der obigen Programmausführung ist:
someDict1 含有 3 个键值对 someDict2 含有 2 个键值对
Die isEmpty-Eigenschaft
Wir können die schreibgeschützte EigenschaftisEmptyverwenden, um festzustellen, ob das Dictionary leer ist; sie gibt einen Boolean-Wert zurück:
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)")
Die Ausgabe der obigen Programmausführung ist:
someDict1 = false someDict2 = false someDict3 = trueAndere Erweiterungen