Manejo básico de errores

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

Manejo básico de errores es un patrón fundamental en Go donde se comprueban los errores después de operaciones que podrían fallar.

Aprendamos a manejar errores en Go creando una función de división simple que devuelva un error al dividir por cero:

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

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

Ahora, veamos cómo usar esta función y manejar cualquier error potencial:

result, err := divide(10, 0)
    
if err != nil {
    fmt.Println("Error occurred:", err)
    return // Detener la ejecución o manejar el error
}
    
fmt.Println("Result:", result)

Después de ejecutar este código, comprobamos si ocurrió un error usando la condición if err != nil. Dado que intentamos dividir por cero, la función devuelve un error y se mostrará lo siguiente en la pantalla:

Error occurred: division by zero

Este patrón de devolver un error como el último valor de retorno y comprobarlo inmediatamente es muy común en Go. Permite que tu programa maneje los fallos de forma controlada en lugar de bloquearse.

Desafío

Fácil

En este desafío, practicarás el manejo básico de errores en Go. Tienes una función que divide dos números, pero la división por cero causa un error de tiempo de ejecución. Tu tarea es agregar el manejo de errores para prevenir este fallo.

El código ya tiene una función que devuelve tanto un resultado como un error. Debes verificar si hay un error antes de usar el resultado.

Hoja de referencia

En Go, las funciones que podrían fallar devuelven un error como último valor de retorno:

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

Compruebe si hay errores utilizando if err != nil:

result, err := divide(10, 0)
    
if err != nil {
    fmt.Println("Error occurred:", err)
    return // Detener la ejecución o manejar el error
}
    
fmt.Println("Result:", result)

Este patrón permite que los programas manejen los fallos de forma controlada en lugar de bloquearse.

Pruébalo tú mismo

package main

import (
	"errors"
	"fmt"
)

// Esta función divide x por y y devuelve un error si y es cero
func divide(x, y float64) (float64, error) {
	if y == 0 {
		return 0, errors.New("cannot divide by zero")
	}
	return x / y, nil
}

func main() {
	// Valores de prueba
	numerator := 10.0
	denominator := 0.0
	
	// Llamar a la función divide
	result, err := divide(numerator, denominator)
	
	// TODO: Comprobar si err no es nil (hay un error)
	// Si hay un error, imprimirlo usando fmt.Println(err)
	// De lo contrario, imprimir el resultado usando fmt.Printf("Result: %.2f\n", result)
	
	// Eliminar esta línea e implementar el manejo de errores adecuado arriba
	fmt.Printf("Result: %.2f\n", result)
}