Lección 20 de 36 · Errores y funciones✦ WebMCP implementado
defer, panic y recover: el finally de Go
8 min de lectura3 retos
En PHP limpias con finally y cazas lo inesperado con catch (\Throwable $e). Go tiene tres palabras para eso: defer deja algo apuntado para cuando la función termine, panic para el programa cuando algo es imposible y recover lo rescata.
En 4 ideas
1/4
defer apunta una llamada para que se ejecute al salir de la función, pase lo que pase. Es el finally de PHP, pero escrito justo al lado de lo que abres.
Si hay varios defer, se ejecutan al revés: el último que apuntas es el primero que sale, como una pila de platos. En PHP tendrías varios try/finally anidados.
panic es para lo que no debería pasar nunca (un bug, un índice fuera del slice). Los fallos normales, como «tarea no encontrada», son un error. Se parece más a un Error de PHP, como TypeError, que a una excepción de negocio.
recover, dentro de una función con defer, detiene un panic y te deja convertirlo en un error. Es el catch (\Throwable $e) de PHP, y solo funciona ahí dentro.
1 · defer: déjalo apuntado para el final
defer significa «aplazar». Cuando escribes defer algo(), Go no lo ejecuta ahora: lo apunta en una lista y lo ejecuta justo antes de que la función termine, salga por donde salga: por el final, por un return a mitad o por un panic.
Es como la nota que te dejas en la puerta: «al salir, apaga la luz». Da igual por qué salgas de casa, la nota está ahí.
package main
import (
"errors""fmt"
)
typeFicherostruct {
lineas []string
}
funcAbrir() *Fichero {
fmt.Println("Abierto")
return &Fichero{}
}
func (f *Fichero) Escribir(linea string) {
f.lineas = append(f.lineas, linea)
}
func (f *Fichero) Cerrar() {
fmt.Println("Cerrado")
}
funcExportarTareas(tareas []string) error {
f := Abrir()
// En PHP: finally { fclose($fichero); }defer f.Cerrar()
for _, t := range tareas {
if t == "" {
// Sale a mitad... y Cerrar() se ejecuta igualreturn errors.New("tarea vacía")
}
f.Escribir(t)
}
fmt.Println("Exportadas:", len(tareas))
returnnil
}
funcmain() {
fmt.Println(ExportarTareas([]string{"Comprar pan", "Repasar Go"}))
fmt.Println(ExportarTareas([]string{"Comprar pan", ""}))
}
Con varios defer, el orden es el de una pila de platos: el último plato que pones encima es el primero que coges.
Gomain.go
package main
import"fmt"funcmain() {
fmt.Println("Empiezo el día")
defer fmt.Println("1. Apagar la luz")
defer fmt.Println("2. Cerrar la lista de tareas")
defer fmt.Println("3. Guardar los cambios")
fmt.Println("Trabajo en mis tareas")
}
¿Por qué? · En PHP no existe
¿Por qué defer y no finally? En PHP existe finally
En PHP abres el fichero arriba y lo cierras en el finally, a veinte líneas de distancia. Si abres tres cosas (un fichero, una conexión y un bloqueo), acabas con tres try/finally anidados, o con uno solo que cierra cosas que quizá ni llegaron a abrirse.
Con defer el cierre va en la línea de debajo de la apertura:
No se te olvida: lo escribes en el momento en que abres.
Cada cosa se cierra solo si llegó a abrirse, porque el defer va después.
El orden inverso es justo el correcto: lo último que abriste depende de lo primero, así que se cierra antes.
2 · Qué se apunta y qué puede cambiar un defer
Cuidado con un detalle: los argumentos de un defer se calculan en el momento de escribirlo, no al final. Es como hacer una foto: si luego la variable cambia, la foto no. Si quieres el valor del final, mete el código en una función anónima (una closure, la lección siguiente): esa sí lee la variable al ejecutarse.
Gomain.go
package main
import"fmt"funcmain() {
hechas := 0// El argumento se fotografía AHORA: vale 0defer fmt.Println("defer con argumento:", hechas)
// La función anónima lee hechas AL FINAL: vale 3deferfunc() {
fmt.Println("defer con función:", hechas)
}()
hechas = 3
fmt.Println("Terminé", hechas, "tareas")
}
Y un truco que en PHP no existe: si los resultados de la función tienen nombre, un defer puede cambiarlos después del return. Así se añade algo al final pase lo que pase:
Gomain.go
package main
import"fmt"// (resumen string) es un resultado con nombre: una variable// que existe desde el principio y es lo que se devuelve.funcResumen(titulos []string) (resumen string) {
deferfunc() {
resumen += " [revisado]"
}()
iflen(titulos) == 0 {
return"sin tareas"
}
return fmt.Sprintf("%d tareas", len(titulos))
}
funcmain() {
fmt.Println(Resumen(nil))
fmt.Println(Resumen([]string{"Comprar pan", "Repasar Go"}))
}
3 · panic: cuando algo no debería pasar nunca
Un panic para la función en seco, ejecuta sus defer y sube a la que la llamó, que también se para, y así hasta arriba. Si nadie lo detiene, el programa entero termina y muestra el error y el camino que siguió. Es el freno de emergencia del tren.
Lo lanza el propio Go cuando haces algo imposible, como leer la posición 5 de un slice que tiene 2:
Gomain.go
ts := []string{"pan", "leche"}
i := 5
fmt.Println(ts[i])
panic: runtime error: index out of range [5] with length 2
goroutine 1 [running]:
main.main()
/m/main.go:8 +0x1c
exit status 2
Otros clásicos: escribir en un map nil, usar un puntero nil o convertir una interfaz al tipo que no es. También puedes lanzarlo tú con panic("mensaje"), pero solo para lo que de verdad es imposible si el programa está bien escrito.
¿Por qué? · En PHP no existe
¿Por qué panic no es el throw de Go? En PHP todo se lanza igual
En PHP usas throw para todo: para «tarea no encontrada» (algo normal, el usuario escribió mal el ID) y para un TypeError (un bug tuyo). Los dos viajan por el mismo camino y los cazas con el mismo catch.
Go los separa a propósito:
Lo que puede pasar (no existe, no hay red, el título está vacío) es un error: se devuelve y se trata.
Lo que no debería pasar (un bug) es un panic: para el programa para que lo veas y lo arregles, en vez de seguir con datos rotos.
Así, al leer una firma, sabes qué fallos tienes que tratar tú. Si una librería de Go usa panic para un fallo normal, está mal hecha.
4 · recover: el catch de los panic
recover() detiene un panic en curso y te devuelve lo que se pasó a panic. Solo funciona dentro de una función con defer, porque es lo único que se ejecuta mientras el programa se está parando. Fuera de ahí devuelve nil y no hace nada.
El truco es el mismo de antes: err es un resultado con nombre, así que el defer lo rellena y la función devuelve un error normal en vez de reventar.
Equivalencia POO · PHP → Go
Go no tiene destructores ni finally ni catch: tiene defer para limpiar y recover para el caso raro de un panic.
PHP
Go
Qué cambia
try { … } finally { … }
defer limpiar()
Se escribe junto a lo que abres, no al final
__destruct()
defer x.Cerrar()
No hay destructores: el cierre se pide a mano
throw new TypeError(…) (un bug)
panic(…)
Solo para lo imposible; lo normal es un error
catch (\Throwable $e)
defer func() { if r := recover(); r != nil { … } }()
Solo dentro de un defer
exit(1)
os.Exit(1)
Ojo: os.Exit termina en el acto y no ejecuta los defer
5 · ¿error o panic?
Situación
Qué usar
En PHP
La tarea 7 no existe
error (ErrTareaNoEncontrada)
Excepción de negocio
El título llega vacío del formulario
error (ErrorValidacion)
Excepción de validación
La base de datos no responde
error
PDOException
Lees la posición 5 de un slice de 2
panic (lo lanza Go)
Un Warning y sigue con null
Falta una configuración sin la que no se puede arrancar
panic o log.Fatal en main
exit() al arrancar
La pregunta que te vas a hacer
«Vale, pero… ¿y si un panic tumba mi servidor web?»
En PHP cada petición es un proceso aparte: si una revienta, las demás ni se enteran. En Go todas las peticiones viven en el mismo programa, así que la pregunta es muy buena.
El servidor de net/http ya trae un recover por cada petición: si tu controlador entra en panic, esa petición se corta, el error se escribe en el log y el servidor sigue atendiendo a los demás. Pero un panic en una goroutine que lances tú (módulo 08) no tiene esa red y sí tumba el programa entero.
El programa debe imprimir Abro la lista, las dos tareas y, al final, Cierro la lista. Sin mover la línea del cierre de sitio, haz que se ejecute al terminar main. Es el finally de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Pon defer delante de la llamada que cierra la lista.
Reto 2 de 3 · ✓ Resuelto
El registro siempre se cierra
Revisar(titulos []string) (registro []string) apunta inicio, cada título y fin. Si encuentra un título vacío, para ahí. El problema: al parar, el fin no se apunta. Arréglalo con un defer para que Revisar([]string{"pan", "", "leche"}) devuelva [inicio pan fin]. Es el finally { $registro[] = 'fin'; } de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Como registro es un resultado con nombre, un defer func() { registro = append(registro, "fin") }() al principio lo cambia después de cualquier return. Quita el append de fin del final o saldrá dos veces.
Reto 3 de 3 · ✓ Resuelto
Rescata el panic
TituloEn(ts []Tarea, i int) (titulo string, err error) devuelve el título de la posición i, pero si i no existe, entra en panic. Sin tocar la línea del return, añade un defer con recover para que devuelva "" y el error no hay tarea en la posición 5 (con el i que toque). Es el catch (\Throwable $e) de PHP. En código real comprobarías antes i < len(ts); aquí es para practicar recover.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Antes del return, escribe defer func() { if r := recover(); r != nil { err = fmt.Errorf(...) } }(). Como err tiene nombre, lo que le asignes ahí es lo que se devuelve.
Resumen
Lo que te llevas de esta lección
defer f.Cerrar() justo debajo de abrir: se ejecuta al salir, pase lo que pase (en PHP, finally).
Varios defer salen en orden inverso, como una pila de platos (en PHP, try/finally anidados).
Los argumentos de un defer se fotografían al escribirlo; una función anónima lee el valor del final.
panic es para bugs y lo imposible; lo normal es un error (en PHP, un TypeError frente a una excepción de negocio).
recover() solo funciona dentro de un defer y convierte el panic en un error (en PHP, catch (\Throwable $e)).
Para recordarlo: «Al salir, apaga la luz»
defer es la nota en la puerta: se cumple al salir, salgas como salgas, y las notas se leen de la última a la primera. panic es el freno de emergencia y recover solo lo puede soltar quien dejó una nota (defer).