Determinare se il dizionario Swift contiene chiave e ottenere uno dei suoi valori

Attualmente sto usando i seguenti (goffi) pezzi di codice per determinare se un dizionario Swift (non vuoto) contiene una determinata chiave e per ottenere un (qualsiasi) valore dallo stesso dizionario.

Come si può mettere questo in modo più elegante in 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
}

Non hai bisogno di alcun codice speciale per farlo, perché è quello che fa già un dizionario. Quando si recupera dict[key]si sa se il dizionario contiene la chiave, perché l'opzionale che si ottiene indietro non è nil(e contiene il valore).

Quindi, se vuoi solo rispondere alla domanda se il dizionario contiene la chiave, chiedi:

let keyExists = dict[key] != nil

Se vuoi il valore e sai che il dizionario contiene la chiave, dì:

let val = dict[key]!

Ma se, come al solito, non sai che contiene la chiave - vuoi prenderla e usarla, ma solo se esiste - usa qualcosa come if let:

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

Perché non controllare semplicemente dict.keys.contains(key)? Il controllo per dict[key] != nilnon funzionerà nei casi in cui il valore è zero. Come [String: String?]ad esempio un dizionario .

La risposta accettata let keyExists = dict[key] != nilnon funzionerà se il dizionario contiene la chiave ma ha un valore pari a zero.

Se vuoi essere sicuro che il Dizionario non contenga affatto la chiave, utilizzalo (testato in Swift 4).

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

Sembra che tu abbia ottenuto quello che ti serve da @matt, ma se vuoi un modo rapido per ottenere un valore per una chiave, o solo il primo valore se quella chiave non esiste:

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”}

Nota, nessuna garanzia di ciò che effettivamente otterrai come primo valore, in questo caso capita solo di restituire "rosso".

if dictionayTemp["quantity"] != nil
    {

  //write your code
    }

La mia soluzione per un'implementazione della cache che memorizza NSAttributedString opzionale:

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

Ecco cosa funziona per me su Swift 3

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