Determinar si el diccionario Swift contiene clave y obtener alguno de sus valores

Actualmente estoy usando los siguientes fragmentos de código (torpes) para determinar si un diccionario Swift (no vacío) contiene una clave determinada y para obtener un (cualquier) valor del mismo diccionario.

¿Cómo se puede poner esto más elegantemente en 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
}

No necesita ningún código especial para hacer esto, porque es lo que un diccionario ya hace. Cuando busca dict[key], sabe si el diccionario contiene la clave, porque el Opcional que obtiene no lo está nil(y contiene el valor).

Entonces, si solo desea responder la pregunta de si el diccionario contiene la clave, pregunte:

let keyExists = dict[key] != nil

Si desea el valor y sabe que el diccionario contiene la clave, diga:

let val = dict[key]!

Pero si, como suele suceder, no sabe que contiene la clave, desea obtenerla y usarla, pero solo si existe, use algo como if let:

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

¿Por qué no simplemente verificar dict.keys.contains(key)? La comprobación de dict[key] != nilno funcionará en los casos en que el valor sea nulo. Como con un diccionario [String: String?]por ejemplo.

La respuesta aceptada let keyExists = dict[key] != nilno funcionará si el Diccionario contiene la clave pero tiene un valor nulo.

Si desea asegurarse de que el Diccionario no contiene la clave, use esto (probado en Swift 4).

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

Parece que obtuvo lo que necesita de @matt, pero si desea una forma rápida de obtener un valor para una clave, o simplemente el primer valor si esa clave no existe:

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

Tenga en cuenta que no garantiza lo que realmente obtendrá como primer valor, simplemente sucede que en este caso devuelve "rojo".

if dictionayTemp["quantity"] != nil
    {

  //write your code
    }

Mi solución para una implementación de caché que almacena NSAttributedString opcional:

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

Esto es lo que funciona para mí en Swift 3

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