Go, manejo de excepciones

Cuando programamos es usual cometer ciertos errores que hacen que el flujo normal de un programa sea interrumpido. Tales como operaciones incorrectas, formateo de cadenas que no son cumplen un requisito o condición, invocación de métodos que no deberían realizarse, etc.

Go es un lenguaje moderno que ha tomado lo mejor de los lenguajes como Java, C#, etc. y ha mejorado ciertos mecanismos como el manjeo de excepciones.

Ejemplo de excepciones (en Java):

// División por cero
try{
    int divide = 2/0;
}catch(ArithmeticException ex){
    ex.printStackTrace();
}

// Acceder a un índice inexistente
int[] arreglo = {1,2,3};
try{
    int numero = arreglo[3];
}
catch(ArrayIndexOutOfBoundsException ex){
    ex.printStackTrace();
}
catch(Exception ex){
    ex.printStackTrace();
}

// Parsear una cadena no numérica o con formato incorrecto
try{
    int entero = Integer.parseInt("23f");
}catch(NumberFormatException ex){
    ex.printStackTrace();
}

// Intentar operar sobre un null
String cadena = null;
try{
    boolean vacio = cadena.isEmpty();
}catch(NullPointerException ex){
    ex.printStackTrace();
}

Tomando en cuenta estas excepciones veremos como hacer lo mismo en Go.

Para la división por cero tendríamos esto:

package main

import "fmt"

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Se detectó una excepción:", r)
        }
    }()

    divide := 2 / 0 // panic: division by zero
    fmt.Println("Resultado:", divide)
}

Un equivalente al manejo de la excepción ``ArithmeticException``.

Ejecutamos:

$ go run arithemticexcep.go

Salida:

.\arithemticexcep.go:39:16: invalid operation: division by zero

Para la excepción ``ArrayIndexOutOfBoundsException`` tendríamos algo como esto:

package main

import "fmt"

func main() {
    arreglo := []int{1, 2, 3}
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Error de índice fuera de rango:", r)
        }
    }()

    numero := arreglo[3] // panic: index out of range
    fmt.Println("Número:", numero)
}

Ejecutamos:

$ go run arrayindex.go

Salida:

Error de índice fuera de rango: runtime error: index out of range [3] with length 3

Para la excepción ``NumberFormatException`` sería de este modo:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    entero, err := strconv.Atoi("23f")
    if err != nil {
        fmt.Println("Error al convertir cadena a entero:", err)
    } else {
        fmt.Println("Entero convertido:", entero)
    }
}

Ejecutamos:

$ go run formatexception.go

Salida:

Error al convertir cadena a entero: strconv.Atoi: parsing "23f": invalid syntax

Para la excepción ``NullPointerException`` así lo podríamos gestionar:

package main

import "fmt"

func main() {
    var cadena *string = nil

    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Se detectó un puntero nulo:", r)
        }
    }()

    // Esto provocará panic si intentamos desreferenciar cadena
    if *cadena == "" {
        fmt.Println("La cadena está vacía")
    } else {
        fmt.Println("Cadena:", *cadena)
    }
}

Ejecutamos:

$ go run nullpointer.go

Salida:

Se detectó un puntero nulo: runtime error: invalid memory address or nil pointer dereference

El manejo de excepciones puede ser útil (y lo será) para que el flujo de nuestro programa no sea interrumpido. Sin embargo, no necesariamente nos asegurará que todo vaya bien. El fantasma de los null siempre puede estar presente, un acceso a una variable en el momento inadecuado o hasta el bajo rendimiento de nuestras máquinas será algo a lo que nos debemos saber enfrentar. En cualquier programa, no importando lo bien escrito y depurado que este, no se salvará de algún error.

Continuaremos sobre esta serie en próximas entregas.

Enlaces:

https://go.dev/
https://codemonkeyjunior.blogspot.com/2025/07/programando-en-c-no-8-manejo-de.html
https://alquimistadecodigo.blogspot.com/2025/07/rust-manejo-de-excepciones.html