desenvolver múltiples opcionales en la sentencia if

Quiero desenvolver dos opciones en una instrucción if, pero el comstackdor presenta una queja sobre una expresión esperada después del operador en la constante de contraseña. ¿Cuál podría ser la razón?

if let email = self.emailField?.text && let password = self.passwordField?.text { //do smthg } 

Hecho en Swift.

Una gran noticia. Ahora Swift 1.2 (XCode 6.3 beta, lanzado el 9/9/15) admite el desempaquetado de múltiples opcionales en una sola línea.

No se necesita más coincidencia de patrón de tupla / interruptor. De hecho, está muy cerca de la syntax original sugerida (¡gracias por escuchar, Apple!)

 if let email = emailField?.text, password = passwordField?.text { } 

Otra cosa agradable es que también puede agregar where una “condición de protección”:

 var email: String? = "baz@bar.com" var name: String? = "foo" if let n = name, e = email where contains(e, "@") { println("name and email exist, email has @") } 

Referencia: XCode 6.3 Beta Release Notes

Actualización para Swift 3:

 if let email = emailField?.text, let password = passwordField?.text { } 

cada variable debe ir precedida de una palabra clave let

¿Qué tal envolver los opcionales en una tupla y usar el interruptor para emparejar el patrón?

 switch (self.emailField?.text, self.passwordField?.text) { case let (.Some(email), .Some(password)): // unwrapped 'email' and 'password' strings available here default: break } 

Definitivamente es un poco más ruidoso, pero al menos también podría combinarse con una cláusula where .

El uso

 if let x = y { } 

no es equivalente a

 if (let x = y) { // this is actually not allowed } 

“if let” es efectivamente una palabra clave de dos palabras, que es equivalente a

 if y != nil { let x = y! // rest of if let block } 

Antes de Swift 1.2

Al igual que @James, también he creado una función de unwrap , pero esta usa el flujo de control de if let para controlar, en lugar de usar un cierre:

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

Esto se puede usar así:

 if let (email, password) = unwrap(self.emailField?.text, self.passwordField?.text) { // do something } 

De: https://gist.github.com/tomlokhorst/f9a826bf24d16cb5f6a3

Tenga en cuenta que si desea manejar más casos (como cuando uno de los dos campos es nulo), estará mejor con una statement de switch .

No puedo explicar por qué el código anterior no funciona, pero este sería un buen reemplazo:

 if let email = self.emailField?.text { if let password = self.passwordField?.text { //do smthg } } 

Swift 4

 if let suggestions = suggestions, let suggestions1 = suggestions1 { XCTAssert((suggestions.count > suggestions1.count), "TEST CASE FAILED: suggestion is nil. delete sucessful"); } 

Basado en la respuesta de @ Joel, he creado un método de ayuda.

 func unwrap(a:T?, b:U?, handler:((T, U) -> ())?) -> Bool { switch (a, b) { case let (.Some(a), .Some(b)): if handler != nil { handler!(a, b) } return true default: return false } } 

// uso

 unwrap(a, b) { println("\($0), \($1)") }