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 19 de 36 · Errores y funciones ✦ WebMCP implementado

Errores como valores: adiós try/catch

9 min de lectura 5 retos

En PHP, cuando algo va mal, se lanza una excepción con throw y alguien la caza con try/catch. En Go no hay excepciones: un error es un valor más que la función devuelve, y tú decides qué hacer con él justo en la línea siguiente.

¿De dónde vienen los nombres?

Errorf = Error + f (formatted, con formato)
Como Sprintf, pero en vez de un string devuelve un error. En PHP sería new RuntimeException(sprintf(...)).
%w = w de wrap (envolver)
El verbo de fmt.Errorf que mete un error dentro de otro sin perderlo. Es el previous: $e del constructor de una excepción de PHP.
Unwrap = Un + wrap (desenvolver)
Saca el error que iba envuelto dentro: el $e->getPrevious() de PHP.
ErrTareaNoEncontrada = Err de error
Por convención, las variables de error de un paquete empiezan por Err. Es como terminar en Exception el nombre de tus clases de excepción en PHP.
En 4 ideas
1/4

Una función que puede fallar devuelve dos cosas: el resultado y un error. Si todo fue bien, el error vale nil. En PHP la función devolvería el resultado y, si falla, haría throw.

1 · Un error es un valor, no un salto

En PHP, un throw es como la alarma de incendios de un colegio: suena en un aula y todo el mundo sale corriendo por el pasillo hasta que alguien, en algún sitio, la apaga con un catch. Si nadie la apaga, el usuario ve un error 500.

En Go no hay alarma. Una función que puede fallar te devuelve una nota junto al resultado: «aquí tienes la tarea» o «no la he encontrado». La nota es un valor de tipo error, y lo lees en la línea siguiente. Nadie sale corriendo.

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

final class TareaNoEncontrada extends RuntimeException {}

function buscarPorId(array $tareas, int $id): array
{
    foreach ($tareas as $tarea) {
        if ($tarea['id'] === $id) {
            return $tarea;
        }
    }
    throw new TareaNoEncontrada("tarea {$id} no encontrada");
}

$tareas = [['id' => 1, 'titulo' => 'Comprar pan']];

try {
    $tarea = buscarPorId($tareas, 7);
    echo $tarea['titulo'] . PHP_EOL;
} catch (TareaNoEncontrada $e) {
    echo "Error: {$e->getMessage()}" . PHP_EOL;
}
Gomain.go
package main

import (
    "fmt"
)

type Tarea struct {
    ID     int
    Titulo string
}

// La firma ya avisa: devuelve una Tarea Y un error.
func BuscarPorID(ts []Tarea, id int) (Tarea, error) {
    for _, t := range ts {
        if t.ID == id {
            // Todo bien: el error es nil.
            return t, nil
        }
    }
    // En PHP: throw new TareaNoEncontrada("tarea {$id} no encontrada");
    return Tarea{}, fmt.Errorf("tarea %d no encontrada", id)
}

func main() {
    ts := []Tarea{{ID: 1, Titulo: "Comprar pan"}}

    t, err := BuscarPorID(ts, 7)
    // En PHP: catch (TareaNoEncontrada $e) { ... }
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(t.Titulo)
}

Fíjate en tres cosas:

  1. error es un tipo que viene de serie, como int o string. Por dentro es una interfaz con un solo método: Error() string, que devuelve el mensaje.
  2. Por convención, el error va siempre el último en lo que devuelve la función: (Tarea, error), (int, error).
  3. Si devuelves un error, el resto de valores van con su valor cero (Tarea{}, 0, ""): quien llama no debe usarlos.

¿Por qué? · En PHP no existe

¿Por qué Go no tiene excepciones? En PHP existe throw

En PHP cualquier función puede lanzar y su firma no lo dice: como mucho, un @throws en el comentario que nadie obliga a mantener. Si olvidas un catch, la excepción sube y sube hasta reventar la petición con un 500. Y mientras sube, se salta todo el código que había en medio.

Go quiso que el fallo se viera:

  • La firma (Tarea, error) te dice que puede fallar, sin leer la documentación.
  • Para usar la tarea tienes que recoger también el error: o lo miras, o lo tiras a propósito con _, y eso salta a la vista en una revisión de código.
  • No hay saltos invisibles: el programa sigue línea a línea y tú decides qué pasa en cada fallo.

El precio es escribir muchos if err != nil. Los programadores de Go lo pagan a gusto: el camino del error queda tan claro como el del éxito.

Equivalencia POO · PHP → Go

No hay jerarquía de excepciones ni try/catch: los errores son valores y se comparan o se inspeccionan con el paquete errors.

PHPGoQué cambia
throw new RuntimeException('…')return errors.New("…")Devuelves el error como un valor más; nada salta
try { … } catch (Exception $e) { … }if err != nil { … }Se mira justo después de cada llamada que puede fallar
catch (TareaNoEncontrada $e)errors.Is(err, ErrTareaNoEncontrada)Se compara con un error centinela (una variable)
class ErrorValidacion extends DomainExceptiontype ErrorValidacion struct{…} + Error() stringSin extends: cualquier tipo con Error() es un error
catch (ErrorValidacion $e) { $e->campo; }errors.As(err, &ev) y luego ev.CampoBusca un error de ese tipo y te lo da para leer sus campos
new RuntimeException('…', previous: $e)fmt.Errorf("…: %w", err)Envolver: añade contexto y guarda el original
$e->getMessage() / $e->getPrevious()err.Error() / errors.Unwrap(err)El mensaje y el error de dentro
finally { … }defer …Lo verás en la lección siguiente

2 · Crear errores: errors.New y fmt.Errorf

Hay dos formas de fabricar un error. errors.New cuando el mensaje es fijo y fmt.Errorf cuando quieres meter datos dentro, como harías con sprintf().

Gomain.go
package main

import (
    "errors"
    "fmt"
    "strings"
)

// ValidarTitulo devuelve nil si el título vale, o un error que explica por qué no.
func ValidarTitulo(titulo string) error {
    titulo = strings.TrimSpace(titulo)
    if titulo == "" {
        // En PHP: throw new InvalidArgumentException('el título está vacío');
        return errors.New("el título está vacío")
    }
    if len(titulo) > 20 {
        // En PHP: throw new InvalidArgumentException(sprintf('...', strlen($titulo)));
        return fmt.Errorf("el título ocupa %d bytes (máximo 20)", len(titulo))
    }
    return nil
}

func main() {
    titulos := []string{"Comprar pan", "   ", "Repasar el módulo seis de Go"}
    for _, titulo := range titulos {
        if err := ValidarTitulo(titulo); err != nil {
            fmt.Println("No vale:", err)
            continue
        }
        fmt.Println("Vale:", titulo)
    }
}

El if err := ValidarTitulo(titulo); err != nil es una forma corta muy común: declara err y lo comprueba en la misma línea. Ese err solo existe dentro del if, como una nota que tiras al salir.

3 · Errores centinela: ErrTareaNoEncontrada

A veces quien llama necesita saber qué falló, no solo que falló. «No encontrada» es un 404; «la base de datos no responde» es un 500. En PHP creas una clase TareaNoEncontrada. En Go creas una variable de error y la devuelves siempre que pase eso. Se llama error centinela: como el centinela de un castillo, siempre es el mismo y lo reconoces de lejos.

Gomain.go
package main

import (
    "errors"
    "fmt"
)

type Tarea struct {
    ID     int
    Titulo string
}

// En PHP: final class TareaNoEncontrada extends RuntimeException {}
var ErrTareaNoEncontrada = errors.New("tarea no encontrada")

func BuscarPorID(ts []Tarea, id int) (Tarea, error) {
    for _, t := range ts {
        if t.ID == id {
            return t, nil
        }
    }
    return Tarea{}, ErrTareaNoEncontrada
}

func main() {
    ts := []Tarea{{ID: 1, Titulo: "Comprar pan"}, {ID: 2, Titulo: "Repasar Go"}}

    t, err := BuscarPorID(ts, 2)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Encontrada:", t.Titulo)

    _, err = BuscarPorID(ts, 7)
    // En PHP: catch (TareaNoEncontrada $e) { http_response_code(404); }
    if errors.Is(err, ErrTareaNoEncontrada) {
        fmt.Println("La 7 no existe: respondo un 404")
    }
}

La biblioteca estándar está llena de centinelas que verás mucho: io.EOF (se acabó el fichero), sql.ErrNoRows (la consulta no devolvió filas) o http.ErrServerClosed (el servidor se apagó). Casi todos empiezan por Err; io.EOF es la excepción famosa a la regla.

4 · Envolver errores con %w y errors.Is

Un error que sube por varias funciones gana contexto por el camino, como una carta que va metiéndose en sobres: «guardar» mete dentro el error de «buscar tarea 7», que a su vez lleva dentro «tarea no encontrada». En Go cada sobre se pone con fmt.Errorf y el verbo %w.

Gomain.go
package main

import (
    "errors"
    "fmt"
)

var ErrTareaNoEncontrada = errors.New("tarea no encontrada")

func buscar(id int) error {
    return ErrTareaNoEncontrada
}

func Completar(id int) error {
    if err := buscar(id); err != nil {
        // En PHP: throw new RuntimeException("completar tarea {$id}", previous: $e);
        return fmt.Errorf("completar tarea %d: %w", id, err)
    }
    return nil
}

func main() {
    err := Completar(7)
    fmt.Println(err)

    // == compara el sobre de fuera: ya no es el centinela
    fmt.Println("¿Con ==?", err == ErrTareaNoEncontrada)

    // errors.Is abre los sobres uno a uno buscando el centinela
    fmt.Println("¿Con errors.Is?", errors.Is(err, ErrTareaNoEncontrada))

    // En PHP: $e->getPrevious()
    fmt.Println("Lo de dentro:", errors.Unwrap(err))
}

¿Por qué? · En PHP no existe

¿Por qué %w y no %v? En PHP el previous va aparte

Con %v el error de dentro se convierte en texto y se pierde: el mensaje se ve igual, pero errors.Is ya no lo encuentra. Es como fotocopiar la carta en vez de meterla en el sobre.

Con %w (wrap) el error original viaja dentro del nuevo. En PHP lo haces con el argumento previous del constructor de la excepción; en Go es un verbo del formato. Regla fácil: si es un error, %w.

5 · Tus propios tipos de error y errors.As

Un centinela solo dice qué pasó. Si además quieres llevar datos (qué campo del formulario está mal y por qué), creas un tipo. Basta con que tenga el método Error() string: Go lo acepta como error sin que escribas implements ni extends, porque las interfaces se cumplen solas (lo viste en el módulo 05).

Gomain.go
package main

import (
    "errors"
    "fmt"
)

type Tarea struct {
    Titulo    string
    Prioridad int
}

// En PHP: final class ErrorValidacion extends DomainException { ... }
type ErrorValidacion struct {
    Campo  string
    Motivo string
}

// Con este método, ErrorValidacion ya es un error.
// En PHP: el mensaje que pasas a parent::__construct()
func (e ErrorValidacion) Error() string {
    return fmt.Sprintf("campo %s: %s", e.Campo, e.Motivo)
}

func Validar(t Tarea) error {
    if t.Titulo == "" {
        return ErrorValidacion{Campo: "titulo", Motivo: "está vacío"}
    }
    if t.Prioridad < 0 || t.Prioridad > 2 {
        return ErrorValidacion{Campo: "prioridad", Motivo: fmt.Sprintf("%d no es Baja, Media ni Alta", t.Prioridad)}
    }
    return nil
}

func Guardar(t Tarea) error {
    if err := Validar(t); err != nil {
        return fmt.Errorf("guardar: %w", err)
    }
    return nil
}

func main() {
    err := Guardar(Tarea{Titulo: "Repasar Go", Prioridad: 7})
    fmt.Println(err)

    // En PHP: catch (ErrorValidacion $e) { echo $e->campo; }
    var ev ErrorValidacion
    if errors.As(err, &ev) {
        fmt.Println("Marca en rojo el campo:", ev.Campo)
    }
}
PreguntaFunciónEn PHP
¿Es este error concreto?errors.Is(err, ErrTareaNoEncontrada)catch (TareaNoEncontrada $e)
¿Hay un error de este tipo? Dámeloerrors.As(err, &ev)catch (ErrorValidacion $e) y usar $e->campo
¿Qué lleva dentro?errors.Unwrap(err)$e->getPrevious()

6 · El patrón if err != nil y la trampa del :=

Todo el código de Go tiene la misma forma: llamas, miras el error, y si lo hay sales pronto con return. El camino feliz queda pegado a la izquierda y los errores se despachan arriba, como un portero que no deja pasar a nadie sin entrada.

Gomain.go
func CompletarTarea(repo RepositorioTareas, id int) error {
    t, err := repo.BuscarPorID(id)
    if err != nil {
        return fmt.Errorf("completar tarea %d: %w", id, err)
    }

    t.Hecha = true
    if _, err := repo.Guardar(t); err != nil {
        return fmt.Errorf("completar tarea %d: %w", id, err)
    }
    return nil
}

Ahora la trampa. Recuerda: := crea variables. Si lo usas dentro de un bloque (if, for) con un nombre que ya existía fuera, no cambias la de fuera: creas otra con el mismo nombre que la tapa hasta que acaba el bloque. Se llama sombrear (shadowing): la de dentro hace sombra a la de fuera.

Gomain.go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Llega del formulario, como un $_POST['prioridad']
    texto := "alta"
    prioridad := 1
    var err error

    if texto != "" {
        // ⚠️ := crea OTRO prioridad y OTRO err que solo viven dentro del if
        prioridad, err := strconv.Atoi(texto)
        fmt.Println("dentro:", prioridad, err)
    }

    // El err de fuera sigue en nil: el fallo se ha perdido
    fmt.Println("fuera:", prioridad, err)
}

Compila sin una queja, porque las dos variables se usan. El arreglo es cambiar := por = dentro del bloque: «dos puntos, nace; sin puntos, cambia». En PHP esto no puede pasar porque un if no crea un ámbito nuevo, así que esta trampa te pillará por sorpresa.

La pregunta que te vas a hacer

«Vale, pero… ¿y cómo devuelvo un 404 o un 500 desde mi API?»

En Laravel o Symfony lanzas una excepción y un manejador global la convierte en respuesta HTTP. En Go haces lo mismo, pero a mano y en un solo sitio: el controlador mira el error con errors.Is o errors.As y elige el código. ErrTareaNoEncontrada es un 404, ErrorValidacion un 422 y lo demás un 500. Lo montarás en el proyecto final.

Hora de practicar

Retos · 0/5 resueltos

Reto 1 de 5

Valida el título

Completa ValidarTitulo(titulo string) error: si el título, sin espacios a los lados, queda vacío, devuelve el error el título está vacío; si no, nil. Es el throw new InvalidArgumentException(...) de PHP, pero devuelto.

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. Una función que falla devuelve (resultado, error) y el error vale nil si todo va bien (en PHP, throw).
  2. if err != nil { return … } justo después de cada llamada (en PHP, el try/catch, pero pegado a la línea).
  3. fmt.Errorf("contexto: %w", err) envuelve sin perder el original (en PHP, previous: $e).
  4. errors.Is para centinelas como ErrTareaNoEncontrada y errors.As para tipos propios (en PHP, catch (Clase $e)); nunca == con errores envueltos.
  5. Dentro de un if o un for, := crea un err nuevo que tapa al de fuera: usa = para cambiar el de fuera (en PHP no existe esa trampa).

Para recordarlo: «D.E.P. try/catch»

DDevuelve
return t, err
EEnvuelve
fmt.Errorf("…: %w", err)
PPregunta
errors.Is / errors.As

Descanse en paz el try/catch: en Go el error se Devuelve, cada capa lo Envuelve con su contexto y arriba del todo se Pregunta qué era.