Ustalanie, czy słownik Swift zawiera klucz i uzyskiwanie którejkolwiek z jego wartości

Obecnie używam następujących (niezdarnych) fragmentów kodu do ustalenia, czy (niepusty) słownik Swift zawiera dany klucz i do uzyskania jednej (dowolnej) wartości z tego samego słownika.

Jak bardziej elegancko umieścić to w Swift?

// excerpt from method that determines if dict contains key
if let _ = dict[key] {
    return true
}
else {
    return false
}

// excerpt from method that obtains first value from dict
for (_, value) in dict {
    return value
}

Nie potrzebujesz do tego żadnego specjalnego kodu, ponieważ to właśnie robi już słownik. Gdy pobierasz dict[key], wiesz, czy słownik zawiera klucz, ponieważ opcjonalny, który otrzymasz, nie jest nil(i zawiera wartość).

Jeśli więc chcesz tylko odpowiedzieć na pytanie, czy słownik zawiera klucz, zapytaj:

let keyExists = dict[key] != nil

Jeśli chcesz tę wartość i wiesz, że słownik zawiera klucz, powiedz:

let val = dict[key]!

Ale jeśli, jak to zwykle bywa, nie wiesz, że zawiera on klucz - chcesz go pobrać i użyć, ale tylko jeśli istnieje - użyj czegoś takiego if let:

if let val = dict[key] {
    // now val is not nil and the Optional has been unwrapped, so use it
}

Dlaczego nie po prostu sprawdzić dict.keys.contains(key)? Sprawdzanie dict[key] != nilnie zadziała w przypadkach, gdy wartość wynosi zero. Jak [String: String?]na przykład w słowniku .

Akceptowana odpowiedź let keyExists = dict[key] != nilnie zadziała, jeśli Słownik zawiera klucz, ale ma wartość zero.

Jeśli chcesz mieć pewność, że słownik nie zawiera klucza, skorzystaj z niego (testowane w Swift 4).

if dict.keys.contains(key) {
  // contains key
} else { 
  // does not contain key
}

Wygląda na to, że masz to, czego potrzebujesz od @matt, ale jeśli chcesz szybko uzyskać wartość klucza lub po prostu pierwszą wartość, jeśli ten klucz nie istnieje:

extension Dictionary {
    func keyedOrFirstValue(key: Key) -> Value? {
        // if key not found, replace the nil with 
        // the first element of the values collection
        return self[key] ?? first(self.values)
        // note, this is still an optional (because the
        // dictionary could be empty)
    }
}

let d = ["one":"red", "two":"blue"]

d.keyedOrFirstValue("one")  // {Some "red"}
d.keyedOrFirstValue("two")  // {Some "blue"}
d.keyedOrFirstValue("three")  // {Some "red”}

Uwaga: nie ma gwarancji, co faktycznie otrzymasz jako pierwszą wartość, po prostu w tym przypadku zwraca się „czerwony”.

if dictionayTemp["quantity"] != nil
    {

  //write your code
    }

Moje rozwiązanie dla implementacji pamięci podręcznej przechowującej opcjonalne NSAttributString:

public static var attributedMessageTextCache    = [String: NSAttributedString?]()

    if attributedMessageTextCache.index(forKey: "key") != nil
    {
        if let attributedMessageText = TextChatCache.attributedMessageTextCache["key"]
        {
            return attributedMessageText
        }
        return nil
    }

    TextChatCache.attributedMessageTextCache["key"] = .some(.none)
    return nil

Oto, co działa dla mnie w Swift 3

let _ = (dict[key].map { $0 as? String } ?? "")