Errores personalizados en Go para mejor depuración

Clase 20 de 28 • Curso de Go

Resumen

Entender el manejo de errores en un lenguaje de programación ayuda a tener aplicaciones robustas y fáciles de mantener. Go permite crear errores personalizados, ofreciendo mensajes claros que facilitan la resolución de problemas, tanto para desarrolladores como usuarios finales.

¿qué ventajas tienen los errores personalizados en Go?

Usar errores personalizados en Go simplifica la tarea de identificar y resolver problemas dentro de la aplicación. Crear mensajes intuitivos evita confusiones generadas por mensajes técnicos estándar como Stack Overflow Memory Exception, que pueden ser difíciles de entender.

Algunos beneficios incluyen: - Claridad sobre los problemas específicos que ocurren durante la ejecución del programa. - Facilidad de diagnóstico para desarrolladores, disminuyendo el tiempo en resolver incidencias. - Mejor experiencia del usuario debido a mensajes claros y comprensibles.

¿cómo creo errores personalizados en Go?

Para crear un error personalizado en Go, utilizas el paquete interno errors y sigues estos pasos sencillos:

Declaras la variable del error con un mensaje específico.
Implementas este error dentro de alguna función personalizada en tu código.

Por ejemplo:

package main

import (
    "fmt"
    "errors"
)

var errorDeCafe = fmt.Errorf("Ya no hay café")
var errorDeEnergia = fmt.Errorf("Ya no hay electricidad")

func hacerCafe(args int) error {
    if args == 2 {
        return errorDeCafe
    } else if args == 3 {
        return errorDeEnergia
    }
    return nil
}

Así, tus mensajes serán específicos y claras indicaciones frente a cualquier situación durante la ejecución.

¿cómo utilizo y muestro estos errores dentro de mi código?

La ejecución de estos errores personalizados se realiza dentro de un bucle o condición en tu función principal. Ejemplo:

func main() {
    for i := 0; i < 5; i++ {
        err := hacerCafe(i)
        if err != nil {
            fmt.Println(err)
        } else {
            fmt.Println("Ya hay café")
        }
    }
}

En este caso, en cada iteración, la aplicación revisa si surge algún error con instrucciones específicas y mensajes personalizados, haciendo mucho más fácil su identificación inmediata.

Con estos ejemplos, adquieres herramientas prácticas para mantener aplicaciones escritas en Go comprensibles y organizadas. ¡Úsalos y optimiza tus proyectos! ¿Listo para mejorar tus soluciones? ¡Déjanos saber tu experiencia en los comentarios!

Moises Almonte

student•

Me dio curiosidad como esta creada la librería de errores de Go, busque en el repo de Go en GitHub, el archivo errors.go

Este el código fuente:

package errors
func New(text string) error {
	return &errorString{text}
}
type errorString struct {
	s string
}
func (e *errorString) Error() string {
	return e.s
}
var ErrUnsupported = New("unsupported operation")

URL: https://github.com/golang/go/blob/master/src/errors/errors.go

José Antonio De La Paz Fonseca

student•

Vivan los fundamentos

Samuel Soto Hoyos

student•

Go, como lenguaje, fomenta un enfoque distinto para el manejo de errores en comparación con otros lenguajes que utilizan excepciones o aserciones. El objetivo es hacer que el manejo de errores sea explícito, comprensible y que permita que los servidores continúen operando incluso después de errores no fatales.

A continuación, se presentan las buenas prácticas para el manejo de errores en Go:

Múltiples valores de retorno: La forma principal de informar errores es mediante el retorno de múltiples valores, donde uno de los valores es el tipo error incorporado. Si una función se ejecuta con éxito, el valor error debe ser nil. Esto permite que una función devuelva un resultado útil y una indicación de error simultáneamente.
- Ejemplo: La función Write en Go retorna el número de bytes escritos (n int) y un error.
- Siempre revise los retornos de error: Descartar los valores de error con el identificador en blanco (_) es una mala práctica y puede llevar a fallos inesperados. Los errores se proporcionan por una razón.
Interfaz error:
- La interfaz error es una interfaz simple y predefinida que requiere un solo método: Error() string.
- Las librerías pueden implementar esta interfaz con modelos más ricos, como os.PathError, que proporciona contexto adicional como la operación y la ruta del archivo que causaron el error.
- Los strings de error deben identificar su origen, por ejemplo, incluyendo un prefijo que nombre la operación o el paquete que generó el error (ej. "image: unknown format").
- Los llamadores pueden usar una declaración type switch o una aserción de tipo para inspeccionar errores específicos y extraer detalles si es necesario.
Manejo de pánicos (panic) y recuperación (recover):
- panic: Utilice panic solo para condiciones verdaderamente excepcionales e irrecuperables que impiden que el programa continúe su ejecución normal. Por ejemplo, si una librería no puede inicializarse correctamente. panic detiene inmediatamente la ejecución de la función actual y comienza a desenrollar la pila de la goroutine, ejecutando cualquier función diferida (defer) en el camino.
- Evite exponer panic a los clientes: Las funciones de las librerías deben evitar usar panic si el problema puede ser enmascarado o solucionado. Es mejor convertir los pánicos internos en valores error antes de retornar a los clientes.
- recover: La función recover solo es útil dentro de una función diferida (defer). Permite que una goroutine que está en estado de pánico recupere el control y reanude la ejecución normal. Esto es particularmente útil en servidores, donde una goroutine que falla puede ser apagada limpiamente sin afectar a otras goroutines en ejecución. Al llamar a recover, se detiene el desenrollado de la pila y se devuelve el argumento pasado a panic.
La declaración defer para la gestión de recursos:
- La declaración defer programa una llamada a una función para que se ejecute justo antes de que la función que la contiene retorne. Esto es crucial para liberar recursos de manera garantizada, como cerrar archivos o desbloquear mutexes, sin importar la ruta de retorno de la función.
- Los argumentos de una función diferida se evalúan en el momento en que se ejecuta la instrucción defer, no cuando la llamada se ejecuta realmente.
- defer es fundamental para el patrón panic/recover, ya que las funciones diferidas son las únicas que se ejecutan durante el proceso de pánico.
Consideraciones con nil en interfaces y canales:
- Una variable de interfaz que almacena un puntero nil a un tipo concreto no es nil en sí misma. Esto puede llevar a que una comparación if err != nil retorne true aunque el valor subyacente sea nil. Para retornar un nil error adecuado, la función debe devolver explícitamente nil.
- Los canales nil nunca están listos para la comunicación; cualquier operación de envío o recepción en un canal nil se bloquea indefinidamente. Cerrar un canal nil causa un pánico en tiempo de ejecución.
Finalizadores, limpiezas (cleanups) y punteros débiles (weak pointers):
- Estas características permiten observar y reaccionar a la "muerte" de un objeto (cuando ya no es alcanzable por el programa).
- Consejo general:
  - Escriba pruebas unitarias para el código que usa estas características, ya que su momento de ejecución es difícil de predecir.
  - Evite usarlas directamente en código Go típico; son características de bajo nivel con restricciones y comportamientos sutiles.
  - Encapsule su uso dentro de un paquete y proporcione interfaces que dificulten el uso incorrecto por parte de los usuarios.
  - Prefiera la limpieza determinista de recursos no relacionados con la memoria (ej. descriptores de archivo) mediante APIs explícitas (como un método Close), usando finalizadores y cleanups como un último recurso para errores de programación.
  - Prefiera cleanups a los finalizadores a partir de Go 1.24, ya que son más flexibles, menos propensos a errores y más eficientes. Los finalizadores pueden resucitar objetos y crear ciclos de referencia, impidiendo que la memoria sea liberada.
Identificación y eliminación de asignaciones en el "heap":
- Reducir la cantidad de valores que el recolector de basura (GC) debe gestionar es una forma efectiva de reducir los costos del GC.
- Utilice el perfilado de memoria (heap profiling) para identificar dónde se originan la mayoría de las asignaciones en el "heap". El perfil alloc_space es especialmente útil para esto.
- Aproveche el análisis de escape del compilador Go para optimizar dónde se almacenan los valores (ej. en la pila de goroutine en lugar del "heap"). Puede usar la bandera -gcflags=-m=3 con go build para ver por qué los valores escapan al "heap".

En resumen, Go promueve un estilo de manejo de errores explícito y basado en el control de flujo, utilizando múltiples valores de retorno para errores comunes y mecanismos de panic/recover para situaciones verdaderamente excepcionales, siempre en conjunto con defer para una gestión robusta de recursos. Herramientas como el detector de carreras de datos (go build -race) también son esenciales para prevenir errores relacionados con el acceso concurrente a la memoria.

Ronaldo Jiménez

student•

package main

import (
	"fmt"
)

// En Go, un error personalizado se crea implementando el método `Error()`
// de la interfaz `error`.

// CoffeeError representa un error específico al ordenar café
type CoffeeError struct {
	Code    int    // Un código para identificar el tipo de error
	Message string // Descripción del error
}

// El método `Error()` convierte CoffeeError en un error válido de Go
func (e CoffeeError) Error() string {
	return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
}

// orderCoffee intenta preparar un café, pero puede fallar
func orderCoffee(size string) error {
	// Simulamos algunos casos de error
	if size == "" {
		return CoffeeError{Code: 400, Message: "Debes elegir un tamaño de café."}
	}
	if size == "extra-grande" {
		return CoffeeError{Code: 404, Message: "Ese tamaño de café no existe."}
	}
	if size == "expreso" {
		return CoffeeError{Code: 503, Message: "La máquina de expreso está en mantenimiento."}
	}

	// Si no hay error, todo sale bien
	fmt.Printf("☕ Preparando tu café tamaño '%s'...\n", size)
	return nil
}

func main() {
	// Intentamos ordenar varios cafés para ver los diferentes resultados
	sizes := []string{"", "extra-grande", "expreso", "mediano"}

	for _, s := range sizes {
		err := orderCoffee(s)
		if err != nil {
			// Aquí mostramos el error personalizado
			fmt.Println("❌ Ocurrió un problema:", err)
		} else {
			fmt.Println("✅ ¡Tu café está listo!")
		}
		fmt.Println("-----------------------------")
	}
}

Ronaldo Jiménez

student•

Lo que yo entiendo del tema, lo dejo por aquí: https://github.com/JimcostDev/curso-go/tree/master/error_handling

Ronaldo Jiménez

student•

https://www.youtube.com/watch?v=a5ShJfMcNAA