Determinando se o dicionário Swift contém chave e obtendo qualquer um de seus valores

Atualmente, estou usando os seguintes (desajeitados) trechos de código para determinar se um dicionário Swift (não vazio) contém uma determinada chave e para obter um (qualquer) valor do mesmo dicionário.

Como se pode colocar isso de maneira mais elegante no 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
}

Você não precisa de nenhum código especial para fazer isso, porque é o que um dicionário já faz. Quando você buscar dict[key]você sabe se o dicionário contém a chave, porque o opcional que você recebe de volta não é nil(e contém o valor).

Portanto, se você quiser apenas responder à pergunta se o dicionário contém a chave, pergunte:

let keyExists = dict[key] != nil

Se você deseja o valor e sabe que o dicionário contém a chave, diga:

let val = dict[key]!

Mas se, como geralmente acontece, você não sabe que ela contém a chave - você deseja buscá-la e usá-la, mas apenas se existir -, 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 que não simplesmente procurar dict.keys.contains(key)? A verificação dict[key] != nilnão funcionará nos casos em que o valor for nulo. Como em um dicionário, [String: String?]por exemplo.

A resposta aceita let keyExists = dict[key] != nilnão funcionará se o Dicionário contiver a chave, mas tiver um valor nulo.

Se você quiser ter certeza de que o Dicionário não contém a chave, use isso (testado no Swift 4).

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

Parece que você obteve o que precisa em @matt, mas se desejar uma maneira rápida de obter um valor para uma chave ou apenas o primeiro valor, se essa chave não existir:

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

Observe que não há garantia do que você realmente obterá como o primeiro valor; neste caso, acontece apenas para retornar "vermelho".

if dictionayTemp["quantity"] != nil
    {

  //write your code
    }

Minha solução para uma implementação de cache que armazena 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

Aqui está o que funciona para mim no Swift 3

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