Go Academy · Lección

defer, funciones anónimas y cierres

Llamadas diferidas y valores de función

defer, funciones anónimas y cierres es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

defer: ejecución diferida

defer programa una llamada de función para que se ejecute cuando la función contenedora retorne, independientemente de cómo lo haga (normalmente, con un error o mediante panic):

func readFile(path string) {
    f, err := os.Open(path)
    if err != nil { return }
    defer f.Close() // runs when readFile returns
    // read from f...
}

Orden de evaluación de defer

Las llamadas diferidas se apilan en una pila y se ejecutan en orden LIFO (último en entrar, primero en salir):

func main() {
    defer fmt.Println("third")
    defer fmt.Println("second")
    defer fmt.Println("first")
    // Output: first, second, third
}

defer para la limpieza

defer es la forma idiomática de garantizar que se liberen los recursos:

Desbloquear un mutex después de bloquearlo
Cerrar un archivo después de abrirlo
Confirmar o revertir una transacción de base de datos
Llamar a WaitGroup.Done() después de WaitGroup.Add()

defer con argumentos

Los argumentos de una llamada diferida se evalúan inmediatamente cuando se llama a defer, no cuando se ejecuta:

x := 10
defer fmt.Println(x) // prints 10, not 20
x = 20
fmt.Println(x)       // prints 20

Funciones anónimas

Las funciones anónimas (literales de función) se definen directamente y sin nombre:

double := func(n int) int {
    return n * 2
}
fmt.Println(double(5)) // 10

// Immediately invoked:
result := func(a, b int) int { return a + b }(3, 4)

Cierres

Un cierre es una función que captura variables de su ámbito circundante:

func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

ctr := makeCounter()
fmt.Println(ctr(), ctr(), ctr()) // 1 2 3

Problema de captura de cierres en bucles

Los cierres capturan variables por referencia, lo que provoca un error frecuente en los bucles con goroutines:

for i := 0; i < 3; i++ {
    i := i // create a new variable per iteration
    go func() { fmt.Println(i) }()
}

defer con retornos con nombre

Las funciones diferidas pueden modificar los valores de retorno con nombre, lo que resulta útil para añadir información a los errores:

func doWork() (err error) {
    defer func() {
        if err != nil {
            err = fmt.Errorf("doWork: %w", err)
        }
    }()
    return riskyOp()
}

Patrones funcionales con cierres

Los cierres permiten patrones funcionales como la memoización:

func memoize(f func(int) int) func(int) int {
    cache := map[int]int{}
    return func(n int) int {
        if v, ok := cache[n]; ok {
            return v
        }
        v := f(n)
        cache[n] = v
        return v
    }
}

Cierres como middleware

Los cierres son el componente básico del middleware en los servidores HTTP de Go: envuelven un controlador y añaden comportamiento a su alrededor:

func withLogging(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL)
        next(w, r)
    }
}

Comprobación rápida

¿Cuándo se evalúan los argumentos de una llamada a una función diferida?

Resumen: defer, cierres y funciones anónimas

Estas características hacen que el código Go sea expresivo y seguro:

defer garantiza la limpieza al salir de la función, en orden LIFO
Los argumentos de defer se evalúan inmediatamente
Las funciones anónimas pueden asignarse a variables o llamarse directamente
Los cierres capturan las variables circundantes por referencia
Preste atención a los errores de captura de variables de bucle en las goroutines

Siguiente curso: arrays, slices y mapas.

Preguntas frecuentes

¿La lección «defer, funciones anónimas y cierres» es gratis?

Sí — el texto completo de «defer, funciones anónimas y cierres» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «defer, funciones anónimas y cierres»?

Llamadas diferidas y valores de función Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «defer, funciones anónimas y cierres»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy