Introducción
Los closures son bloques de código que pueden ser pasados por parámetro a otras funciones a lo largo del código. Una de las ventajas que proveen es que son capaces de capturar y guardar referencias de las constantes y variables del contexto en que son definidos.
Las funciones, vistas en una entrada anterior, son casos especiales de closures, que tienen la característica de estar definidos bajo un nombre. Sin embargo, en algunos casos es necesario escribir algoritmos más cortos y específicos que no van a ser reutilizados o invocados varias veces sino que solo tienen sentido en un ámbito en particular. El caso más claro es el de funciones que aceptan funciones por parámetro, y que al momento de invocarlos se les pasa closures, sin nombre ni una declaración completa, sino simplemente el código de su implementación.
Las expresiones de cerraduras proveen muchas optimizaciones en su sintaxis permitiendo simplificarlas sin perder el sentido y la claridad.
Para hacer una analogía con otros lenguajes, una cerradura es similar a una expresión lambda o bloques de Objective C.
Sintaxis
La forma general de una cerradura es la siguiente:
{ (parametros) -> tipo de retorno in
sentencias
}
Como se puede observar, su sintaxis es la de una función con la diferencia de que no posee un nombre que la defina y que agrega la palabra in para separar su declaración de su implementación. Los parámetros pueden ser in-out pero no pueden tener valores por defecto.
Supongamos que tenemos la siguiente función:
func calcular(a:Int, b:Int, operacion:(Int,Int) -> Int) {
print(“El resultado es \(operacion(a,b))”)
}
Para poder invocarla, necesitamos pasar dos números enteros y una función que reciba dos enteros y devuelva otro. Una posibilidad de hacerlo es definir una función que cumpla con el tipo del parámetro operación y pasarla por parámetro:
func sumar(a:Int, b:Int) -> Int {
return a+b
}
calcular(a: 6, b: 10, operacion: sumar)
//Devuelve:
//El resultado es 16
De esta forma, podemos ejecutar una función u otra simplemente especificando el nombre de la función como último parámetro:
func sumar(a:Int, b:Int) -> Int {
return a+b
}
func multiplicar(a:Int, b:Int) -> Int {
return a*b
}
func calcular(a:Int, b:Int, operacion:(Int,Int) -> Int) {
print("El resultado es \(operacion(a,b))")
}
calcular(a: 6, b: 10, operacion: sumar)
calcular(a: 6, b: 10, operacion: multiplicar)
// El resultado es 16
// El resultado es 60
Sin embargo, hacerlo de esta manera implica generar código que posiblemente no se vuelva a reutilizar y requiere de varias líneas para simplemente realizar una operación aritmética entre dos números.
En estos casos, es donde los closures vienen a ayudarnos a definir código mas específico y, al mismo tiempo, nos permite ahorrarnos algunas líneas. Una forma de hacer lo mismo usando closures podría ser:
func calcular(a:Int, b:Int, operacion:(Int, Int) -> Int) {
print("El resultado es \(operacion(a,b))")
}
calcular(a: 6, b: 10, operacion: {(numero1:Int, numero2:Int) -> Int in return numero1 + numero2 })
calcular(a: 6, b: 10, operacion: {(numero1:Int, numero2:Int) -> Int in return numero1 * numero2 })
Simplificando la sintaxis
Lo primero que se puede simplificar al momento de usar un closure en la invocación de una función son los tipos de dato de sus parámetros y valor de retorno. En este sentido, Swift es capaz de inferir que el closure que estamos pasando debe cumplir con la forma (Int,Int) -> Int, por lo tanto no es necesario dejar explícitos los tipos de dato ni la flecha:
calcular(a: 6, b: 10, operacion: {(numero1, numero2) in
return numero1 + numero2
})
calcular(a: 6, b: 10, operacion: {(numero1, numero2) in
return numero1 * numero2
})
Además, los closures de una sola línea pueden omitir la palabra return ya que se sabe que la operación que se va a realizar dentro de ella se va a usar para devolver el dato que se espera:
calcular(a: 6, b: 10, operacion: {(numero1, numero2) in
numero1 + numero2
})
calcular(a: 6, b: 10, operacion: {(numero1, numero2) in
numero1 * numero2
})
Se dice que los closures son de una línea, o single-expression, cuando contienen una única operación independientemente de que hagamos cortes de línea por un tema de claridad al momento de leer el código.
Otra opción que podemos usar son los nombres de argumento corto que provee Swift para identificar a los argumentos, usando los nombres $0, $1, $2, etc, para hacer referencia al primer argumento, segundo, tercero, etc. Al mismo tiempo, se elimina la necesidad de usar la palabra reservada in ya que no se requiere separar la zona de argumentos de la de implementación:
calcular(a: 6, b: 10, operacion: { $0 + $1 })
calcular(a: 6, b: 10, operacion: { $0 * $1 })
Existe una forma aún más corta de escribir el closure anterior y es haciendo uso de los métodos de operador. Toda clase o struct puede definir su propia implementación de los operadores existentes haciendo uso de una técnica llamada sobrecarga. En el caso del tipo de dato Int (que internamente es un struct) tiene definido al operador + como una función del tipo (Int, Int) -> Int que es justamente lo que espera el parámetro calcular. Por lo tanto, la invocación anterior puede hacerse de la siguiente manera:
calcular(a: 6, b: 10, operacion: +)
calcular(a: 6, b: 10, operacion: *)
Trailing closures
Cada vez que escribimos una función que recibe un closure como parámetro, es recomendable dejar ese parámetro último en la lista para poder hacer uso de los trailing closures. El concepto de trailing hace alusión a que el closure puede escribirse por fuera del listado de parámetros, fuera de los paréntesis y a continuación de estos, para poder escribir un código más claro y sin la necesidad de especificar el nombre del argumento. En el caso de que la función no reciba otro parámetro adicional más que el closure, se pueden omitir los paréntesis:
func funcionCualquiera(closure: () -> Void) {
}
//llamando a la función sin usar trailing closure
funcionCualquiera(closure: {
//Codigo
})
//llamando a la función con trailing closure
funcionCualquiera() {
//Codigo
}
//llamando a la función con closure sin los paréntesis
funcionCualquiera {
//Codigo
}
Volviendo al ejemplo anterior, usando lo aprendido se debería escribir así:
calcular(a: 6, b: 10) { $0 + $1 }
calcular(a: 6, b: 10) { $0 * $1 }
Capturar valores usando closures
Como dijimos al principio, los closures pueden capturar valores del ámbito donde están definidos y hacer uso de esos valores incluso cuando este contexto ya no existe.
El ejemplo más claro es el caso de las funciones anidadas, donde la función interior captura las variables que pertenecen a la función que la engloba para realizar sus cálculos, incluso cuando solo se hace uso de la función interna.
Supongamos que tenemos una función que posee un atributo y una función anidada, y que al llamarla la misma devuelve a dicha función, de manera de poder ser utilizada fuera de su ámbito.
func hacerIncremento(en cantidad:Int) -> () -> Int {
var total = 0
func incrementar() -> Int {
total += cantidad
return total
}
return incrementar
}
Como se puede observar, al invocar a hacerIncremento(en:) lo que obtenemos es una referencia a la función incrementar(_:), en lugar de un simple entero, la cual aumenta el valor del atributo total que pertenece a la función que la engloba. Cabe destacar que los atributos total y cantidad, si bien son usados dentro de la función incrementar(_:) no pertecen a ella, sino que ésta captura sus valores al momento de ejecutarse.
let incrementarPorDiez = hacerIncremento(en:10)
print(incrementarPorDiez()) //Devuelve 10
print(incrementarPorDiez()) //Devuelve 20
print(incrementarPorDiez()) //Devuelve 30
Aquí hay un caso curioso. Como podemos ver, incrementarPorDiez es una constante con lo cual no debería poder cambiar su valor y sin embargo estamos observando que cada vez que lo ejecutamos aumenta en 10 su valor de retorno. Esto es posible porque los closures son tipos por referencia. Esto implica que cada vez que asignamos una constante o variable a un closure, en realidad lo que estamos haciendo es asignar la dirección de memoria donde ese closure existe a esa variable o constante, en lugar de hacer una copia fiel del mismo.
En otras palabras, cuando ejecutamos esta línea:
let incrementarPorDiez = hacerIncremento(en:10)
Swift determina un espacio en memoria para que exista la función hacerIncremento(en:) y devuelve la dirección de memoria que es alojada en incrementarPorDiez. Si hiciéramos otra constante apuntando a otra versión distinta de hacerIncremento(en:) obtendríamos lo siguiente:
let incrementarPorCuatro = hacerIncremento(en:4)
print(incrementarPorCuatro()) //Devuelve 4
print(incrementarPorCuatro()) //Devuelve 8
print(incrementarPorCuatro()) //Devuelve 12
Como es un incrementador nuevo, la variable total es nueva también y arranca desde el principio, con lo cual, a estas alturas tenemos 2 incrementadores distintos en memoria. Ahora bien, si queremos asignar a una constante el primer incrementador, sucede lo siguiente:
let otroIncrementadorPorDiez = incrementarPorDiez
print(otroIncrementadorPorDiez()) //Devuelve 40
Como vemos, no arranca de 0 sino de 30, que es donde había quedado el incrementador por 10. Esto sucede porque en la constante otroIncrementadorPorDiez lo que se está almacenando es la misma dirección de memoria a la que apunta incrementarPorDiez, con lo cual el atributo total al que están incrementando es el mismo.
Ejemplos completos
func calcular(a:Int, b:Int, operacion:(Int,Int)->Int){
print("El resultado es \(operacion(a,b))")
}
func sumar(a:Int, b:Int) -> Int{
return a+b
}
calcular(a: 6, b: 10, operacion: sumar)
//Devuelve:
//El resultado es 16
calcular(a: 6, b: 10, operacion: {(numero1:Int, numero2: Int) -> Int in
return numero1 + numero2
})
calcular(a: 6, b: 10, operacion: {(numero1, numero2) in
return numero1 + numero2
})
calcular(a: 6, b: 10, operacion: {(numero1, numero2) in
numero1 + numero2
})
calcular(a: 6, b: 10, operacion: { $0 + $1 })
calcular(a: 4, b: 5, operacion: +)
// Trailing Closures
func funcionCualquiera(closure: () -> Void) {
}
//llamando a la función sin usar trailing Closure
funcionCualquiera(closure: {
//Codigo
})
//llamando a la función con trailing Closure
funcionCualquiera() {
//Codigo
}
calcular(a: 6, b: 10) { $0 + $1 }
func hacerIncremento(en cantidad:Int) -> () -> Int {
var total = 0
func incrementar() -> Int {
total += cantidad
return total
}
return incrementar
}
let incrementarPorDiez = hacerIncremento(en:10)
incrementarPorDiez()
//Devuelve 10
incrementarPorDiez()
//Devuelve 20
incrementarPorDiez()
//Devuelve 30
let incrementarPorCuatro = hacerIncremento(en: 4)
incrementarPorCuatro()
//Devuelve 4
incrementarPorCuatro()
//Devuelve 8
incrementarPorCuatro()
//Devuelve 12
let otroIncrementadorPorDiez = incrementarPorDiez
otroIncrementadorPorDiez()
//Devuelve 40