Cómo combinar dos arreglos que son opcionales

Tener algunos problemas combinando dos matrices que son opcionales. No arrays que contengan elementos opcionales.

let a : [String]? = ["foo"] let b : [String]? = nil 

o

 let a : [String]? = nil let b : [String]? = nil 

o

 let a : [String]? = ["foo"] let b : [String]? = ["bar"] 

Obviamente, esto no funciona porque las matrices son opcionales

 let combinedArrays : [String]? = a + b 

¿Hay una manera más concisa que el enfoque tradicional if let usar methods funcionales u otro método más limpio para combinar las matrices ayb?

Actualización: el ejemplo anterior es artificial pero a continuación se muestra un ejemplo más real de lo que intentaba hacer:

 func pinToAllSidesOfSuperView() -> [NSLayoutConstraint]? { let horizontalConstraints : [NSLayoutConstraint]? = pinViewToLefAndRight() let verticalConstraints : [NSLayoutConstraint]? = pinViewToTopAndBottom() return horizontalConstraints + verticalConstraints } 

Sería bueno devolver un valor de retorno opcional frente a una matriz vacía, por lo que la persona que llama del método todavía puede usar las funciones opcionales (es decir, if let , guard , etc.) frente a la simple comprobación si Array.isEmpty .

No estoy seguro de si esto es lo suficientemente prolijo, pero de todos modos dará el set de cadenas combinadas

 var combined = (a ?? []) + (b ?? []) 

Una de las muchas otras opciones es convertirla en una propiedad calculada y devolver cero si la matriz combinada está vacía

 var combined:[String]?{ let c = (a ?? []) + (b ?? []) return c.isEmpty ? nil : c } 

En lugar de nada, ¿solo los convierte en matrices vacías?

Lo haría así:

 func +<T>(lhs: Array<T>?, rhs: Array<T>?) -> Array<T>? { switch (lhs, rhs) { case (nil, nil): return nil case (nil, _): return rhs case (_, nil): return lhs default: return lhs! + rhs! } } let foo: [Int]? = nil let bar: [Int]? = [1] foo + foo // -> nil foo + bar // -> [1] bar + foo // -> [1] bar + bar // -> [1, 1] 

Tome una de estas soluciones:

1) un poco feo

 let a : [String]? = ["foo"] let b : [String]? = ["bar"] let c = (a != nil ? a! : []) + (b != nil ? b! : []) // ["foo", "bar"] 

2) Recargar + operador para [String]?

 func +(a: [String]?, b: [String]?) -> [String] { var s1 = a != nil ? a! : [] let s2 = b != nil ? b! : [] for n in s2 { s1.append(n) } return s1 } let a : [String]? = ["foo"] let b : [String]? = ["bar"] let c : [String]? = nil let result1 = a + b // ["foo", "bar"] let result2 = a + c // ["foo"] 

Por cierto En el operador principal no puedes escribir algo como:

 func +(a: [String]?, b: [String]?) -> [String] { return (a != nil ? a! : []) + (b != nil ? b! : []) } 

Como ves causará una recursión infinita, así que utilicé cycle and append()