Swift: menguji nilai opsional dalam kasus sakelar

Di Swift, bagaimana saya bisa menulis kasus dalam pernyataan switch yang menguji nilai yang dialihkan dengan konten opsional , melewati kasus jika opsional berisi nil?

Begini cara saya membayangkan ini mungkin terlihat:

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
}

Jika saya hanya menulisnya persis seperti ini, kompilator mengeluh bahwa someOptionaltidak terbungkus, tetapi jika saya secara eksplisit membukanya dengan menambahkan di !bagian akhir, saya tentu saja mendapatkan kesalahan runtime setiap saat someOptionalberisi nil. Menambahkan ?alih-alih !akan masuk akal bagi saya (dalam semangat rangkaian opsional, saya kira), tetapi tidak membuat kesalahan kompiler hilang (yaitu tidak benar-benar membuka bungkus opsional).

Opsional adalah enumseperti ini:

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

    // ...
}

Jadi, Anda dapat mencocokkannya seperti biasa dengan pola pencocokan "Nilai Terkait" :

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

Jika Anda ingin cocok someValue, gunakan ekspresi penjaga :

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

Dan untuk Swift> 2.0

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

Mulai Xcode 7, " x?pola baru dapat digunakan untuk mencocokkan pola dengan pilihan sebagai sinonim untuk .some(x)". Ini berarti bahwa di Swift 2 dan yang lebih baru, variasi jawaban rintaro berikut ini juga akan berfungsi:

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

Di Swift 4 Anda dapat menggunakan Opsional: ExpressibleByNilLiteral dari Apple untuk membungkus opsional

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

Contoh

enum MyEnum {
    case normal
    case cool
}

beberapa

let myOptional: MyEnum? = MyEnum.normal

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

    case .none: 
    break

    default:
    break
}

tidak ada

let myOptional: MyEnum? = nil

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

    case .none: 
    // Found nil
    break

    default:
    break
}

default

let myOptional: MyEnum? = MyEnum.cool

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

    case .none: 
    break

    default:
    // Found .Cool enum
    break
}

Enum dengan nilai

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

beberapa nilai

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
}