El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Errores Personalizados

Siguiente ►
►

En este módulo, aprenderemos cómo crear y manejar errores personalizados en Go. Los errores personalizados son útiles para proporcionar mensajes de error más específicos y detallados, lo que facilita la depuración y el manejo de errores en nuestras aplicaciones.

Conceptos Clave

  1. Error Interface: En Go, los errores se representan mediante la interfaz error.
  2. Creación de Errores Personalizados: Podemos crear errores personalizados implementando la interfaz error.
  3. Uso de errors.New y fmt.Errorf: Estas funciones nos permiten crear errores con mensajes personalizados.
  4. Manejo de Errores Personalizados: Cómo detectar y manejar errores personalizados en nuestro código.

  1. La Interfaz error

La interfaz error en Go es muy simple y se define de la siguiente manera:

type error interface {
    Error() string
}

Cualquier tipo que implemente este método puede ser considerado un error.

  1. Creación de Errores Personalizados

Podemos crear errores personalizados definiendo un nuevo tipo que implemente la interfaz error. Aquí hay un ejemplo:

package main

import (
    "fmt"
)

// Definimos un nuevo tipo de error
type MyError struct {
    Code    int
    Message string
}

// Implementamos el método Error() para nuestro tipo MyError
func (e *MyError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
}

func main() {
    // Creamos una instancia de nuestro error personalizado
    err := &MyError{
        Code:    404,
        Message: "Resource not found",
    }

    // Imprimimos el error
    fmt.Println(err)
}

Explicación del Código

  • Definición del Tipo: Definimos un nuevo tipo MyError que tiene dos campos: Code y Message.
  • Implementación del Método Error: Implementamos el método Error() para que MyError cumpla con la interfaz error.
  • Creación e Impresión del Error: Creamos una instancia de MyError y la imprimimos.

  1. Uso de errors.New y fmt.Errorf

Go proporciona dos funciones útiles para crear errores con mensajes personalizados:

  • errors.New: Crea un error simple con un mensaje.
  • fmt.Errorf: Crea un error con un mensaje formateado.

Ejemplo con errors.New

package main

import (
    "errors"
    "fmt"
)

func main() {
    err := errors.New("an error occurred")
    fmt.Println(err)
}

Ejemplo con fmt.Errorf

package main

import (
    "fmt"
)

func main() {
    err := fmt.Errorf("an error occurred: %s", "something went wrong")
    fmt.Println(err)
}

  1. Manejo de Errores Personalizados

Para manejar errores personalizados, podemos usar una combinación de la declaración switch y la función type assertion para detectar el tipo de error.

Ejemplo de Manejo de Errores Personalizados

package main

import (
    "fmt"
)

// Definimos un nuevo tipo de error
type MyError struct {
    Code    int
    Message string
}

// Implementamos el método Error() para nuestro tipo MyError
func (e *MyError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
}

func doSomething() error {
    return &MyError{
        Code:    500,
        Message: "Internal Server Error",
    }
}

func main() {
    err := doSomething()
    if err != nil {
        switch e := err.(type) {
        case *MyError:
            fmt.Printf("Custom error occurred: %s\n", e)
        default:
            fmt.Printf("An error occurred: %s\n", err)
        }
    }
}

Explicación del Código

  • Función doSomething: Esta función simula una operación que puede devolver un error personalizado.
  • Manejo del Error: En la función main, usamos una declaración switch para detectar si el error es de tipo MyError y manejarlo en consecuencia.

Ejercicio Práctico

Ejercicio

  1. Define un nuevo tipo de error llamado ValidationError que tenga un campo Field y un campo Message.
  2. Implementa el método Error() para ValidationError.
  3. Crea una función validate que tome un string y devuelva un ValidationError si el string está vacío.
  4. En la función main, llama a validate y maneja el error personalizado.

Solución

package main

import (
    "fmt"
)

// Definimos un nuevo tipo de error
type ValidationError struct {
    Field   string
    Message string
}

// Implementamos el método Error() para nuestro tipo ValidationError
func (e *ValidationError) Error() string {
    return fmt.Sprintf("Validation error on field '%s': %s", e.Field, e.Message)
}

func validate(field string) error {
    if field == "" {
        return &ValidationError{
            Field:   "username",
            Message: "cannot be empty",
        }
    }
    return nil
}

func main() {
    err := validate("")
    if err != nil {
        switch e := err.(type) {
        case *ValidationError:
            fmt.Printf("Custom validation error occurred: %s\n", e)
        default:
            fmt.Printf("An error occurred: %s\n", err)
        }
    } else {
        fmt.Println("Validation passed")
    }
}

Explicación del Código

  • Definición de ValidationError: Creamos un nuevo tipo de error con los campos Field y Message.
  • Implementación del Método Error: Implementamos el método Error() para ValidationError.
  • Función validate: Esta función devuelve un ValidationError si el campo está vacío.
  • Manejo del Error en main: Usamos una declaración switch para detectar y manejar el ValidationError.

Conclusión

En esta sección, hemos aprendido cómo crear y manejar errores personalizados en Go. Los errores personalizados nos permiten proporcionar mensajes de error más específicos y detallados, lo que facilita la depuración y el manejo de errores en nuestras aplicaciones. En el próximo módulo, exploraremos el uso de panic y recover para manejar situaciones excepcionales en Go.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados