Lección 19 de 36 · Errores y funciones✦ WebMCP implementado
Errores como valores: adiós try/catch
9 min de lectura5 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.
Después de cada llamada que puede fallar escribes if err != nil { … }. Es un try/catch de una sola línea, pegado a la llamada que puede fallar.
Los errores se crean con errors.New("…") o fmt.Errorf("…") y se envuelven con %w para añadir contexto sin perder el original, como el previous: $e de las excepciones de PHP.
Para saber qué error es usas errors.Is (¿es este error concreto?) y errors.As (¿es de este tipo?). Son tus catch (TareaNoEncontrada $e) de PHP.
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.
package main
import (
"fmt"
)
typeTareastruct {
IDintTitulostring
}
// La firma ya avisa: devuelve una Tarea Y un error.funcBuscarPorID(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");returnTarea{}, fmt.Errorf("tarea %d no encontrada", id)
}
funcmain() {
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:
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.
Por convención, el error va siempre el último en lo que devuelve la función: (Tarea, error), (int, error).
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.
PHP
Go
Qué 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 DomainException
type ErrorValidacion struct{…} + Error() string
Sin extends: cualquier tipo con Error() es un error
catch (ErrorValidacion $e) { $e->campo; }
errors.As(err, &ev) y luego ev.Campo
Busca 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.funcValidarTitulo(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")
}
iflen(titulo) > 20 {
// En PHP: throw new InvalidArgumentException(sprintf('...', strlen($titulo)));return fmt.Errorf("el título ocupa %d bytes (máximo 20)", len(titulo))
}
returnnil
}
funcmain() {
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"
)
typeTareastruct {
IDintTitulostring
}
// En PHP: final class TareaNoEncontrada extends RuntimeException {}varErrTareaNoEncontrada = errors.New("tarea no encontrada")
funcBuscarPorID(ts []Tarea, id int) (Tarea, error) {
for _, t := range ts {
if t.ID == id {
return t, nil
}
}
returnTarea{}, ErrTareaNoEncontrada
}
funcmain() {
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"
)
varErrTareaNoEncontrada = errors.New("tarea no encontrada")
funcbuscar(id int) error {
returnErrTareaNoEncontrada
}
funcCompletar(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)
}
returnnil
}
funcmain() {
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"
)
typeTareastruct {
TitulostringPrioridadint
}
// En PHP: final class ErrorValidacion extends DomainException { ... }typeErrorValidacionstruct {
CampostringMotivostring
}
// 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)
}
funcValidar(t Tarea) error {
if t.Titulo == "" {
returnErrorValidacion{Campo: "titulo", Motivo: "está vacío"}
}
if t.Prioridad < 0 || t.Prioridad > 2 {
returnErrorValidacion{Campo: "prioridad", Motivo: fmt.Sprintf("%d no es Baja, Media ni Alta", t.Prioridad)}
}
returnnil
}
funcGuardar(t Tarea) error {
if err := Validar(t); err != nil {
return fmt.Errorf("guardar: %w", err)
}
returnnil
}
funcmain() {
err := Guardar(Tarea{Titulo: "Repasar Go", Prioridad: 7})
fmt.Println(err)
// En PHP: catch (ErrorValidacion $e) { echo $e->campo; }var ev ErrorValidacionif errors.As(err, &ev) {
fmt.Println("Marca en rojo el campo:", ev.Campo)
}
}
Pregunta
Función
En PHP
¿Es este error concreto?
errors.Is(err, ErrTareaNoEncontrada)
catch (TareaNoEncontrada $e)
¿Hay un error de este tipo? Dámelo
errors.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.
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"
)
funcmain() {
// Llega del formulario, como un $_POST['prioridad']
texto := "alta"
prioridad := 1var err errorif 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.
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
Pista. Añade un if titulo == "" que haga return errors.New("el título está vacío"), y no olvides importar errors.
Reto 2 de 5 · ✓ Resuelto
Busca la tarea o devuelve el centinela
Completa BuscarPorID(ts []Tarea, id int) (Tarea, error): devuelve la tarea con ese ID y nil, o Tarea{} y ErrTareaNoEncontrada si no está. Es tu throw new TareaNoEncontrada() de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Si el bucle termina sin encontrarla, el error que toca devolver ya existe: es la variable ErrTareaNoEncontrada.
Reto 3 de 5 · ✓ Resuelto
Completa y envuelve
Completa Completar(ts []Tarea, id int) error: marca como hecha la tarea con ese ID y devuelve nil. Si no existe, devuelve el error de BuscarIndiceenvuelto con el mensaje completar tarea <id>: …, por ejemplo completar tarea 7: tarea no encontrada. Es el throw new RuntimeException("completar tarea $id", previous: $e) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Cambia el return err por return fmt.Errorf("completar tarea %d: %w", id, err). Con %v el mensaje se vería igual, pero errors.Is ya no encontraría el centinela.
Reto 4 de 5 · ✓ Resuelto
Del error al código HTTP
Completa CodigoHTTP(err error) int: 200 si err es nil, 404 si es (o lleva dentro) ErrTareaNoEncontrada y 500 en cualquier otro caso. Es el manejador de excepciones de Laravel que convierte una ModelNotFoundException en un 404. Ojo: el error puede llegar envuelto.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.== solo mira el sobre de fuera. ¿Qué función abre los sobres uno a uno buscando el centinela?
Reto 5 de 5 · ✓ Resuelto
¿Qué campo está mal?
Completa CampoInvalido(err error) string: si err es (o lleva dentro) un ErrorValidacion, devuelve su Campo; si no, "". Es el catch (ErrorValidacion $e) { return $e->campo; } de PHP. El error puede llegar envuelto por fmt.Errorf con %w.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Declara var ev ErrorValidacion y pregunta con errors.As(err, &ev): si devuelve true, ev ya está relleno.
Resumen
Lo que te llevas de esta lección
Una función que falla devuelve (resultado, error) y el error vale nil si todo va bien (en PHP, throw).
if err != nil { return … } justo después de cada llamada (en PHP, el try/catch, pero pegado a la línea).
fmt.Errorf("contexto: %w", err) envuelve sin perder el original (en PHP, previous: $e).
errors.Is para centinelas como ErrTareaNoEncontrada y errors.As para tipos propios (en PHP, catch (Clase $e)); nunca == con errores envueltos.
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.