Warning: Undefined array key "typ" in /srv/vhost/diaridigital.net/home/html/sourcecode/main/articles.php on line 18
Clausuras en Go
Tiempo de lectura: 1 minutos
Una clausura es una función anónima que puede capturar y acceder a variables de su entorno externo. Lo vemos paso a paso.
Funciones anidadas
En Go, podemos crear una función dentro de otra. A esto lo llamamos funciones anidadas. Por ejemplo, creamos una función anónima dentro de la función greet() que se ejecuta cuando se llama la función externa desde la función principal:
package main
import "fmt"
// fuunción externa
func hello(name string) {
// function interna
var displayName = func() {
fmt.Println("Hola", name)
}
// ejecutamos la función interna
displayName()
}
func main() {
// ejecutamos la functión externa
hello("Xavi")
} Retornar una función
También en Go, podemos hacer que una función retorne una función, indicando que el retorno es del tipo func(). En este caso también es una función anidada, pero la ejecutamos fuera de la función que la crea. Por ejemplo:
package main
import "fmt"
func hello() func() {
return func() {
fmt.Println("Hola, Xavi")
}
}
func main() {
// guardamos el retorno
xavi := hello()
// llamamos a la función guardada
xavi()
} Clausuras
Una clausura es una función anónima que puede capturar y acceder a variables de su entorno externo. Esto significa que la función “recuerda” el contexto en el que fue creada, incluso después de que ese contexto haya terminado su ejecución.
package main
import "fmt"
// función externa
func hello() func() string {
// variable definida fuera de l fuunción intern
name := "Xavi"
// retorna una función anónima, que utiliza la variable
return func() string {
name = "Hola, " + name
return name
}
}
func main() {
// llama a la funcción externa
message := hello()
// llama a la funión interna, pero no le pasamos el nombre
fmt.Println(message())
} Imprime Hola, Xavi
En teoría, después de ejecutar la función hello() la variable name desaparece porque es local a la función.
Esto es posible porque la función anidada ahora actúa como una clausura, que encierra la variable local a la función externa, dentro de su propio ámbito incluso después de que se ejecuta la función externa.
Un ejemplo en detalle
A continuación definimos una función anónima anidada que suma un argumento externo con un o interno:
func suma(a int) func(int) int{
return func(b int) int{
return a + b
}
} La función suma() recibe un argumento a int y devuelve una función anónima (sin identificador) que a su vez esta espera un argumento b int y devuelve un int.
Creamos y llamamos a las clausuras
func main() {
suma01 := suma(5) // Creamos una closure
suma02 := suma(10) // Creamos otra
fmt.Println("Suma 01: ", suma01(2)) // Suma 5 + 2
fmt.Println("Suma 02: ", suma02(100)) // Suma 10 + 100
} En las primeras dos líneas hacemos que suma01 y suma02 almacenen una closure, es decir, una función y el ámbito en que fue creada. A pesar de haber salido del ámbito de suma(), ambas closures almacenan la variable a int correspondiente al momento de su creación, cuando se invoca la función de las clausuras, sumamos a + b (el a del momento de la creación, y el b que pasamos al invocarlas).
Las clausuras ayudan a aislar datos de los que no nos hemos de preocupar a la hora de llamar a las clausuras.
