Bepalen of Swift-woordenboek een sleutel bevat en een van de waarden ervan verkrijgen

Ik gebruik momenteel de volgende (onhandige) stukjes code om te bepalen of een (niet-leeg) Swift-woordenboek een bepaalde sleutel bevat en om één (willekeurige) waarde uit hetzelfde woordenboek te verkrijgen.

Hoe kan je dit eleganter in Swift zetten?

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

Antwoord 1, autoriteit 100%

Je hebt geen eenspeciale code nodig om dit te doen, omdat het is wat een woordenboek al doet. Wanneer u dict[key]ophaalt, weetof het woordenboek de sleutel bevat, omdat het Optioneel dat u terugkrijgt niet nilis (en het bevat de waarde).

Dus, als je alleende vraag wilt beantwoorden of het woordenboek de sleutel bevat, vraag dan:

let keyExists = dict[key] != nil

Als je de waarde wilt en je weetdat het woordenboek de sleutel bevat, zeg dan:

let val = dict[key]!

Maar als je, zoals gewoonlijk gebeurt, niet weet dat het de sleutel bevat – je wilt het ophalen en gebruiken, maar alleen als het bestaat – gebruik dan iets als if let:

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

Antwoord 2, autoriteit 15%

Waarom niet gewoon controleren op dict.keys.contains(key)?
Controleren op dict[key] != nilzal niet werken in gevallen waar de waarde nihil is.
Net als bij een woordenboek [String: String?]bijvoorbeeld.

Antwoord 3, autoriteit 12%

Het geaccepteerde antwoord let keyExists = dict[key] != nilwerkt niet als de Dictionary de sleutel bevat maar de waarde nul heeft.

Als u er zeker van wilt zijn dat de Dictionary de sleutel helemaal niet bevat, gebruikt u deze (getest in Swift 4).

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

Antwoord 4

Het lijkt erop dat je hebt gekregen wat je nodig hebt van @matt, maar als je een snelle manier wilt om een ​​waarde voor een sleutel te krijgen, of alleen de eerste waarde als die sleutel niet bestaat:

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

Let op, er is geen garantie wat u daadwerkelijk als eerste waarde krijgt, in dit geval gebeurt het gewoon dat u “rood” retourneert.

Antwoord 5

Mijn oplossing voor een cache-implementatie die optionele NSAttributedString opslaat:

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

Antwoord 6

if dictionayTemp["quantity"] != nil
    {
  //write your code
    }

Antwoord 7

Als u de waarde van de sleutel wilt retourneren, kunt u deze extensie gebruiken

extension Dictionary {
    func containsKey(_ key: Key) -> Value? {
        if let index = index(forKey: key){
            return self.values[index]
        }
        return nil
    }
}