Czy mogę w jakiś sposób użyć opcjonalnego powiązania dla wielu zmiennych w jednym wierszu w Swift?

Question

Czy mogę w jakiś sposób użyć opcjonalnego powiązania dla wielu zmiennych w jednym wierszu w Swift? Muszę zrobić coś takiego:

if let foo = fooOptional && let bar = barOptional { 
    // ... 
} 

Answer 1

Aktualizacja Swift 1.2:

Od Swift 1.2 (Xcode 6.3 Beta), można rozpakować wieloma ewentualne, z if let:

if let foo = fooOptional, bar = barOptional { 
    println("\(foo), \(bar)") 
} 

---

Przed Swift 1.2

Nie można z if, ale można z switch użyciu "Value-Binding Pattern":

switch (fooOptional, barOptional) { 
case let (.Some(foo), .Some(bar)): 
    println("\(foo), \(bar)") 
default: 
    break 
} 

Answer 2

To bardzo rozsądna prośba o ulepszenie, ale w obecnej sytuacji nie można tego zrobić. Jest wiele różnych powodów, ale sposób, w jaki lubię o tym myśleć, jest następujący: if let to naprawdę jedno słowo. To dwa słowa, ale kolokacja to coś specjalnego, jakby samo słowo kluczowe. Sam w sobie, if ma inne znaczenie; samo w sobie, let ma inne znaczenie. Dlatego nie można umieścić osobnego let później w takiej linii.

Powoduje to, że często kończę kaskadami zagnieżdżonych klauzul if let. Jestem pewien, że powodem twojego pytania jest to, że ty też to robisz i chciałbyś tego uniknąć. Ale nie możesz. Jedną z możliwości jest całkowite pominięcie if let, odfiltrowanie swoich opcji i mieć nadzieję, że nie ulegniesz awarii, gdy jeden z nich będzie zerowy.

Answer 3

To trochę niezgrabne, ale można to zrobić z switch na krotki swoich zmiennych:

var fooOptional: String? = "foo" 
var barOptional: String? = "bar" 

switch (fooOptional, barOptional) { 
case let (.Some(foo), .Some(bar)): 
    println(foo + bar) 
default: 
    break 
} 

Czas Używam tego wiercenia w dół do zagnieżdżonego słownika , jak wielki obiekt JSON - to super, bo można obsługiwać każdy przypadek błędu oddzielnie:

switch (dict["foo"], dict["foo"]?["bar"], dict["foo"]?["bar"]?["baz"]) { 
case let (.Some(foo), .Some(bar), .Some(baz)): 
    // do things 
case (.None, _, _): 
    // no foo 
case (_, .None, _): 
    // no bar 
default: 
    // no baz 
} 

Answer 4

Przed Swift 1.2

Lubię używać do tego oświadczenia switch, szczególnie jeśli chcesz obsłużyć cztery różne przypadki.

Jednakże, jeśli jesteś zainteresowany jedynie w przypadku, gdy oba OPCJE są Some, można też to zrobić:

if let (firstName, lastName) = unwrap(optionalFirstName, optionalLastName) { 
    println("Hello \(firstName) \(lastName)!") 
} 

Gdzie to jest definicja funkcji unwrap:

func unwrap<T1, T2>(optional1: T1?, optional2: T2?) -> (T1, T2)? { 
    switch (optional1, optional2) { 
    case let (.Some(value1), .Some(value2)): 
    return (value1, value2) 
    default: 
    return nil 
    } 
} 

Więcej przeciążeń: https://gist.github.com/tomlokhorst/f9a826bf24d16cb5f6a3