Envoltura de errores (fmt.Errorf)

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 54 de 107.

Cuando los errores pasan a través de múltiples capas de su aplicación, saber dónde se originó un error se vuelve crucial. La función fmt.Errorf de Go con el verbo %w le permite envolver errores, preservando el error original mientras agrega contexto.

El envoltorio de errores crea una cadena de errores. Cada capa puede añadir información sobre lo que estaba intentando hacer cuando ocurrió el error:

func ReadConfig(filename string) error {
    data, err := os.ReadFile(filename)
    if err != nil {
        return fmt.Errorf("reading config file: %w", err)
    }
    // procesar datos...
    return nil
}

El verbo %w es especial: envuelve el error original dentro del nuevo. Esto es diferente de %v, que simplemente convierte el error en una cadena y pierde la identidad del error original.

func LoadSettings() error {
    err := ReadConfig("settings.json")
    if err != nil {
        return fmt.Errorf("loading settings: %w", err)
    }
    return nil
}

Cuando LoadSettings falla, el mensaje de error muestra la cadena completa: "loading settings: reading config file: open settings.json: no such file or directory". Cada capa añade contexto, facilitando mucho la depuración.

El error envuelto todavía contiene el error original en su interior. En la siguiente lección, aprenderás cómo desenvolver estos errores y comprobar qué hay dentro usando errors.Is() y errors.As().

Desafío

Fácil

Vamos a construir un sistema de procesamiento de pedidos que demuestre el envoltorio de errores (error wrapping) a través de múltiples capas. Crearás una cadena de funciones donde cada capa añade contexto a los errores, facilitando el rastreo exacto de dónde ocurren los problemas.

Organizarás tu código en dos archivos:

orders.go: Crea la lógica de procesamiento de pedidos con múltiples capas que envuelven los errores a medida que se propagan hacia arriba.
Implementa tres funciones que formen una cadena de procesamiento:
- ValidateItem(itemID string) error - Devuelve un error con el mensaje "item not found" si el itemID es "INVALID", de lo contrario devuelve nil
- ProcessOrder(orderID, itemID string) error - Llama a ValidateItem. Si devuelve un error, envuélvelo con el contexto: "processing order [orderID]: %w". De lo contrario, devuelve nil
- SubmitOrder(customerName, orderID, itemID string) error - Llama a ProcessOrder. Si devuelve un error, envuélvelo con el contexto: "submitting order for [customerName]: %w". De lo contrario, devuelve nil
Cada capa debe usar fmt.Errorf con el verbo %w para envolver el error de la capa inferior, construyendo una cadena de contexto.
main.go: Lee los detalles del pedido de la entrada, llama a SubmitOrder y muestra el resultado. Si ocurre un error, imprime la cadena completa del error. Si tiene éxito, imprime un mensaje de confirmación.

Se proporcionarán las siguientes entradas:

Línea 1: Nombre del cliente
Línea 2: ID del pedido
Línea 3: ID del artículo

Imprime el resultado:

Si ocurre un error: Error: [full error chain]
Si tiene éxito: Order [orderID] submitted successfully for [customerName]

Por ejemplo, dados Alice, ORD-123 e INVALID, tu salida debería ser:

Error: submitting order for Alice: processing order ORD-123: item not found

Observa cómo el mensaje de error muestra la cadena completa: puedes rastrear el problema desde el intento de envío de nivel superior, a través del procesamiento del pedido, hasta el fallo de validación real. Cada capa añadió su propio contexto usando %w.

Y dados Bob, ORD-456 e ITEM-001, tu salida debería ser:

Order ORD-456 submitted successfully for Bob

Hoja de referencia

Usa fmt.Errorf con el verbo %w para envolver errores mientras preservas el error original:

func ReadConfig(filename string) error {
    data, err := os.ReadFile(filename)
    if err != nil {
        return fmt.Errorf("reading config file: %w", err)
    }
    return nil
}

El verbo %w envuelve el error original dentro del nuevo, a diferencia de %v que solo convierte el error en una cadena y pierde la identidad del error original.

El envoltorio de errores crea una cadena donde cada capa añade contexto:

func LoadSettings() error {
    err := ReadConfig("settings.json")
    if err != nil {
        return fmt.Errorf("loading settings: %w", err)
    }
    return nil
}

El mensaje de error resultante muestra la cadena completa: "loading settings: reading config file: open settings.json: no such file or directory"

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Leer el nombre del cliente
	scanner.Scan()
	customerName := scanner.Text()
	
	// Leer el ID del pedido
	scanner.Scan()
	orderID := scanner.Text()
	
	// Leer el ID del artículo
	scanner.Scan()
	itemID := scanner.Text()
	
	// TODO: Llamar a SubmitOrder con los valores de entrada
	// TODO: Si ocurre un error, imprimir: Error: [cadena de error completa]
	// TODO: Si tiene éxito, imprimir: Order [orderID] submitted successfully for [customerName]
	
	_ = customerName
	_ = orderID
	_ = itemID
}