El concepto de errores

Parte de la sección Fundamentos del Journey de GO de Coddy — lección 102 de 109.

En Go, los errores son valores que indican que algo salió mal. Go maneja los errores de forma explícita en lugar de usar excepciones.

Vamos a crear una función que podría producir un error al dividir números:

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

Esta función devuelve dos valores: el resultado de la división y un posible error. Si el divisor es cero, devolvemos un mensaje de error en lugar de intentar la división.

Ahora, usemos nuestra función y manejemos cualquier error potencial:

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

Después de ejecutar este código, veremos un mensaje de error en la pantalla porque intentamos dividir por cero:

Error: cannot divide by zero

Esto demuestra el patrón de manejo de errores de Go: verificar si ocurrió un error (err != nil) y luego tomar la acción apropiada. Si no ocurrió ningún error, podemos usar el resultado de forma segura.

Desafío

Fácil

En este desafío, practicarás el trabajo con errores en Go. Crearás una función que divida dos números y devuelva un error si se intenta una división por cero.

Tu tarea es:

Completa la función divide que toma dos enteros y devuelve su cociente y un error.
Si el divisor es cero, devuelve 0 y un error con el mensaje "division by zero".
Si la división es válida, devuelve el resultado y nil para el error.
En la función main, llama a divide con los valores proporcionados y maneja cualquier error de manera apropiada.

Este ejercicio demuestra cómo las funciones de Go comúnmente devuelven un resultado y un error, y cómo verificar y manejar esos errores.

Hoja de referencia

En Go, los errores son valores que indican que algo salió mal. Go maneja los errores de forma explícita en lugar de utilizar excepciones.

Las funciones que podrían fallar devuelven dos valores: el resultado y un error potencial:

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

Para manejar errores, verifique si el error no es nil:

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

Utilice errors.New() para crear nuevos mensajes de error y devuelva nil cuando no ocurra ningún error.

Pruébalo tú mismo

package main
import (
    "errors"
    "fmt"
)
// divide divide a entre b y devuelve el resultado
// Si b es 0, devuelve un error
func divide(a, b int) (int, error) {
    // TODO: Implementar la función divide
    // Si b es 0, devolver 0 y un error con el mensaje "division by zero"
    // De lo contrario, devolver a/b y nil para el error

}
func main() {
    // Primer caso de prueba
    a, b := 10, 2
    result, err := divide(a, b)
    if err != nil {
        fmt.Printf("Error: %s\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }

    // Segundo caso de prueba
    a, b = 8, 0
    result, err = divide(a, b)
    if err != nil {
        fmt.Printf("Error: %s\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }
}