Go (también conocido como Golang) es un lenguaje de programación de código abierto y tipado estático. Fue desarrollado originalmente por Google. Algunas características notables de Go incluyen la simplicidad, el alto rendimiento, la legibilidad y la eficiencia.
Al igual que cualquier otro lenguaje de programación destacado, la biblioteca estándar de Go ofrece un amplio conjunto de paquetes. Sin embargo, también podemos extender las funcionalidades incorporando paquetes de terceros. Esta guía demostrará cómo importar paquetes e incorporarlos a sus proyectos de Go.
Requisitos previos
Para seguir esta guía, necesitará tener a su disposición los siguientes componentes preparados:
- Un servidor Ubuntu configurado correctamente. Obtenga más información sobre cómo configurar su propio servidor Ubuntu en CloudSigma.
- El entorno de programación de Go. Puede utilizar esta guía sobre cómo instalar Go en Ubuntu.
- Un editor de texto moderno, por ejemplo, Vim, Sublime Text, Atom, Visual Studio Code, Brackets, etc. Esta guía presentará Visual Studio Code .
Paso 1 – Instalación de Go
Ya analizamos la instalación del núcleo del lenguaje de programación Go en Ubuntu 20.04. Sin embargo, existe un método alternativo más sencillo: g (un administrador de versiones de Go ligero).
La razón por la que vamos a utilizar g es que ninguna de las versiones de Go disponibles en los repositorios de paquetes de Ubuntu o snap incluye la última versión disponible de Go (v1.18 al momento de escribir esta guía). Siempre se recomienda utilizar la última versión disponible de cualquier paquete de lenguaje de programación.
El siguiente comando ejecutará el g script de instalación:
|
1 |
wget -qO- https://git.io/g-install | sh -s |
Para que los cambios surtan efecto, debe reiniciar la sesión de la shell. Después de reiniciar, verifique la instalación:
|
1 |
go version |
|
1 |
which go |
Después de instalar Go, también se recomienda instalar gopls . Es el servidor de lenguaje oficial de Go. Es compatible con muchos editores de texto como VS Code, Vim, Emacs, Sublime Text, Atom y muchos más. Ejecute el siguiente comando:
|
1 |
go install golang.org/x/tools/gopls@latest |
Nuestro entorno de programación de Go ya está listo.
Paso 2 – Creación de un script de Go de ejemplo
Todo el código demostrado en esta guía cabrá en un solo script de Go. Cree un script de Go de ejemplo:
|
1 |
touch practice.go |
Después de realizar cambios en el script, podemos ejecutarlo utilizando el siguiente comando de Go:
|
1 |
go run practice.go |
Aquí, el compilador de Go ejecutará el código en modo intérprete.
Paso 3 – Uso de paquetes de la biblioteca estándar
Go viene con una gran colección en su biblioteca estándar. Consta de numerosos paquetes, por ejemplo:
- fmt: Implementa E/S formateada con funciones análogas a C ( printf y scanf ).
- http: Este paquete proporciona funciones para crear servicios web, enviar y recuperar datos a través del http protocolo, etc.
Para incorporar cualquier paquete en un proyecto de Go, tiene que ser implementado utilizando la instrucción import . La instrucción se declara mediante la palabra clave import junto con los nombres de los paquetes. Por ejemplo, para importar math/rand , la instrucción de importación se vería así:
|
1 |
import "math/rand" |
El siguiente código implementa varias funciones del paquete math/rand :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "math/rand" func main() { for i := 0; i < 10; i++ { println(rand.Intn(25)) } } |
Este código demuestra un bucle for simple que imprime 10 enteros aleatorios (del 0 al 24) en la pantalla. Aquí:
- rand.Int() : Esta llamada a la función devuelve un entero aleatorio.
- rand.Intn() : Actúa de manera similar a rand.Int() pero acepta un parámetro que define el rango para los enteros aleatorios (desde 0 hasta el número especificado).
A continuación, ejecute el código:
|
1 |
go run practice.go |
La salida se verá así:
Tenga en cuenta que la salida será exactamente la misma, ya que la semilla para el generador de números aleatorios es un valor fijo por defecto. Esta es la naturaleza de un generador de números pseudoaleatorios. Puedes aprender más sobre la semilla aleatoria aquí.
Paso 4 – Importar múltiples paquetes
Los proyectos más grandes y complejos necesitan incorporar múltiples paquetes. ¿Cómo los importas en tu código de Go? Una opción válida es utilizar declaraciones de importación individuales para cada paquete importado. Sin embargo, este enfoque es ineficiente en comparación con la siguiente estructura de importación:
|
1 2 3 4 5 6 7 8 9 |
import ( "<package_1>" "<package_2>" "<package_3>" ) |
Aquí, una sola declaración de importación incorpora múltiples paquetes al mismo tiempo. Esto reduce la cantidad de código que es necesario escribir, al tiempo que mejora la legibilidad.
El siguiente código pone en acción esta característica:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Ejecuta el código:
|
1 |
go run practice.go |
La salida se verá algo así:
Paso 5 – Instalar bibliotecas adicionales de Go
La biblioteca estándar de Go incluye numerosos paquetes útiles. Estos son, por diseño, de propósito general. Permite a los desarrolladores crear sus propios paquetes sobre la biblioteca estándar para satisfacer sus necesidades específicas. Echa un vistazo a la base de datos oficial de paquetes de Go.
¿Qué pasa si necesitas implementar un paquete de Go de terceros? Go incluye el comando go install ( go get está obsoleto). Puede obtener cualquier paquete de Go de terceros de Internet.
Para la demostración, vamos a instalar el paquete cobra-cli . El siguiente comando de Go descargará e instalará los archivos necesarios e integrará el paquete en el sistema de bibliotecas de Go:
|
1 |
go install github.com/spf13/cobra-cli@latest |
El binario de cobra-cli debería estar ubicado en la siguiente ubicación:
|
1 |
ls -l $GOPATH/bin |
Los otros archivos del paquete deberían estar ubicados en la siguiente ubicación:
|
1 |
ls -l $GOPATH/pkg/mod/github.com/spf13 |
A partir de Go v1.11, los módulos de Go definen la versión del paquete que deseas importar. Esto se explica en detalle aquí: GitHub de Go Modules.
Paso 6 – Alias de paquetes
En varias situaciones, puedes encontrar nombres de paquetes en conflicto entre los paquetes locales y los importados. Aquí es donde el uso de alias puede resolver la colisión. La estructura de alias se ve algo así:
|
1 |
import <alias> "import_package_name" |
Modifiquemos nuestro programa simple de Go para incorporar fmt_alias como un alias para el paquete fmt :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( fmt_alias "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt_alias.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Ten en cuenta que en lugar de usar fmt.Printf() , estamos usando el alias de paquete fmt_alias.Printf() .
Sin embargo, Go no es muy amigable con los alias. Cuando utilizas alias para evitar la colisión de nombres de importación, se recomienda asignar un alias a la importación más local o específica del proyecto. Por ejemplo, si deseas tener tanto un paquete local strings y un paquete del sistema strings , entonces deberías asignar un alias al paquete local, no al paquete del sistema.
La mejor práctica es evitar las colisiones de nombres en primer lugar.
Paso 7 – Formato de importaciones
Aprendimos a declarar todas las importaciones utilizando una sola declaración import . ¿Qué pasa si tuvieras varias importaciones? Por ejemplo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import ( "fmt" "os" "github.com/example/foo" "github.com/example/bar" "math/rand" "github.com/abc/pqr/xyz" ) |
El formateo de importaciones ordena los paquetes en un orden específico, mejorando la consistencia del código. Como solo ordena el orden de las importaciones, también evita commits aleatorios. También evita la rotación innecesaria de código y las revisiones de código confusas.
La mayoría de los editores modernos formatearán las importaciones por ti automáticamente. Alternativamente, admiten goimports. Es una práctica común en la industria utilizar goimports en lugar de ordenar manualmente las importaciones. Además, goimports también refleja los cambios de estilo en el código.
Así es como puede verse el bloque import después de aplicar goimports :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import ( fmt_alias "fmt" "math/rand" "os" "github.com/example/foo" "github.com/example/bar" "github.com/abc/pqr/xyz" ) |
¿Notas algún patrón?
- Todas las bibliotecas estándar se agrupan primero.
- Los grupos están separados por líneas en blanco, lo que mejora la legibilidad del código.
Reflexiones finales
Las importaciones en Go son una característica potente que permite llamar a funciones que no están integradas en Go. Aunque la biblioteca estándar ofrece muchos paquetes de propósito general, Go también admite paquetes de terceros. Esta guía demuestra cómo importar paquetes de Go integrados y de terceros.
En esta guía, ejecutamos nuestros programas de Go utilizando el intérprete. Sin embargo, puedes compilar el código en binarios independientes para obtener un mejor rendimiento. Puedes obtener más información sobre cómo compilar programas de Go aquí. Si quieres aprender cómo desplegar una aplicación web de Go con Nginx, consulta este tutorial. Además, puedes echar un vistazo a nuestra guía que muestra cómo escribir tus propios paquetes de Go.
¿Eres un desarrollador de Go? CloudSigma ofrece soporte para la API de Go para una integración perfecta con tus proyectos.
¡Feliz computación!
Comentarios
Aún no hay comentarios. Sea el primero.