Paquete local de importación de Golang

En Go, un paquete se refiere a una colección de archivos de código fuente de GO en el mismo directorio que se compilan juntos. Por lo general, utilizará estos paquetes para exportar e importar código entre ellos. Esto a su vez hace que el código sea modular y fácil de mantener.

Sin embargo, si recién ingresa al lenguaje de programación GO, puede ser bastante difícil descubrir cómo importar el paquete local. De eso se trata este tutorial.

Paquete Golang

Para comprender mejor qué es un paquete Go, tomemos un proyecto llamado My Workspace. Dentro del directorio del espacio de trabajo, tiene 3 directorios más llamados Dir1, Dir2 y Dir3.

Por lo tanto, el árbol del directorio es como se muestra:

└─── space
├─se
├─se
└───Dir3

Esto significa que el proyecto de espacio de trabajo tiene 3 paquetes. Cada archivo creado en cada directorio se convierte en una parte de ese paquete (directorio).

Tenga en cuenta que el proyecto principal es lo que se conoce como el paquete principal. En la mayoría de los casos, encontrará archivos como Main.Vaya con la primera línea de código como "

paquete principal

Volviendo al proyecto de espacio de trabajo, será la primera entrada en cada uno de los archivos con el nombre del paquete bajo el cual pertenecen.

Un ejemplo es como:

Paquete Dir1 // para archivos en Dir1
Paquete Dir2 // para archivos en Dir2
Paquete Dir3 // para DIR3

Cada archivo dentro de un paquete puede exportar su código. Otros archivos dentro del proyecto pueden hacer referencia a ese paquete (directorio) e importar el código desde los archivos. Esto le permite importar un solo paquete y todo el código en los archivos en ese paquete será accesible para su uso.

Para crear un nuevo paquete en su proyecto, puede crear un nuevo directorio.

Veamos un ejemplo práctico para crear paquetes Go.

Golang Inicializar el módulo

El primer paso cuando los paquetes de importación es inicializar un nuevo módulo. Puedes hacerlo ejecutando el comando:

Go Mod Init

Por ejemplo, en el directorio del espacio de trabajo, podemos crear un nuevo módulo como:

Espacio de trabajo de Go Mod Init

Una vez que ejecutas el init de mod, se crea un go.archivo mod que realiza un seguimiento de los módulos que importa. El archivo también contiene información como el nombre del módulo, la versión GO, etc.

Piense en ello como el paquete.archivo json en nodo.

Cuida el nombramiento de tus módulos como lo requerirás al importar tus paquetes. Un ejemplo de Go.El archivo mod es como se muestra:

espacio de trabajo del módulo
ir 1.17

Como no tenemos paquetes externos, el archivo contiene el nombre del módulo y la versión GO.

Paquete de creación de Golang

Como se mencionó, para crear un paquete en su proyecto GO, cree un nuevo directorio y agregue los archivos del código fuente en ese paquete.

Por ejemplo, creemos archivos de origen Go para paquetes Dir1, Dir2 y Dir3.

$ touch Dir1/Dir1.ir
$ touch Dir2/Dir12.ir
$ touch Dir3/Dir3.ir

En la primera línea de cada archivo, incluya el espacio de nombres del paquete como:

Paquete Dir1 // Reemplazar Dir2 con el nombre del paquete

A continuación, agregemos algún código en cada uno de estos archivos.

// Dir1.ir
Paquete Dir1
string funcsayhello ()
Regrese "HI del paquete Dir1"

// Dir2.ir
Paquete Dir2
string funcsayrunning ()
devolver "Estoy ejecutando desde el paquete dir2"

// Dir3.ir
Paquete Dir3
FuncsayBye () cadena
Regrese "Adiós del paquete Dir3"

Los ejemplos anteriores son simples. Son solo funciones que devuelven un valor de cadena de cada paquete.

Nota: Para exportar una variable o una función desde un paquete GO, asegúrese de iniciar el nombre de la función o variable con una letra mayúscula.

De nuevo: ☝️☝️☝️☝️☝️

Golang Importa paquetes locales

El último paso es importar sus paquetes locales para que pueda usar el código en cada uno de ellos. En la raíz de su proyecto, también conocido como, el directorio del espacio de trabajo, cree un.Archivo GO.

A continuación, agregue las siguientes líneas para importar sus paquetes locales:

paquete principal
importar (
"FMT"
"Espacio de trabajo/Dir1"
"Espacio de trabajo/Dir2"
"Espacio de trabajo/Dir3"
)
funcmain ()
fmt.Println (Dir1.Di hola())
fmt.Println (Dir2.Sayrunning ())
fmt.Println (Dir3.Di adiós())

En el ejemplo anterior, agregamos 3 cláusulas de importación para importar todos los paquetes en nuestro programa.

Una vez importado, podemos usar el código exportado en los paquetes.

Luego podemos ejecutar el código en Main.IR FILE AS:

$ Go Run Main.ir
Hola del paquete Dir1
Estoy ejecutando del paquete dir2
Adiós del paquete dir3

Verá la salida exportada por las funciones de los paquetes.

Conclusión

En este artículo, discutimos cómo puede exportar e importar código utilizando paquetes GO. Los paquetes son una forma muy práctica y limpia de organizar su código y retener la legibilidad y el mantenimiento. Esperamos que hayas disfrutado!