Installation et premiers pas

a. Télécharger Go

Le package d’installation de Go pour Windows est disponible sur le site officiel de Go. Il est conseillé de télécharger la version la plus récente afin de profiter des dernières fonctionnalités et corrections de bugs.

b. Installer Go

Une fois le fichier .msi téléchargé, l’installation peut commencer en suivant ces étapes :

Une interface graphique vous guidera tout au long de l’installation, en proposant les options suivantes :

c. Vérifier l’installation

Après l’installation, il est essentiel de s’assurer que Go est correctement installé et accessible depuis le terminal.

go version 

Cette commande...

a. GOROOT : le répertoire d’installation de Go

La variable GOROOT désigne le chemin où Go est installé sur le système. Ce répertoire contient l’exécutable go, les bibliothèques standard et d’autres fichiers nécessaires à l’exécution de Go.

Vérifier le GOROOT

Pour vérifier le chemin actuel de GOROOT, on peut exécuter la commande suivante :

go env GOROOT 

Une sortie typique pourrait ressembler à ceci :

/usr/local/go 

Si GOROOT est incorrect ou non défini, il peut être nécessaire de le configurer manuellement en ajoutant la ligne suivante au fichier ~/.bashrc ou ~/.zshrc :

export GOROOT=/usr/local/go  
export PATH=$GOROOT/bin:$PATH 

b. GOPATH : l’espace de travail Go

Contrairement à GOROOT, la variable GOPATH désigne l’espace de travail personnel d’un développeur. C’est ici que seront stockés les projets, les dépendances téléchargées et les binaires compilés.

Organisation du GOPATH

Un espace de travail Go (GOPATH) suit une structure standard :

GOPATH/  
|-- bin/        # Contient les binaires des programmes installés  
|-- pkg/        # Contient les fichiers compilés  
|-- src/        # Contient le code source des projets   

Vérifier et configurer GOPATH

On peut consulter la valeur actuelle de GOPATH avec la commande :

go env GOPATH 

Si la variable GOPATH n’est pas définie, il est possible de la configurer en ajoutant la ligne suivante au fichier de configuration du shell :

export GOPATH=$HOME/go  
export PATH=$GOPATH/bin:$PATH 

a. Structure d’un programme Go

Un programme Go est structuré autour d’un fichier principal contenant le point d’entrée main(). Il peut importer des packages pour étendre ses fonctionnalités.

mkdir -p $HOME/go/src/hello_world  
cd $HOME/go/src/hello_world 

package main  
 
import (   
    "fmt"   
    "time"  
)    
  
// Fonction principale du programme  
func main() {   
    // Affichage d'un message de bienvenue   
    fmt.Println("Bienvenue dans votre premier programme Go !")    
 
    // Déclaration de variables   
    currentTime := time.Now() // Récupère l'heure actuelle   
    userName := "Utilisateur"       
   
 
    // Affichage d'informations complémentaires 
     fmt.Printf("Bonjour %s, nous sommes le %s.\n", userName, 
currentTime.Format("02/01/2006 15:04:05"))      
    // Appel d'une fonction personnalisée  
    displayMessage("Ce programme fonctionne correctement.")  }  
  
// Fonction pour afficher...

a. Pourquoi utiliser go mod ?

Avant l’introduction des modules Go, la gestion des dépendances reposait sur le GOPATH, ce qui posait plusieurs limitations, notamment l’impossibilité d’utiliser plusieurs versions d’un même package dans différents projets. Avec go mod, chaque projet peut gérer ses propres dépendances de manière indépendante.

b. Création d’un projet avec go mod

Pour initialiser un projet avec go mod, suivez ces étapes :

mkdir my_project && cd my_project 

go mod init github.com/username/my_project 

module github.com/username/my_project  
 
go 1.20 

Ce fichier définit le module et la version de Go utilisée.

c. Ajouter des dépendances

Lorsqu’un projet utilise des bibliothèques externes, celles-ci doivent être ajoutées au module.

Pour ajouter une dépendance :

go get github.com/gin-gonic/gin 

Cette commande télécharge le package et met à jour le fichier go.mod ainsi que go.sum.

Le fichier go.sum assure l’intégrité des versions des dépendances.

d. Mettre à jour et gérer les dépendances

go get -u github.com/gin-gonic/gin 

a. Usage fondamental dans un projet local

Lorsque l’on travaille dans un répertoire contenant des fichiers .go, notamment un point d’entrée tel qu’un fichier main.go défini avec un package main, il devient possible de générer un exécutable local. Imaginons un fichier principal structuré de la manière suivante :

package main  
 
import "fmt" 
  
func main() {   
    fmt.Println("Démarrage de l'application...") // Affiche un 
message de bienvenue  
} 

En se plaçant dans le dossier contenant ce fichier, on peut exécuter la commande :

go build 

Cette instruction analyse l’ensemble du package courant. Si celui-ci inclut une fonction main, le compilateur générera un fichier binaire. Ce dernier prendra automatiquement le nom du dossier courant.

b. Compilation ciblée d’un fichier source

Il est possible de demander explicitement la compilation d’un fichier unique, ce qui peut être utile pour tester des scripts isolés ou des prototypes :

go build app_entry.go 

Si le fichier contient une fonction main dans un package main, un exécutable sera produit. Ce binaire portera alors le nom app_entry (ou app_entry.exe sur Windows).

Une fois le fichier généré...