Fundamentos del manejo de errores en Golang

Una de las características más útiles del lenguaje de programación Go es la forma en que maneja los errores. En lugar de utilizar una metodología Try/Catch como otros lenguajes de programación, Go trata los errores como valores de retorno normales.

Creando módulos sencillos y aplicando unas cuantas reglas de registro, podemos producir mensajes de error útiles para atrapar todo tipo de excepciones durante el proceso de desarrollo.

En este artículo, cubriremos algunas de las formas más básicas en que Golang encuentra y maneja estas excepciones.

Manejo básico de errores en Golang

Podemos capturar errores en Go utilizando simples sentencias if/then que comprueban las condiciones en las que no se cumplen los parámetros requeridos.

Veamos un módulo básico que podemos crear para comprobar si una cadena incluye un valor o no.

Creamos un paquete llamado «hello» e importamos los módulos estándar «errors» y «fmt» para reconocer los errores y el texto formateado:

package helloimport ("errors""fmt")

A continuación podemos crear un módulo que devuelva una cadena de texto para una variable con nombre.

func Hello(name string) (string, error) {if name == "" {return "", errors.New("No name was given")}

Lo anterior comprueba si se devuelve una cadena en blanco para la variable «nombre», que luego devuelve un nuevo error con algún texto especificado. Esta es nuestra condición de error. Una condición de error comprueba si el propio error existe.
Si la condición no se cumple (es decir, no hay error), devolvemos el valor que coincide con la variable «nombre» especificada:

message := fmt.Sprintf("Hi, %v. Welcome!", name)return message, nil}

Nota que devuelve el mensaje y el valor de «nil», lo que significa que no hay error. Esto indica al programa que llama que la función se procesó sin error.

Ahora veremos cómo podemos llamar a este paquete en un script real.

Creemos un nuevo script, llamado test.go

Como es normal en Golang, un script debe comenzar definiendo el paquete como «main». A continuación, importamos los paquetes «fmt» y «log», junto con nuestro paquete «hello» creado, como se muestra a continuación:

package mainimport ("fmt""log""yoursite.com/hello")

A continuación, definimos nuestra función main, establecemos unas cuantas propiedades para nuestro logger con el fin de crear un prefijo fácil de entender, y (por razones de seguridad) creamos una bandera para que no mostremos la hora, el archivo fuente y el número de línea.

func main() {log.SetPrefix("Hello: ")log.SetFlags(0)

A continuación, especificaremos un mensaje a mostrar:

message, err := hello.Hello("")

Por último, buscamos si hay un error comprobando si «err» no es igual a «nil». Si es así, imprimimos el mensaje en la consola y salimos.

if err != nil {log.Fatal(err)}

Si no existe ninguna condición de error, simplemente imprimimos el mensaje que se definió en nuestro paquete hello.

fmt.Println(message)}

Para probar esto, podemos ejecutar el código tal cual. Una vez que lo hagamos, deberíamos obtener un resultado parecido a este:

>go run test.gogreetings: No name was givenexit status 1

Si queremos modificar nuestro script test.go, introducimos algo así:

message, err := hello.Hello("John")

Nuestra salida debería entonces tener este aspecto:

>go run test.goHi, John. Welcome!

Otro tipo de mensaje de error que podemos devolver es:

fmt.Errorf – esto formateará una cadena según las reglas de Printf.

Manejo de enteros en Golang

Por supuesto, los errores de cadena son sólo un tipo de error. Con el manejo de errores de Golang, hay varios otros errores que puedes comprobar en tu código. Uno en particular que debes conocer son los errores numéricos.

El manejo de enteros es sencillo para Go. Así es como funciona:

Supongamos que tenemos errores numéricos, como si tuviéramos que dividir por cero. Primero creamos una función «División», que divide dos variables x por y. Para la primera parte de nuestra condición if/then, necesitamos asegurarnos de que y no es igual a cero:

func Division(x int, y int) (int, error) {if y == 0 {return 0, errors.New("Thou shalt not divide by zero!")} else {return (x / y), nil}}

Esta es la función principal. Ahora, puedes pasarle dos variables. En este ejemplo, usaremos 12 y 0.

func main() {if result, err := Division(12, 0); err != nil {fmt.Println("We got an error: ", err)} else {fmt.Println("The answer is", result)}}

Entonces recibirás un mensaje que dice algo como:

«Tenemos un error: Thou shalt not divide by zero!»

Este es sólo un ejemplo de cómo puedes utilizar el manejo de errores de Golang para encontrar errores numéricos. Realmente, con las funciones adecuadas, puedes encontrar varios errores por tu cuenta a través de Golang.

Encontrando errores de estado HTTP

Con Golang, puedes traer errores de estado HTTP si una API a la que estamos llamando entrega uno.

Así es como:

Primero, vamos a importar un nuevo paquete, «net/http»:

import ( "fmt" "log" "net/http")

En nuestra función principal, llamamos a una app (por ejemplo, una web) y registramos cualquier error. Sabemos que las solicitudes exitosas caen dentro del rango 2xx, así que crea un estado respectivo que encuentre cualquier error HTTP que caiga fuera de este rango. Puedes hacer esto de la siguiente manera:

func main() { resp, err := http.Get("https://example.com") if err != nil { log.Fatal(err) } fmt.Println("HTTP Response Status:", resp.StatusCode, http.StatusText(resp.StatusCode)) if resp.StatusCode >= 200 && resp.StatusCode 

Como puedes ver, nuestra función principal se establece en

>= 200 && resp.StatusCode <= 299

que comprobará si alguna petición HTTP cae dentro del rango 2xx. Si la petición no cumple esta condición, mostrará un mensaje de error.

Con un solo módulo, puedes reunir rápidamente toda la información que necesitas para encontrar y arreglar tu código Golang.

Resumen

Esta guía sólo araña la superficie en cuanto a cómo el lenguaje Go está diseñado para manejar los errores. Sin embargo, aspectos básicos como la forma de comprobar la existencia de una cadena, la forma de plantear una condición de error si se presenta una declaración numérica ilógica, y la forma de comprobar los códigos de estado HTTP de una respuesta son todos los grandes lugares para comenzar en su viaje de monitoreo de errores Golang.

¿No tiene tiempo para comprobar y utilizar estas técnicas de manejo de errores Golang manualmente? Ahí es donde herramientas como Airbrake Error Monitoring son útiles. Con Airbrake Error Monitoring, podrás encontrar errores rápidamente sin necesidad de crear módulos individuales. Prueba Airbrake Error Monitoring gratis durante 30 días para un número ilimitado de errores y eventos de rendimiento.