Vérifier si le dictionnaire contient une valeur en Swift

Question

Une simple tâche. J'ai un dictionnaire var types = [Int : String]() qui démarre comme un vide et qui, après quelques actions de l'utilisateur, se remplit de données. Selon le vide ou certaines données spécifiques dans ce dictionnaire, j'active/désactive un bouton dans l'interface utilisateur. Vérifier le vide est facile, mais comment vérifier si le dictionnaire contient une certaine valeur ? Le compilateur m'a suggéré un placeholder avec un prédicat :

types.contains(predicate: ((Int, String)) throws -> Bool>)

Answer 1

Puisque vous voulez seulement vérifier l'existence d'une donnée valeur vous pouvez appliquer le contains pour la méthode values des propriétés de votre dictionnaire (donné comme dictionnaire Swift natif), par exemple

var types: [Int : String] = [1: "foo", 2: "bar"]
print(types.values.contains("foo")) // true

Comme mentionné dans @njuri : réponse en utilisant le values du dictionnaire peut apparemment entraîner une surcharge (je ne l'ai pas vérifié moi-même) par rapport à la simple vérification de la propriété contains directement contre l'entrée de la valeur dans le tuple clé-valeur de chaque Dictionary élément. Comme Swift est rapide, cela ne devrait pas poser de problème, sauf si vous travaillez avec un énorme dictionnaire. Quoi qu'il en soit, si vous souhaitez éviter d'utiliser l'élément values vous pouvez consulter les alternatives données dans la réponse précédente, ou utiliser une autre alternative ( Dictionary ) comme suit :

extension Dictionary where Value: Equatable {
  func containsValue(value : Value) -> Bool {
    return self.contains { $0.1 == value }
  }
}

types.containsValue("foo") // true
types.containsValue("baz") // false

Answer 2

J'ai écrit une fonction qui utilise contains sur le dictionnaire.

Votre cas spécifique :

let dic : [Int : String] = [1 : "a", 2 : "b"]

func dictionary(dict : [Int : String], containsValue value : String)->Bool{

  let contains = dict.contains { (_,v) -> Bool in
      return v == value
  }
  return contains
}

let c = dictionary(dic, containsValue: "c") // false
let a = dictionary(dic, containsValue: "a") // true

Générique :

extension Dictionary{
  func containsValue<T : Equatable>(value : T)->Bool{
    let contains = self.contains { (k, v) -> Bool in

      if let v = v as? T where v == value{
        return true
      }
      return false
    }
    return contains
  }
}

J'ai testé cette fonction contre dictionary.values.contains() et il est environ deux fois plus rapide.

Answer 3

Si vous voulez vérifier si le site contient déjà un valeur ce serait la solution :

if !yourDictionary.values.contains("Zero") {
   yourDictionary[newItemKey] = newItemValue; //addNewItem
}
else {
    print("this value already exists");
}

Et celui-ci, si vous voulez vérifier si la clé existe :

1. Vous obtenez l'élément à ajouter à votre dictionnaire.
2. Vérifier si la clé de l'élément existe déjà

3. Si ce n'est pas le cas, ajoutez l'élément ou activez le bouton.

   //1
   let newItemKey = 0
   let newItemValue = "Zero"
   //2
   let keyExists = yourDictionary[newItemKey] != nil
   //3
   if !keyExists {
       yourDictionary[newItemKey] = newItemValue; //addNewItem
   }
   else {
   print("This key already exists");
   }