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

Conceptos Básicos de Manejo de Errores

Siguiente ►
►

El manejo de errores es una parte crucial de la programación en cualquier lenguaje, y Go no es la excepción. En este módulo, aprenderás cómo manejar errores de manera efectiva en Go, lo que te permitirá escribir código más robusto y confiable.

  1. Introducción al Manejo de Errores en Go

En Go, el manejo de errores se realiza de manera explícita. A diferencia de otros lenguajes que utilizan excepciones, Go utiliza valores de retorno para indicar errores. Esto hace que el manejo de errores sea más claro y predecible.

Ejemplo Básico

package main

import (
    "errors"
    "fmt"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(4, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

Explicación del Código

  1. Importación de Paquetes: Importamos los paquetes errors y fmt.
  2. Función divide: Esta función toma dos números a y b y devuelve el resultado de la división y un error. Si b es 0, la función retorna un error utilizando errors.New.
  3. Manejo del Error en main: Llamamos a la función divide y verificamos si hay un error. Si hay un error, lo imprimimos; de lo contrario, imprimimos el resultado.

  1. Uso del Paquete errors

El paquete errors proporciona una manera sencilla de crear errores. La función errors.New toma un mensaje de error y devuelve un valor de tipo error.

Ejemplo

package main

import (
    "errors"
    "fmt"
)

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

  1. Comprobación de Errores

En Go, es común comprobar los errores inmediatamente después de una operación que puede fallar. Esto se hace utilizando una declaración if.

Ejemplo

package main

import (
    "fmt"
    "strconv"
)

func main() {
    num, err := strconv.Atoi("123a")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Number:", num)
    }
}

Explicación del Código

  1. Conversión de Cadena a Entero: Intentamos convertir la cadena "123a" a un entero utilizando strconv.Atoi.
  2. Comprobación del Error: Si hay un error, lo imprimimos; de lo contrario, imprimimos el número convertido.

  1. Errores Personalizados

Puedes definir tus propios tipos de error para proporcionar más contexto sobre lo que salió mal.

Ejemplo

package main

import (
    "fmt"
)

type MyError struct {
    Msg string
}

func (e *MyError) Error() string {
    return e.Msg
}

func doSomething(flag bool) error {
    if !flag {
        return &MyError{Msg: "something went wrong"}
    }
    return nil
}

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

Explicación del Código

  1. Definición de MyError: Creamos un tipo MyError que implementa la interfaz error.
  2. Función doSomething: Esta función retorna un error de tipo MyError si flag es false.
  3. Manejo del Error en main: Llamamos a doSomething y verificamos si hay un error. Si hay un error, lo imprimimos.

Ejercicio Práctico

Ejercicio

Escribe una función sqrt que calcule la raíz cuadrada de un número. Si el número es negativo, la función debe retornar un error.

package main

import (
    "errors"
    "fmt"
    "math"
)

func sqrt(x float64) (float64, error) {
    if x < 0 {
        return 0, errors.New("cannot compute square root of a negative number")
    }
    return math.Sqrt(x), nil
}

func main() {
    result, err := sqrt(-4)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

Solución

  1. Función sqrt: La función toma un número x y retorna su raíz cuadrada y un error. Si x es negativo, retorna un error.
  2. Manejo del Error en main: Llamamos a sqrt con un número negativo y verificamos si hay un error. Si hay un error, lo imprimimos; de lo contrario, imprimimos el resultado.

Conclusión

En esta sección, hemos aprendido los conceptos básicos del manejo de errores en Go. Hemos visto cómo crear y manejar errores utilizando el paquete errors, cómo definir errores personalizados y cómo comprobar errores de manera efectiva. Estos conceptos son fundamentales para escribir código robusto y confiable en Go.

En el próximo módulo, exploraremos cómo crear errores personalizados más avanzados y cómo manejar situaciones de pánico y recuperación.

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