Usare “se let …” con molte espressioni

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