¿Cómo manejar los errores en Golang?

Como Manejar Los Errores En Golang



Go es un lenguaje de programación muy apreciado que ha ganado popularidad debido a su eficacia, velocidad y eficiencia. Sin embargo, pueden ocurrir errores durante las fases de desarrollo y ejecución, al igual que con cualquier otro lenguaje de programación. El manejo efectivo de los errores es esencial para garantizar la confiabilidad y estabilidad de sus programas Go.

Este artículo examinará varios métodos y procedimientos recomendados para administrar errores en Go.







Manejar errores en Golang

En Go, puedes manejar errores a través de los métodos mencionados a continuación:



1: función nueva ()

El lenguaje Go proporciona la Nuevo() Función para gestionar errores. Esta función, disponible en el paquete de errores integrado, permite a los desarrolladores crear mensajes de error personalizados para sus programas. Al utilizar el Nuevo() función, los desarrolladores pueden manejar los errores de manera efectiva y proporcionar mensajes de error significativos a los usuarios.



paquete principal

importar 'errores'
importar 'fmt'

comprobación de funciones ( cadena de nombre ) error {
nError := errores.Nuevo ( 'Nombre inválido' )
  si nombre ! = 'linux' {
    devolver error
  }
  devolver nulo
}
función principal ( ) {
nombre := 'linux'
error := verificar ( nombre )
  si errar ! = cero {
fmt.Println ( errar )
  } demás {
fmt.Println ( 'Nombre válido' )
  }
}

 





El código anterior utiliza el Nuevo() comprobarNombre función para ver si la cadena linux coincide con el nombre dado. La función produce un error con el mensaje. Nombre inválido si el nombre no es linux . La función devuelve nil para mostrar que no hubo error si el nombre es igual a linux .

La variable de nombre se establece en linux en la llamada de la función principal a la comprobarNombre función, que también toma la variable de nombre como argumento. La función principal imprime el mensaje de error si el comprobarNombre La función devuelve un error. La función principal imprime el Nombre válido Si el comprobarNombre la función devuelve cero.



Producción

2: Función Errorf()

El errorf() La función en Go también nos permite manejar errores. errorf() nos da la opción de formatear el mensaje de error. Al importar el paquete fmt, los desarrolladores pueden utilizarlo para personalizar los mensajes de error según sus necesidades. errorf() agiliza y mejora la eficiencia de la gestión y transmisión de errores en Go.

paquete principal
importar 'fmt'

función div ( n1, n2 tu ) error {

  si n2 == 0 {
    devolver fmt.Errorf ( '%d / %d \norte No se puede dividir un número por cero' , n1, n2 )
  }
  devolver nulo
}
función principal ( ) {
error := div ( 42 , 0 )
  si errar ! = cero {
fmt.Printf ( 'error: %s' , errar )
  } demás {
fmt.Println ( 'División válida' )
  }
}

 

En el código anterior, el división La función acepta dos entradas enteras, n1 y n2, y si n2 es cero, produce un error. La función produce un error con un mensaje que contiene los valores de n1 y n2 si n2 es cero. La función devuelve nil para mostrar que no hubo error si n2 no es cero.

El error que devuelve div se guarda en la variable err cuando la función principal ejecuta div con los valores 42 y 0. La función principal usa fmt.Printf para mostrar el mensaje de error si la función div devuelve un error. La función principal imprime División válida si la función div devuelve nil.

Producción

3: Manejo explícito de errores

Go fomenta la gestión explícita de errores en comparación con otros lenguajes de programación, que con frecuencia se basan en excepciones. Este enfoque alienta a los desarrolladores a usar declaraciones if para verificar explícitamente los errores, en lugar de depender de los bloques try-catch. Al hacer esto, es más probable que los errores se encuentren y se resuelvan adecuadamente. Para facilitar esto, Go proporciona la si yerra != nulo declaración, que permite a los desarrolladores comprobar si hay errores después de ejecutar una función y tomar las medidas adecuadas en función del resultado. Con un manejo de errores explícito, Go ofrece un enfoque más estructurado y confiable para el manejo de errores.

paquete principal
importar 'fmt'

función dividir ( a, b flotante64 ) ( float64, error ) {
    si segundo == 0 {
        devolver 0 , fmt.Errorf ( 'no se puede dividir por cero' )
    }
    devolver a / b, cero
}
función principal ( ) {
resultado, err := dividir ( 13 , 3 )
    si errar ! = cero {
fmt.Printf ( 'Error: %v \norte ' , errar )
    } demás {
fmt.Printf ( 'Resultado: %f \norte ' , resultado )
    }
resultado, err = dividir ( 23 , 0 )
    si errar ! = cero {
fmt.Printf ( 'Error: %v \norte ' , errar )
    } demás {
fmt.Printf ( 'Resultado: %f \norte ' , resultado )
    }
}

 

En esta ilustración, la función de división se usa para dividir dos valores. El resultado es el resultado de hacerlo. Si el segundo número es 0, la función produce un error con un mensaje de error distinto.

Divide se llama dos veces en la función principal: una vez con entradas válidas y otra vez con entradas no válidas. El si error! = cero se utiliza para determinar si se produjo un error cada vez que se utiliza la función de división. Se imprime un mensaje de error si ocurre alguno. Si no, se imprime el resultado.

Producción

4: Diferir, entrar en pánico y recuperar

Golang también proporciona la aplazar declaración, que se utiliza para ejecutar una función después de la finalización de un programa o un bloque específico de código. El aplazar La declaración se usa a menudo junto con la recuperar Función para detectar y recuperarse de errores de pánico en tiempo de ejecución. Cuando ocurre un error de pánico en tiempo de ejecución, el recuperar La función se utiliza para recuperarse de la condición de error y evitar que el programa se bloquee. Esto es útil para tareas de limpieza como cerrar archivos, cerrar conexiones de red o liberar recursos. Al aplazar estas tareas, se asegura de que se ejecuten incluso si se produce un error.

El pánico se utiliza para detener la ejecución normal del programa cuando ocurre un error inesperado, mientras que recuperar se utiliza para manejar el pánico y continuar la ejecución del programa.

paquete principal

importar 'fmt'

función recuperarDePánico ( ) {
    si r := recuperar ( ) ; r ! = cero {
fmt.Println ( 'Recuperado del pánico:' r )
    }
}
función dividir ( x, y float64 ) flotar64 {
aplazar la recuperación del pánico ( )

    si y == 0 {
pánico ( 'no se puede dividir por cero' )
    }
    devolver X / y
}
función principal ( ) {
fmt.Println ( dividir ( 13 , 3 ) )
fmt.Println ( dividir ( 23 , 0 ) )
}

 

En el código anterior, la función de división se usa para dividir dos valores de punto flotante. El resultado es el resultado de hacerlo. La función emite un mensaje de error personalizado si el segundo número es cero. La instrucción defer se utiliza para invocar el recuperarDePánico función. El recuperarDePánico La función detectará un pánico que ocurrió dentro de la función de división e imprimirá un error si ocurrió.

Divide se llama dos veces en la función principal: una vez con entradas válidas y otra vez con entradas no válidas. El fmt.Println La función imprime la salida de la función cada vez que se ejecuta la función de división. El recuperarDePánico La función detectará un pánico si ocurre e imprimirá un error si lo hace.

Producción

Después de detectar el error, el programa se recuperó del pánico y siguió funcionando. Sin embargo, el código entró en pánico y no devolvió un valor en la segunda llamada a dividir, por lo que devolvió cero.

5: Envoltura de errores

Go también incluye una característica conocida como Envoltura de errores , que le permite agregar contexto adicional a un mensaje de error. Esto es útil para registrar problemas o proporcionar más detalles en los mensajes de error. Esto se puede lograr creando un tipo de error que incluya el error original y el contexto adicional.

paquete principal

importar 'errores'
importar 'fmt'

función principal ( ) {
    si err := bar ( ) ; errar ! = cero {
fmt.Println ( errar )
    }
}
función dividir ( a, b flotante64 ) ( float64, error ) {
    si segundo == 0 {
        devolver 0 , errors.New ( 'división por cero' )
    }
    devolver a / b, cero
}
barra de funciones ( ) ( errar error ) {
_, err = dividir ( 42 , 0 )
    si errar ! = cero {
        devolver fmt.Errorf ( 'error al calcular: %w' , errar )
    }
    devolver nulo
}

 

En el código anterior, la función de división calcula la proporción de dos números en este ejemplo y arroja un error si el segundo valor es cero. La función de barra llama a la función de dividir y luego envuelve el error que dividir devuelve un nuevo error con un mensaje que incluye el mensaje de error original utilizando la función fmt.Errorf. La función de barra es llamada por la función principal, que también imprime los errores que devuelve.

Producción

Conclusión

El desarrollo de software debe incluir manejo de errores , y Golang tiene varias funciones y métodos integrados para hacerlo con gracia. Estos mecanismos permiten a los desarrolladores detectar errores y recuperarse de ellos, evitar bloqueos del programa y proporcionar mensajes de error informativos a los usuarios finales. Mediante el uso efectivo de estos mecanismos de manejo de errores, los desarrolladores pueden crear aplicaciones de software sólidas, confiables y eficientes.