GOPATH et Modules

Introduction

Dans cet atelier, nous allons explorer deux approches différentes pour la gestion des dépendances en Go : le GOPATH et les Modules Go. Il s'agit de concepts fondamentaux pour organiser et administrer efficacement vos projets Go.

Points de connaissances :

GOPATH
GOROOT
Modules Go (Go Modules)

Préparation

Dans cette étape, nous allons préparer l'environnement de travail en décompressant l'archive fournie.

Tout d'abord, ouvrez votre terminal et accédez au répertoire du projet en saisissant la commande suivante :
```
cd ~/project
```
Décompressez le fichier helloWorld.tar.gz dans le répertoire courant :
```
tar -xzf helloWorld.tar.gz
```
Une fois l'extraction terminée, vérifiez si le dossier helloWorld a bien été créé :
```
ls helloWorld
```

Cette commande affichera le contenu du répertoire helloWorld s'il a été décompressé correctement.

Fonctionnement de base du GOPATH

Avant la version 1.11 de Go, le langage utilisait un espace de travail spécifique nommé GOPATH pour stocker l'intégralité du code source. Dans cette étape, nous allons comprendre comment fonctionne le GOPATH.

GOROOT correspond au répertoire où Go est installé, incluant ses outils et les paquets de la bibliothèque standard.
GOPATH est l'endroit où réside votre code Go personnel. Il contient généralement trois répertoires :
- src : Stocke le code source de vos projets.
- bin : Stocke les fichiers exécutables compilés.
- pkg : Stocke les paquets compilés qui ne sont pas des exécutables.

Pour vérifier les valeurs actuelles de GOPATH et GOROOT, exécutez les commandes suivantes :

## Vérifier le répertoire GOPATH
go env | grep GOPATH

## Vérifier le répertoire GOROOT
go env | grep GOROOT

Ces commandes afficheront les chemins configurés pour GOPATH et GOROOT sur votre machine.

Initialisation d'un module

Les Modules Go, introduits avec Go 1.11 et activés par défaut depuis Go 1.13, visent à résoudre deux problèmes majeurs :

Dépendance excessive au GOPATH : Avant les modules, le code devait impérativement être stocké dans le répertoire GOPATH/src. Avec les Modules Go, vous pouvez placer votre code n'importe où sur votre système.
Gestion des versions : Les Modules Go permettent aux projets de gérer et de suivre les dépendances avec des versions spécifiques, facilitant ainsi l'utilisation de différentes versions d'un même paquet.

Dans cette étape, nous allons initialiser un module Go pour un nouveau projet.

Créez un nouveau répertoire pour le projet nommé testHello :
```
cd ~/project
mkdir testHello
```
Accédez au répertoire testHello :
```
cd testHello
```

Initialisez le module Go pour ce projet :

go mod init testHello

La sortie devrait être :

go: creating new go.mod: module testHello

Créez un nouveau fichier Go nommé testHello.go à l'intérieur du dossier testHello avec le contenu suivant :
```
touch testHello.go
```
```
package main

import "fmt"

func main() {
    fmt.Println("hello, world")
}
```

Nous avons maintenant initialisé le projet testHello en utilisant les modules Go et y avons ajouté un programme simple.

Importer d'autres paquets avec les modules

Dans cette étape, nous allons démontrer comment importer et utiliser d'autres modules locaux dans votre projet Go.

Le paquet helloWorld situé dans le dossier helloWorld a été initialisé avec les modules Go. De même, le paquet test, qui utilise également les modules, importe la fonction Say du paquet helloWorld.

Pour explorer cela, suivez ces instructions :

Examinez d'abord la structure des répertoires helloWorld et test :

helloWorld
├── go.mod
└── helloWorld.go
test
├── go.mod
└── test.go

Ensuite, ouvrez le fichier test/go.mod. Vous devriez y voir le contenu suivant :

module test

go 1.15

require "helloWorld" v0.0.1
replace "helloWorld" => "../helloWorld"

La directive replace indique à Go d'utiliser le chemin local ../helloWorld au lieu de chercher le paquet sur un dépôt distant. La directive require spécifie que le paquet test dépend de la version v0.0.1 du paquet helloWorld.

Paramètre	Description
module	Spécifie le nom du paquet actuel
require	Spécifie les dépendances nécessaires
replace	Remplace une dépendance par une autre (souvent locale)
exclude	Exclut certaines versions de dépendances

Pour exécuter le fichier test.go dans le paquet test :

cd ~/project/test
go run test.go

Le résultat affiché devrait être :

hello, world

Importer des paquets distants

En Go, vous pouvez facilement importer des paquets hébergés à distance. Utilisons un paquet distant provenant de GitHub pour illustrer cela.

Créez un répertoire remoteModule :

cd ~/project
mkdir remoteModule
cd remoteModule

Initialisez le module Go :
```
go mod init remoteModule
```
Créez un fichier remote.go dans le dossier remoteModule avec le contenu suivant :
```
touch remote.go
```
```
package main

import (
    "github.com/labex-labs/golang-dev-code/chap02module"
)

func main() {
    chap02module.StringTobase64("miiy")
}
```
Ce programme importe le paquet chap02module depuis GitHub et utilise sa fonction StringTobase64.
Exécutez le fichier remote.go à l'aide des commandes suivantes :
```
go get github.com/labex-labs/golang-dev-code/chap02module
go run -v remote.go
```
Astuce : Les utilisateurs gratuits n'ont pas accès à Internet, vous ne pourrez donc pas exécuter cette commande. Passez au plan Pro pour obtenir un accès complet à Internet.

La commande go get téléchargera le paquet chap02module depuis GitHub et le placera dans votre cache de modules. Une fois cette opération terminée, la commande go run exécutera votre programme.

Mini Test

Dans cette étape, nous allons tester vos connaissances en créant un nouveau fichier qui utilise la fonction Hello du module distant.

Créez un dossier remoteModule2 :

cd ~/project
mkdir remoteModule2
cd remoteModule2

Initialisez le module Go :
```
go mod init remoteModule2
```

Créez un fichier remote2.go avec le contenu suivant :

touch remote2.go

package main

import (
    "github.com/labex-labs/golang-dev-code/chap02module"
)

func main() {
    chap02module.Hello()
}

Exécutez le programme :

go get github.com/labex-labs/golang-dev-code/chap02module
go run remote2.go

Le résultat devrait être :

hello

Résumé

Dans cet atelier, nous avons appris les points suivants :

La signification et le rôle des répertoires GOPATH et GOROOT.
Les bases des Modules Go pour la gestion des dépendances.
Comment initialiser et utiliser les modules Go dans un projet.
Comment importer et utiliser des paquets Go locaux et distants.

À l'issue de cet atelier, vous devriez être à l'aise avec l'utilisation des modules Go pour gérer les dépendances de vos projets.