Package local de Golang Importer

Dans Go, un package fait référence à une collection de fichiers de code source GO dans le même répertoire qui sont compilés ensemble. En règle générale, vous utiliserez ces packages pour exporter et importer du code entre eux. Cela rend le code modulaire et facile à entretenir.

Cependant, si vous vous retrouvez dans le langage de programmation Go, il peut être assez difficile de comprendre comment importer un package local. C'est de cela que parle ce tutoriel.

Package de Golang

Pour mieux comprendre ce qu'est un package Go, prenons un projet appelé mon espace de travail. À l'intérieur du répertoire de l'espace de travail, vous avez 3 autres répertoires appelés dir1, dir2 et dir3.

Par conséquent, l'arbre d'annuaire est comme indiqué:

└fiques
├tilies
├fiques
└fiques

Cela signifie que le projet d'espace de travail a 3 packages. Chaque fichier créé sous chaque répertoire devient une partie de ce package (répertoire).

Gardez à l'esprit que le projet principal est ce que l'on appelle le package principal. Dans la plupart des cas, vous trouverez des fichiers tels que.Allez avec la première ligne de code comme "

package principal

Revenant au projet Workspace, vous serez la première entrée dans chacun des fichiers avec le nom du package sous lequel ils appartiennent.

Un exemple est:

package dir1 // pour les fichiers dans dir1
package dir2 // pour les fichiers dans dir2
package dir3 // pour dir3

Chaque fichier d'un package peut exporter son code. D'autres fichiers du projet peuvent ensuite référencer ce package (répertoire) et importer le code à partir des fichiers. Cela vous permet d'importer simplement un seul package et tout le code des fichiers dans ce package sera accessible pour une utilisation.

Pour créer un nouveau package dans votre projet, vous pouvez simplement créer un nouveau répertoire.

Voyons un exemple pratique pour créer des packages go.

Module d'initialisation de Golang

La première étape où les packages d'importation consiste à initialiser un nouveau module. Vous pouvez le faire en exécutant la commande:

aller mod init

Par exemple, dans le répertoire de l'espace de travail, nous pouvons créer un nouveau module comme:

GO Mod init Workspace

Une fois que vous avez exécuté le go mod init, il crée un coup.Fichier Mod qui garde une trace des modules que vous importez. Le fichier contient également des informations telles que le nom du module, la version Go, etc.

Pensez-y comme le package.Fichier JSON dans le nœud.

Faites attention à la dénomination de vos modules tels que vous en avez besoin lors de l'importation de vos packages. Un exemple de go.Le fichier mod est comme indiqué:

Espace de travail du module
aller 1.17

Puisque nous n'avons pas de packages externes, le fichier contient le nom du module et la version Go.

Golang Créer un package

Comme mentionné, pour créer un package dans votre projet GO, créez un nouveau répertoire et ajoutez les fichiers de code source sous ce package.

Par exemple, créons des fichiers source Go pour les packages Dir1, Dir2 et Dir3.

$ touch dir1 / dir1.aller
$ touch dir2 / dir12.aller
$ touch dir3 / dir3.aller

À la première ligne de chaque fichier, incluez l'espace de noms de package comme:

package dir1 // remplacer dir2 par le nom du package

Ensuite, ajoutons du code dans chacun de ces fichiers.

// dir1.aller
package dir1
funcsayhello () String
Renvoie "salut du package dir1"

// dir2.aller
package dir2
funcsayrunning () String
Retour "Je cours à partir du package Dir2"

// dir3.aller
package dir3
funcsaybye () String
Renvoyez "Au revoir du package dir3"

Les exemples ci-dessus sont simples. Ce ne sont que des fonctions qui renvoient une valeur de chaîne de chaque package.

Remarque: Pour exporter une variable ou une fonction à partir d'un package GO, assurez-vous de démarrer le nom de la fonction ou de la variable avec une lettre majuscule.

Encore une fois: ☝️☝️☝️☝️☝️

Golang Importer des packages locaux

La dernière étape consiste à importer vos packages locaux afin que vous puissiez utiliser le code dans chacun d'eux. Dans la racine de votre projet, alias, le répertoire de l'espace de travail, créez un principal.faire un dossier.

Ensuite, ajoutez les lignes suivantes pour importer vos packages locaux:

package principal
importer (
"FMT"
"Workspace / dir1"
"Workspace / dir2"
"Workspace / dir3"
)
funcmain ()
fmt.Println (dir1.Dis bonjour())
fmt.Println (dir2.Sayrunning ())
fmt.Println (dir3.Dis au revoir())

Dans l'exemple ci-dessus, nous ajoutons 3 clauses d'importation pour importer tous les packages de notre programme.

Une fois importé, nous pouvons utiliser le code exporté dans les packages.

Nous pouvons alors exécuter le code en main.Allez le fichier comme:

$ va run main.aller
Salut à partir de package dir1
Je cours à partir du package dir2
Au revoir du package dir3

Vous verrez la sortie comme exportée par les fonctions des packages.

Conclusion

Dans cet article, nous avons discuté de la façon dont vous pouvez exporter et importer du code à l'aide de packages Go. Les forfaits sont un moyen très pratique et propre d'organiser votre code et de conserver la lisibilité et l'entretien. Nous espérons que vous avez apprécié!