Usare “se let …” con molte espressioni

Questo idioma di Swift ha senso

if let x = someDict[someKey] { ... } 

Tuttavia, quello che voglio veramente è

 if let x = someDict[someKey], y = someDict[someOtherKey] { ... } 

Come scritto questo non è corretto, ma questa idea è ansible?

Aggiornamento per Swift 1.2

Da Swift 1.2, if let consente di scartare più opzioni, così ora puoi semplicemente scrivere questo, come nel tuo esempio:

 if let x = someDict[someKey], y = someDict[someOtherKey] { … } 

Puoi anche intercalare condizioni come:

 if let x = someDict[someKey] where x == "value", y = someDict[someOtherKey] { … } 

Questo era valido prima di Swift 1.2

Ecco come lo faresti senza un brutto involucro di forza:

 switch (dict["a"], dict["b"]) { case let (.Some(a), .Some(b)): println("match") default: println("no match") } 

Ancora piuttosto prolisso, in realtà.

Funziona perché un tipo facoltativo del modulo Type? è in realtà una abbreviazione di Optional , che è un enum che appare grosso modo come questo:

 enum Optional { case None case Some(T) } 

È quindi ansible utilizzare la corrispondenza del modello come per qualsiasi altra enumerazione.

Edit: Ho visto persone scrivere funzioni di aiuto come questa (scusate la mancanza di attribuzione, non ricordo dove l’ho visto):

 func unwrap(a: A?, b: B?) -> (A, B)? { switch (a, b) { case let (.Some(a), .Some(b)): return (a, b) default: return nil } } 

Quindi puoi continuare a usare il costrutto if let , cioè in questo modo:

 if let (a, b) = unwrap(dict["a"], dict["b"]) { println("match: \(a), \(b)") } else { println("no match") } 

In Swift 1.2 (parte di Xcode 6.3), il costrutto di binding facoltativo if let può associare più optionals , usando la stessa syntax trovata in questa domanda.

 if let x = someDict[someKey], y = someDict[someOtherKey] { ... } 

Puoi anche estenderlo con condizioni sui valori associati:

 if let a = foo(), b = bar(), a < b, let c = baz() { ... } 

Il modello di switch per la gestione del binding multiplo opzionale (come mostrato in questa risposta ) rimane valido. Sebbene con if let condizioni di guardia potresti trovare un minor numero di casi d'uso, è comunque lì nel caso in cui tu voglia, ad esempio, gestire casi di più collegamenti opzionali con comportamenti diversi quando diversi sottoinsiemi degli optionals che stai testando sono nulli.

(Nota: prima di Swift 3, if let a = ..., b = ..., a < b usato where dividere l'associazione dal condizionale.)

In Swift1.2 è ansible utilizzare più associazioni opzionali.

 if let x = someDict[someKey], y = someDict[someOtherKey] { ... } 

Si noti che y è implicitamente dichiarato come costante, che è lo stesso di x.Il codice precedente è equivalente al seguente.

 if let x = someDict[someKey],let y = someDict[someOtherKey] { ... } 

Se vuoi dichiarare esplicitamente y come tipo mutabile, digita var prima del nome della variabile.

 if let x = someDict[someKey],var y = someDict[someOtherKey] { ... }