Comprendre le GOPATH

Introduction

Cet article vous aidera à comprendre ce qu’est le GOPATH, comment il fonctionne et comment le configurer. C’est une étape cruciale pour la mise en place d’un environnement de développement Go, ainsi que pour comprendre comment Go trouve, installe et construit les fichiers sources. Dans cet article, nous utiliserons GOPATH pour faire référence au concept de la structure de dossiers dont nous allons parler. Nous utiliserons $GOPATH pour faire référence à la variable d’environnement que Go utilise pour trouver la structure de dossiers.

Un espace de travail Go est la façon dont Go gère nos fichiers sources, les binaires compilés et les objets mis en cache utilisés pour une compilation plus rapide plus tard. Il est typique, et également conseillé, de n’avoir qu’un seul espace de travail Go, bien qu’il soit possible d’avoir plusieurs espaces. Le GOPATH agit comme le dossier racine d’un espace de travail.

Définir la variable d’environnement $GOPATH

La variable d’environnement $GOPATH liste les endroits où Go doit chercher les espaces de travail Go.

Par défaut, Go suppose que notre emplacement GOPATH est à $HOME/go, où $HOME est le répertoire racine de notre compte utilisateur sur notre ordinateur. Nous pouvons changer cela en définissant la variable d’environnement $GOPATH. Pour une étude plus approfondie, suivez ce tutoriel sur la lecture et le paramétrage des variables d’environnement sous Linux.

Pour plus d’informations sur le paramétrage de la variable $GOPATH, consultez la documentation de Go.

De plus, cette série marche à travers l’installation de Go et la configuration d’un environnement de développement Go.

$GOPATH n’est pas $GOROOT

Le $GOROOT est l’endroit où vit le code, le compilateur et l’outillage de Go – ce n’est pas notre code source. Le $GOROOT est généralement quelque chose comme /usr/local/go. Notre $GOPATH est généralement quelque chose comme $HOME/go.

Bien que nous n’ayons plus besoin de configurer spécifiquement la variable $GOROOT, elle est toujours référencée dans les anciens matériaux.

Maintenant, discutons de la structure de l’espace de travail de Go.

Anatomie de l’espace de travail de Go

À l’intérieur d’un espace de travail de Go, ou GOPATH, il y a trois répertoires : bin, pkg, et src. Chacun de ces répertoires a une signification particulière pour la chaîne d’outils Go.

.├── bin├── pkg└── src └── github.com/foo/bar └── bar.go

Regardons chacun de ces répertoires.

Le répertoire $GOPATH/bin est l’endroit où Go place les binaires que go install compile. Notre système d’exploitation utilise la variable d’environnement $PATH pour trouver les applications binaires qui peuvent s’exécuter sans chemin complet. Il est recommandé d’ajouter ce répertoire à notre variable globale $PATH.

Par exemple, si nous n’ajoutons pas $GOPATH/bin à $PATH pour exécuter un programme à partir de là, nous devrions exécuter :

$GOPATH/bin/myapp

Lorsque $GOPATH/bin est ajouté à $PATH, nous pouvons faire le même appel comme tel :

myapp

Le répertoire $GOPATH/pkg est l’endroit où Go stocke les fichiers objets pré-compilés pour accélérer la compilation ultérieure des programmes. Typiquement, la plupart des développeurs n’auront pas besoin d’accéder à ce répertoire. Si vous rencontrez des problèmes de compilation, vous pouvez supprimer ce répertoire en toute sécurité et Go le reconstruira ensuite.

Le répertoire src est l’endroit où tous nos fichiers .go, ou code source, doivent être situés. Il ne faut pas le confondre avec le code source que l’outil Go utilise, qui se trouve dans le $GOROOT. Au fur et à mesure que nous écrivons des applications, des paquets et des bibliothèques Go, nous placerons ces fichiers sous $GOPATH/src/path/to/code.

Que sont les paquets ?

Le code Go est organisé en paquets. Un paquet représente tous les fichiers d’un seul répertoire sur le disque. Un répertoire ne peut contenir que certains fichiers du même paquetage. Les paquets sont stockés, avec tous les fichiers sources Go écrits par l’utilisateur, sous le répertoire $GOPATH/src. Nous pouvons comprendre la résolution de paquet en important différents paquets.

Si notre code vit à $GOPATH/src/blue/red, alors son nom de paquet devrait être red.

L’instruction d’importation pour le paquet red serait:

import "blue/red"

Les paquets qui vivent dans des dépôts de code source, comme GitHub et BitBucket, ont l’emplacement complet du dépôt comme partie de leur chemin d’importation.

Par exemple, nous importerions le code source à https://github.com/gobuffalo/buffalo en utilisant le chemin d’importation suivant:

import "github.com/gobuffalo/buffalo"

Par conséquent, ce code source se trouverait à l’emplacement suivant sur le disque:

$GOPATH/src/github.com/gobuffalo/buffalo

Conclusion

Dans cet article, nous avons discuté du GOPATH comme un ensemble de dossiers dans lesquels Go s’attend à ce que notre code source vive, ainsi que ce que sont ces dossiers et ce qu’ils contiennent. Nous avons discuté de la façon de changer cet emplacement, de la valeur par défaut de $HOME/go au choix de l’utilisateur, en définissant la variable d’environnement $GOPATH. Enfin, nous avons abordé la façon dont Go recherche les paquets dans cette structure de dossiers.

Introduits dans Go 1.11, les modules Go visent à remplacer les espaces de travail Go et les GOPATH. Bien qu’il soit recommandé de commencer à utiliser les modules, certains environnements, tels que les environnements d’entreprise, peuvent ne pas être prêts à utiliser les modules.

Le GOPATH est l’un des aspects les plus délicats de la configuration de Go, mais une fois qu’il est configuré, nous pouvons généralement l’oublier.