Swift: Testen gegen optionalen Wert im Schaltergehäuse

Wie kann ich in Swift einen Fall in eine switch-Anweisung schreiben, die den Wert, der umgeschaltet wird, mit dem Inhalt einer Option vergleicht und den Fall überspringt, wenn die Option enthält nil?

So stelle ich mir das vor:

let someValue = 5
let someOptional: Int? = nil

switch someValue {
case someOptional:
    // someOptional is non-nil, and someValue equals the unwrapped contents of someOptional
default:
    // either, someOptional is nil, or someOptional is non-nil but someValue does not equal the unwrapped contents of someOptional
}

Wenn ich es nur schreiben genau so, beschwert sich der Compiler , dass someOptionalnicht ausgepackt ist, aber wenn ich unwrap es ausdrücklich durch Zugabe !bis zum Ende, ich natürlich einen Laufzeitfehler erhalten jederzeit someOptionalenthält nil. Das Hinzufügen ?statt !würde für mich einen Sinn ergeben (im Geiste der optionalen Verkettung, nehme ich an), lässt aber den Compilerfehler nicht verschwinden (dh das optionale nicht auspacken).

Optional ist einfach enumso:

enum Optional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)

    // ...
}

So können Sie sie wie gewohnt mit "Assoziierten Werten" abgleichen:

let someValue = 5
let someOptional: Int? = nil

switch someOptional {
case .Some(someValue):
    println("the value is \(someValue)")
case .Some(let val):
    println("the value is \(val)")
default:
    println("nil")
}

Wenn Sie eine Übereinstimmung von möchten someValue, verwenden Sie den Schutzausdruck :

switch someValue {
case let val where val == someOptional:
    println(someValue)
default:
    break
}

Und für Swift> 2.0

switch someValue {
case let val where val == someOptional:
    print("matched")
default:
    print("didn't match; default")        
}

Ab Xcode 7 (aus den Beta 1-Versionshinweisen) kann "ein neues x?Muster verwendet werden, um Musterübereinstimmungen mit Optionen als Synonym für .Some(x)". Dies bedeutet, dass in Xcode 7 und höher auch die folgende Variante der Antwort von rintaro funktioniert:

let knownValue = 5

switch someOptional {
case knownValue?:
    // Contents of someOptional are knownValue, defined above.
case let otherValue?:
    // Contents of someOptional are *any* non-nil value not already tested for.
    // Unwrapped contents are assigned to otherValue for use inside this case.
default:
    // someOptional is nil.
}

In Swift 4 können Sie Optional: ExpressibleByNilLiteral von Apple verwenden, um optional zu verpacken

https://developer.apple.com/documentation/swift/optional

Beispiel

enum MyEnum {
    case normal
    case cool
}

etwas

let myOptional: MyEnum? = MyEnum.normal

switch smyOptional {
    case .some(.normal): 
    // Found .normal enum
    break

    case .none: 
    break

    default:
    break
}

keiner

let myOptional: MyEnum? = nil

switch smyOptional {
    case .some(.normal): 
    break

    case .none: 
    // Found nil
    break

    default:
    break
}

Standard

let myOptional: MyEnum? = MyEnum.cool

switch smyOptional {
    case .some(.normal): 
    break

    case .none: 
    break

    default:
    // Found .Cool enum
    break
}

Aufzählung mit Wert

enum MyEnum {
    case normal(myValue: String)
    case cool
}

ein Wert

let myOptional: MyEnum? = MyEnum.normal("BlaBla")

switch smyOptional {
case .some(.normal(let myValue)) where myValue == "BlaBla":
    // Here because where find in my myValue "BlaBla"
    break

// Example for get value
case .some(.normal(let myValue)):
    break

// Example for just know if is normal case enum
case .some(.normal):
    break

case .none:
    break

default:

    break
}