Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 20 de 36 · Errores y funciones ✦ WebMCP implementado

defer, panic y recover: el finally de Go

8 min de lectura 3 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.

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í.

PHP 8.5exportar.php
<?php
declare(strict_types=1);

function exportarTareas(array $tareas): void
{
    $fichero = fopen('php://memory', 'w+');
    echo 'Abierto' . PHP_EOL;
    try {
        foreach ($tareas as $tarea) {
            if ($tarea === '') {
                throw new InvalidArgumentException('tarea vacía');
            }
            fwrite($fichero, $tarea . PHP_EOL);
        }
        echo 'Exportadas: ' . count($tareas) . PHP_EOL;
    } finally {
        fclose($fichero);
        echo 'Cerrado' . PHP_EOL;
    }
}

exportarTareas(['Comprar pan', 'Repasar Go']);
Gomain.go
package main

import (
    "errors"
    "fmt"
)

type Fichero struct {
    lineas []string
}

func Abrir() *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")
}

func ExportarTareas(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 igual
            return errors.New("tarea vacía")
        }
        f.Escribir(t)
    }
    fmt.Println("Exportadas:", len(tareas))
    return nil
}

func main() {
    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"

func main() {
    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"

func main() {
    hechas := 0

    // El argumento se fotografía AHORA: vale 0
    defer fmt.Println("defer con argumento:", hechas)

    // La función anónima lee hechas AL FINAL: vale 3
    defer func() {
        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.
func Resumen(titulos []string) (resumen string) {
    defer func() {
        resumen += " [revisado]"
    }()

    if len(titulos) == 0 {
        return "sin tareas"
    }
    return fmt.Sprintf("%d tareas", len(titulos))
}

func main() {
    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.

Gomain.go
package main

import "fmt"

func TituloSeguro(ts []string, i int) (titulo string, err error) {
    defer func() {
        // En PHP: catch (\Throwable $e) { ... }
        if r := recover(); r != nil {
            err = fmt.Errorf("recuperado: %v", r)
        }
    }()
    return ts[i], nil
}

func main() {
    ts := []string{"Comprar pan", "Repasar Go"}

    t, err := TituloSeguro(ts, 1)
    fmt.Printf("%q %v\n", t, err)

    t, err = TituloSeguro(ts, 5)
    fmt.Printf("%q %v\n", t, err)

    fmt.Println("El programa sigue vivo")
}

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.

PHPGoQué 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ónQué usarEn PHP
La tarea 7 no existeerror (ErrTareaNoEncontrada)Excepción de negocio
El título llega vacío del formularioerror (ErrorValidacion)Excepción de validación
La base de datos no respondeerrorPDOException
Lees la posición 5 de un slice de 2panic (lo lanza Go)Un Warning y sigue con null
Falta una configuración sin la que no se puede arrancarpanic o log.Fatal en mainexit() 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.

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Cierra la lista al final

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

Resumen

Lo que te llevas de esta lección

  1. defer f.Cerrar() justo debajo de abrir: se ejecuta al salir, pase lo que pase (en PHP, finally).
  2. Varios defer salen en orden inverso, como una pila de platos (en PHP, try/finally anidados).
  3. Los argumentos de un defer se fotografían al escribirlo; una función anónima lee el valor del final.
  4. panic es para bugs y lo imposible; lo normal es un error (en PHP, un TypeError frente a una excepción de negocio).
  5. 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).