Le dictionnaire contient une certaine valeur swift 3

Question

Je veux vérifier si une chaîne de caractères existe dans l'une des valeurs de mon dictionnaire.

Dictionary<String, AnyObject>

Je sais que les tableaux ont des .contains donc je pense qu'un dictionnaire en a aussi. Xcode me dit d'utiliser ce qui suit lorsque je commence à taper contains

countDic.contains(where: { ((key: String, value: AnyObject)) -> Bool in
            <#code#>
        })

Je ne comprends pas comment l'utiliser. Je sais qu'à l'intérieur je dois retourner un Bool, mais je ne comprends pas où je dois mettre la chaîne que je cherche. Toute aide serait la bienvenue.

Answer 1

contains(where:) vérifie si un élément de la collection satisfait à le prédicat donné, donc dans votre cas, ce serait

let b = countDic.contains { (key, value) -> Bool in
    value as? String == givenString
}

ou, directement appliqué à la values vue du dictionnaire :

let b = countDic.values.contains { (value) -> Bool in
    value as? String == givenString
}

Dans les deux cas, il est nécessaire (facultativement) d'utiliser l'attribut AnyObject à un String afin de la comparer avec la chaîne de caractères donnée.

Ce serait un peu plus facile avec un dictionnaire de type Dictionary<String, String> parce que les chaînes de caractères sont Equatable , et le contains(element:) peut être utilisée :

let b = countDic.values.contains(givenString)

Answer 2

Puisque vos valeurs sont AnyObject - Any en Swift 3 - vous devez vérifier si la valeur est une chaîne de caractères. Si oui, vérifiez si la valeur contient la sous-chaîne.

let countDic : [String:Any] = ["alpha" : 1, "beta" : "foo", "gamma" : "bar"]

countDic.contains { (key, value) -> Bool in
  if let string = value as? String { return string.contains("oo") }
  return false
}

Cependant, si vous voulez vérifier si l'une des valeurs est égal à (plutôt que contient ) une chaîne de caractères, vous pouvez également utiliser le filter et isEmpty

!countDic.filter { (key, value) -> Bool in
  value as? String == "foo"
}.isEmpty

Answer 3

Vous devrez peut-être apprendre l'utilisation de base de contains(where:) pour Dictionary s en premier :

Pour [String: Int] :

let myIntDict1: [String: Int] = [
    "a" : 1,
    "b" : 101,
    "c" : 2
]
let myIntDict1ContainsIntGreaterThan100 = myIntDict1.contains {
    key, value in //<- `value` is inferred as `Int`
    value > 100 //<- true when value > 100, false otherwise
}
print(myIntDict1ContainsIntGreaterThan100) //->true

Pour [String: String] :

let myStringDict1: [String: String] = [
    "a" : "abc",
    "b" : "def",
    "c" : "ghi"
]
let myStringDict1ContainsWordIncludingLowercaseE = myStringDict1.contains {
    key, value in //<- `value` is inferred as `String`
    value.contains("e") //<- true when value contains "e", false otherwise
}
print(myStringDict1ContainsWordIncludingLowercaseE) //->true

Ainsi, avec [String: AnyObject] :

let myAnyObjectDict1: [String: AnyObject] = [
    "a" : "abc" as NSString,
    "b" : 101 as NSNumber,
    "c" : "ghi" as NSString
]
let myAnyObjectDict1ContainsWordIncludingLowercaseE = myAnyObjectDict1.contains {
    key, value in //<- `value` is inferred as `AnyObject`
    //`AnyObject` may not have the `contains(_:)` method, so you need to check with `if-let-as?`
    if let stringValue = value as? String {
        return value.contains("e") //<- true when value is a String and contains "e"
    } else {
        return false //<- false otherwise
    }
}
print(myAnyObjectDict1ContainsWordIncludingLowercaseE) //->false

Donc, dans votre cas :

let countDic: [String: AnyObject] = [
    "a" : 1 as NSNumber,
    "b" : "no" as NSString,
    "c" : 2 as NSNumber
]
let countDicContainsString = countDic.contains {
    key, value in //<- `value` is inferred as `AnyObject`
    value is String //<- true when value is a String, false otherwise
}
print(countDicContainsString) //->true