Introducción

Golang o Go tiene un sólido mecanismo de manejo de errores que es parte integral del diseño del lenguaje. Si bien Go proporciona tipos de errores integrados, hay situaciones en las que es posible que necesite más control y contexto en el manejo de errores.
Aquí es donde entra en juego la creación de errores personalizados. Los errores personalizados pueden brindarle mensajes de error más informativos y pueden usarse para categorizar diferentes tipos de errores en su aplicación.

En este artículo, exploraremos cómo crear y utilizar errores personalizados en Golang de manera efectiva.

Comprender el manejo de errores integrado de Go

En Go, el tipo de error es una interfaz integrada que se ve así:

type error interface {
    Error() string
}

Cualquier tipo que implemente el método Error() con un tipo de retorno de cadena satisface esta interfaz y puede considerarse un error. Esto es simple pero poderoso porque le permite crear tipos de errores personalizados simplemente implementando este método.

Manejo básico de errores en Go

Aquí hay un ejemplo rápido de manejo de errores básico en Go:

package main

import (
    "errors"
    "fmt"
)

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

func doSomething() error {
    return errors.New("something went wrong")
}

Este ejemplo utiliza la función errores.Nueva para crear un error básico. Si bien esto es útil para casos simples, carece de la capacidad de proporcionar más contexto o distinguir entre diferentes tipos de errores.

¿Por qué crear errores personalizados?

Los errores personalizados son esenciales cuando necesitas mensajes de error más descriptivos o cuando quieres manejar diferentes tipos de errores de manera diferente. Por ejemplo, es posible que desee devolver un tipo de error específico cuando no se encuentra un archivo y otro tipo cuando un archivo está dañado. Los errores personalizados también pueden contener datos adicionales, lo que facilita la depuración y proporciona información más detallada a la persona que llama.

Creando errores personalizados en Go

Para crear un error personalizado en Go, debes definir un nuevo tipo que implemente el método Error(). Veamos un ejemplo.

Ejemplo 1: un error personalizado simple

Así es como puedes crear un error personalizado simple:

package main

import (
    "fmt"
)

type MyError struct {
    Code    int
    Message string
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Code %d: %s", e.Code, e.Message)
}

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

func doSomething() error {
    return &MyError{
        Code:    404,
        Message: "Resource not found",
    }
}

En este ejemplo, MyError es un tipo de error personalizado que incluye un código y un mensaje. El método Error() los formatea en una cadena, lo que facilita imprimir o registrar el error.

Ejemplo 2: Verificar errores con errores. Es función

A veces, es útil comparar errores directamente. Aquí es donde entran los errores centinela. Un error centinela es una variable exportada predefinida que representa un error específico.

package main

import (
    "errors"
    "fmt"
)

var ErrNotFound = errors.New("resource not found")

func main() {
    err := doSomething()
    if errors.Is(err, ErrNotFound) {
        fmt.Println("Error:", err)
    }
}

func doSomething() error {
    return ErrNotFound
}

Si bien este enfoque es sencillo, combinar valores centinela con tipos de error personalizados puede ser aún más poderoso, permitiendo tanto la comparación de errores como datos de error enriquecidos.

Ejemplo 3: errores de ajuste para obtener más contexto

Go 1.13 introdujo la función fmt.Errorf con el verbo %w, que le permite ajustar errores, agregando más contexto y preservando el error original.

package main

import (
    "errors"
    "fmt"
)

var ErrNotFound = errors.New("resource not found")

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
        if errors.Is(err, ErrNotFound) {
            fmt.Println("The resource was not found.")
        }
    }
}

func doSomething() error {
    err := fetchResource()
    if err != nil {
        return fmt.Errorf("failed to do something: %w", err)
    }
    return nil
}

func fetchResource() error {
    return ErrNotFound
}

Esto le permite verificar errores específicos y también mantener una pila de errores que brinda más contexto sobre lo que salió mal.

Ejemplo 4: Enriquecimiento de errores con el método Unwrap()

Go también proporciona una manera de extraer el error empaquetado usando el método Unwrap(). Al implementar este método en sus tipos de errores personalizados, puede permitir una mayor resolución de errores.

package main

import (
    "errors"
    "fmt"
)

type MyError struct {
    Code    int
    Message string
    Err     error
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Code %d: %s", e.Code, e.Message)
}

func (e *MyError) Unwrap() error {
    return e.Err
}

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
        if errors.Is(err, ErrNotFound) {
            fmt.Println("The resource was not found.")
        }
    }
}

var ErrNotFound = errors.New("resource not found")

func doSomething() error {
    err := fetchResource()
    if err != nil {
        return &MyError{
            Code:    500,
            Message: "Something went wrong",
            Err:     err,
        }
    }
    return nil
}

func fetchResource() error {
    return ErrNotFound
}

Aquí, MyError tiene un método Unwrap() que devuelve el error empaquetado. Esto permite una inspección y un manejo más profundos del error subyacente.

Ejemplo 5: Verificación de errores con errores. Como función

Go también proporciona una forma de extraer el error con errores. Como método. Al implementar este método en sus tipos de error personalizados, puede verificar el tipo de error y también recuperar los valores de error personalizados.

package main

import (
    "errors"
    "fmt"
)

type MyError struct {
    Code    int
    Message string
    Err     error
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Code %d: %s: %v", e.Code, e.Message, e.Err)
}

func main() {
    err := doSomething()
    var mErr *MyError
    // another way to initialize custom error
    // mErr := &MyError{}
    if errors.As(err, &mErr) {
        fmt.Println("Error:", mErr)
    }
}

// doSomething attempts to fetch a resource and returns an error if it fails.
// If the error is ErrNotFound, it is wrapped in a MyError with a code of 500.
func doSomething() error {
    err := fetchResource()
    if err != nil {
        return &MyError{
            Code:    500,
            Message: "Something went wrong",
            Err:     err,
        }
    }
    return nil
}

var ErrNotFound = errors.New("resource not found")

func fetchResource() error {
    return ErrNotFound
}

Mejores prácticas para errores personalizados en Go

1. Utilice errores personalizados con moderación: Los errores personalizados son potentes pero pueden añadir complejidad. Úselos cuando proporcionen beneficios importantes, como una mejor categorización de errores o contexto adicional.

2. Aproveche el empaquetado y desenvolvimiento: Envolver errores con contexto adicional y desenvolverlos más tarde es una práctica recomendada que mejora la depuración de errores.

3. Documente sus tipos de errores: Asegúrese de que todos los errores personalizados estén bien documentados para que su propósito y uso sean claros.

4. Prefiere valores de error para comparar: Cuando necesites comparar errores, considera usar valores de error predefinidos (errores centinela) para lograr coherencia y claridad.

Conclusión

Los errores personalizados en Go brindan una forma flexible y poderosa de administrar errores en sus aplicaciones. Al crear sus propios tipos de errores, agruparlos para obtener un contexto adicional y desenvolverlos para una inspección más profunda, puede crear mecanismos de manejo de errores sólidos y fáciles de mantener. Esto no solo ayuda en la depuración sino que también mejora la calidad general de su código Go.
Elige tu estrategia con los errores y utiliza los errores consistentes en todo el proyecto.