Swift: Anahtar durumunda isteğe bağlı değere karşı test etme

Swift'de, isteğe bağlı bir içeriğin içeriğine göre değiştirilen değeri test eden bir anahtar deyiminde, isteğe bağlı varsa , durumu atlayarak nasıl bir durum yazabilirim nil?

İşte bunun nasıl görünebileceğini hayal ediyorum:

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
}

Tam olarak böyle yazarsam, derleyici paketlenmemiş olduğundan şikayet eder someOptional, ancak !sonuna ekleyerek açıkça açarsam , elbette her zaman someOptionaliçerdiği bir çalışma zamanı hatası alırım nil. ?Bunun yerine eklemek !bana biraz mantıklı gelebilir (sanırım isteğe bağlı zincirleme ruhu içinde), ancak derleyici hatasını ortadan kaldırmaz (yani isteğe bağlı olanı açmaz).

İsteğe bağlı, enumşunun gibidir:

enum Optional<T> : Reflectable, NilLiteralConvertible {
    case none
    case some(T)

    // ...
}

Böylece, bunları her zamanki "İlişkili Değerler" eşleme modelleriyle eşleştirebilirsiniz:

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")
}

Eşleştirme istiyorsanız someValue, koruma ifadesini kullanarak :

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

Swift> 2.0 için

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

Xcode 7'den itibaren, " x?eşanlamlı olarak opsiyonellere karşı model eşleştirmek için yeni bir model kullanılabilir .some(x)". Bu, Swift 2 ve sonrasında rintaro'nun cevabının aşağıdaki varyasyonunun da işe yarayacağı anlamına gelir :

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 kullanabilirsiniz ExpressibleByNilLiteral: İsteğe isteğe wrappe için Apple

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

Misal

enum MyEnum {
    case normal
    case cool
}

biraz

let myOptional: MyEnum? = MyEnum.normal

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

    case .none: 
    break

    default:
    break
}

Yok

let myOptional: MyEnum? = nil

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

    case .none: 
    // Found nil
    break

    default:
    break
}

varsayılan

let myOptional: MyEnum? = MyEnum.cool

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

    case .none: 
    break

    default:
    // Found .Cool enum
    break
}

Değer içeren numaralandırma

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

biraz değer

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
}