Comment puis-je vérifier si une clé existe dans un dictionnaire? Mon dictionnaire est de type [Type:Type?].
Je ne peux pas simplement vérifier dictionary[key] == nil, car cela pourrait résulter de la valeur d'être nil.
Des idées?
Comment puis-je vérifier si une clé existe dans un dictionnaire? Mon dictionnaire est de type [Type:Type?].
Je ne peux pas simplement vérifier dictionary[key] == nil, car cela pourrait résulter de la valeur d'être nil.
Des idées?
En fait ton test dictionary[key] == nil pouvez être utilisé pour vérifier
si une clé existe dans un dictionnaire. Il ne cédera pas true si la valeur
est réglé sur nil:
let dict : [String : Int?] = ["a" : 1, "b" : nil]
dict["a"] == nil // false, dict["a"] is .Some(.Some(1))
dict["b"] == nil // false !!, dict["b"] is .Some(.None)
dict["c"] == nil // true, dict["c"] is .None
Distinguer entre "clé n'est pas présente dans dict" et "valeur pour clé est nulle" vous peut faire une affectation optionnelle imbriquée:
if let val = dict["key"] {
if let x = val {
println(x)
} else {
println("value is nil")
}
} else {
println("key is not present in dict")
}
Je crois le type de dictionnaire indexForKey(key: Key) est ce que vous recherchez. Il retourne l'index pour une clé donnée, mais plus important encore pour vos propositions, il renvoie nil s'il ne trouve pas la clé spécifiée dans le dictionnaire.
if dictionary.indexForKey("someKey") != nil {
// the key exists in the dictionary
}
Swift 3 syntaxe ....
if dictionary.index(forKey: "someKey") == nil {
print("the key 'someKey' is NOT in the dictionary")
}
Vous pouvez toujours faire:
let arrayOfKeys = dictionary.allKeys
if (arrayOfKeys.containsObject(yourKey)) {
}
else {
}
Cependant, je n'aime vraiment pas l'idée de créer un NSDictionary pouvant contenir des options.
Essaye ça:
let value = dict[key] != nil
J'espère que cela fonctionne pour vous. Merci
Cela fonctionne pour moi [Swift 3.0]:
let myVar = "c"
let myDict: [String: Int] = ["a": 0, "b": 1, "c": 2]
if myDict.keys.contains(myVar) {
print(myVar)
} else {
print("ERROR")
}
Je l'ai géré de cette façon dans Swift 4:
extension Dictionary {
func contains(key: Key) -> Bool {
let value = self.contains { (k,_) -> Bool in key == k }
return value
}
}
Cela utilise Dictionary.contains(where: (key: Hashable, value: Value) throws -> Bool). En l'encapsulant en tant qu'extension, j'ai une bonne idée de mettre à jour l'implémentation sans modifier mon code. J'évite de créer des données, qui index(forKey:Key) Est-ce que. J'espère que c'est plus efficace que d'accéder à keys car cela doit créer l'ensemble du tableau avant de le chercher.