Swift switch-Anweisung auf ein Tupel der optionale Boolesche Werte

Ich habe Schwierigkeiten, herauszufinden, wie man Optionen innerhalb eines Tupels innerhalb einer switch. Der unten .Einige(lassen ...) ... - syntax arbeitet als non-Tupel, aber in einem Tupel ich erwarten separator Sachen 🙁

var dict = Dictionary<String,Bool>()
dict["a"] = true

switch (dict["a"],dict["b") {
case (.Some(let a) where !a, .Some(let b) where b):
  println("false/nil, true")
case (.Some(let a) where a, .Some(let b) where !b):
  println("true, false/nil")

Möchte ich vermeiden, tun Sie den folgenden

    if let a = self.beaconList["a"] {
        if let b = self.beaconList["b"] {
            //a, b
        } else {
            //a, !b
        }
    } else {
        if let b = self.beaconList["b"] {
            //!a, b
        } else {
            //!a, !b
        }
    }
InformationsquelleAutor nflacco | 2014-06-27
  1. 17

    Gibt es eine Reihe von Möglichkeiten, dies zu tun, aber fix die syntax von dem, was Sie zu tun versuchen buchstäblich, müssen Sie explizit unbox die Optionale, entweder indem ein Abgleich mit .Einige(false), oder unwrapping es mit ! (ich denke, das ist Art von seltsam, wie Sie sehen werden)

    var dict = Dictionary<String,Bool>()
dict["a"] = true
dict["c"] = false

func matchOneOrTheOtherWithOptionals(a: Bool?, b: Bool?) -> String {
    switch (a, b) {
    case (.Some(true), let b) where b == .None || !b!: //gross
        return "a was true, but b was None or false"
    case (let a, .Some(true)) where a == .None || a == .Some(false):
        return "a was None or false and b was true"
    default:
        return "They both had a value, or they were both missing a value"
    }
}

matchOneOrTheOtherWithOptionals(true, .None) //"a was true, but b was None or false"
matchOneOrTheOtherWithOptionals(true, false) //"a was true, but b was None or false"
matchOneOrTheOtherWithOptionals(.None, true) //"a was None or false and b was true"
matchOneOrTheOtherWithOptionals(false, true) //"a was None or false and b was true"

matchOneOrTheOtherWithOptionals(false, false) //"They both had a value, or they were both missing a value"
matchOneOrTheOtherWithOptionals(true, true) //"They both had a value, or they were both missing a value"
matchOneOrTheOtherWithOptionals(.None, .None) // "They both had a value, or they were both missing a value"

    Könnte man auch versuchen, die folgenden:

    func noneToFalse(bool: Bool?) -> Bool {
    if let b = bool {
        return b
    } else {
        return false
    }
}

func matchOneOrTheOther(a: Bool, b: Bool) -> String {
    switch (a, b) {
    case (true, false):
        return "a is true, b was false or None"
    case (false, true):
        return "a was false/None, b was true"
    default:
        return "both were true, or both were false/None"
    }
}

matchOneOrTheOther(noneToFalse(dict["a"]), noneToFalse(dict["b"]))

    Hier ist eine Zusammenfassung von dem Spielplatz, die ich verwendet, beim schreiben dieser Antwort: https://gist.github.com/bgrace/b8928792760159ca58a1

    • Sie können vermeiden, die !b! grossness, indem Sie sowohl die a & b args implizit unwrapped optionals mit matchOneOrTheOtherWithOptionals(a: Bool!, b: Bool!). Dann ist dein Fall wheres werden nur where b == .none || !b: & where a == .none || !a:. Dies ist ganz sicher hier, weil Sie explizit die überprüfung sowohl a & b für .none vor der Verwendung des umschlossenen booleschen Wert.
    InformationsquelleAutor Brett
  2. 2

    Vereinfachen!

    var dict = Dictionary<String,String>()

dict["a"] = "the letter a"

switch (dict["a"],dict["b"]) {
  case (.None, let b):
    println("false/nil, true \(b)")
  case (let a, .None):
    println("true, false/nil \(a)")
  default:
    println("don't know") 
}
    • OP hier: ich möchte ein match auf null/false (das .Keiner hat, denke ich), oder wahr. Leider "lassen" oder "lasse b" ermöglicht auch nil/false :(, also muss ich einen anderen Weg finden, dies zu tun.
    InformationsquelleAutor Robert Diamond
Schreibe einen Kommentar