Manejo de errores en Go: try/catch y técnicas avanzadas

Manejo de errores en Go: try/catch y más allá: nivel avanzado

Los desarrolladores que llegan a Go desde lenguajes con excepciones (Java, Python, C#) a menudo se preguntan: «¿Dónde está el try/catch aquí?». La respuesta es simple: en Go no hay excepciones en el sentido clásico. En su lugar, el lenguaje ofrece un modelo de manejo de errores explícito, predecible y eficiente. A primera vista, esto puede parecer un paso atrás, pero en realidad es uno de los principios clave de la filosofía de Go: simplicidad y confiabilidad. En este artículo, no solo explicaremos cómo reemplazar try/catch, sino que analizaremos técnicas avanzadas para trabajar con errores: desde tipos personalizados hasta envoltura y pánico.

¿Por qué no hay try/catch en Go?

La ausencia de try/catch es una decisión arquitectónica deliberada. Las excepciones a menudo conducen a flujos de ejecución implícitos que son difíciles de rastrear. El programa puede «explotar» en cualquier lugar si olvida manejar una excepción. Go propone un enfoque diferente: el error es simplemente un valor (error is a value).

Esto significa que una función que puede fallar devuelve un valor de error como parte de su resultado. El programador debe verificar este valor. Este enfoque hace que el flujo de errores sea visible en el código y evita situaciones en las que la excepción se «traga» o se maneja demasiado lejos del lugar donde ocurrió.

// Idioma típico de Gofunc ReadFile(path string) ([]byte, error) {    data, err := os.ReadFile(path)    if err != nil {        return nil, fmt.Errorf("no se pudo leer el archivo %s: %w", path, err)    }    return data, nil}

// Usodata, err := ReadFile("config.json")if err != nil {    log.Fatal(err) // o return err}

Este es el reemplazo de try/catch. En lugar del bloque try { ... } catch (Exception e) { ... } usamos if err != nil. No es menos expresivo, pero es mucho más explícito.

Técnicas avanzadas: errores personalizados y envoltura

1. Tipos de error personalizados

El tipo estándar error es una interfaz con un único método Error() string. Pero para un manejo avanzado, a menudo necesita más: un código de error, la naturaleza temporal de la falla, datos adicionales. Cree su propio tipo que implemente la interfaz error.

type MyError struct {    Code    int    Message string    IsTemp  bool}

func (e *MyError) Error() string {    return fmt.Sprintf("código %d: %s (temporal: %t)", e.Code, e.Message, e.IsTemp)}

// Usofunc DoSomething() error {    return &MyError{Code: 503, Message: "servicio no disponible", IsTemp: true}}

// Verificaciónerr := DoSomething()var myErr *MyErrorif errors.As(err, &myErr) {    if myErr.IsTemp {        // Reintentar    }}

Consejo: Use errors.As para una conversión segura a su tipo, en lugar de una conversión de tipo directa (type assertion), para evitar pánico.

2. Envoltura de errores (Wrapping)

Una de las características más potentes de Go 1.13+ es la capacidad de envolver errores usando fmt.Errorf y la directiva %w. Esto crea una cadena de errores que se puede desenredar con errors.Is y errors.As.

func OpenConfig() error {    _, err := os.Open("config.yaml")    if err != nil {        // Envolvemos el error, añadiendo contexto        return fmt.Errorf("apertura de configuración: %w", err)    }    return nil}

func LoadApp() error {    err := OpenConfig()    if err != nil {        // Envolvemos de nuevo        return fmt.Errorf("carga de la aplicación: %w", err)    }    return nil}

// En algún lugar de mainerr := LoadApp()if errors.Is(err, os.ErrNotExist) {    fmt.Println("Archivo de configuración no encontrado")}

Tenga en cuenta: errors.Is recorre toda la cadena y encuentra