Mon premier programme Go (`go run`, `go build`)

Le rituel initiatique : Ecrire "Hello, World!" en Go

Après avoir installé Go avec succès, il est temps de passer à l'action et d'écrire votre tout premier programme. Traditionnellement, ce premier pas consiste à afficher le message "Hello, World!" à l'écran. C'est un exercice simple mais fondamental qui permet de vérifier que votre environnement fonctionne et de vous familiariser avec la structure de base d'un programme Go.

Ouvrez votre éditeur de texte ou votre environnement de développement intégré (IDE) préféré et créez un nouveau fichier. Nommez-le `hello.go`. L'extension `.go` est la convention standard pour les fichiers de code source Go. Dans ce fichier, saisissez le code suivant :

package main

import "fmt"

func main() {
	fmt.Println("Hello, World!")
}

Analysons brièvement ce code. La ligne `package main` déclare que ce fichier appartient au paquet `main`, ce qui indique au compilateur Go qu'il doit produire un fichier exécutable (plutôt qu'une bibliothèque). La ligne `import "fmt"` importe le paquet `fmt` (format), qui fait partie de la bibliothèque standard de Go et fournit des fonctions pour l'entrée/sortie formatée, comme l'impression à la console. Enfin, `func main()` définit la fonction principale. C'est le point d'entrée de tout programme exécutable en Go ; l'exécution commence ici. A l'intérieur de `main`, l'instruction `fmt.Println("Hello, World!")` appelle la fonction `Println` du paquet `fmt` pour afficher la chaîne de caractères "Hello, World!" suivie d'un retour à la ligne sur la sortie standard (généralement votre terminal).

Exécution instantanée avec `go run`

Maintenant que vous avez votre fichier `hello.go`, vous pouvez l'exécuter. Go fournit plusieurs commandes pour travailler avec votre code. La plus simple pour une exécution rapide est `go run`. Cette commande compile et exécute un ou plusieurs fichiers source Go sans créer de fichier exécutable permanent sur votre disque.

Ouvrez votre terminal ou invite de commandes, naviguez jusqu'au répertoire où vous avez enregistré `hello.go`, et tapez la commande suivante :

go run hello.go

Si tout s'est bien passé, vous devriez voir immédiatement le message s'afficher dans votre terminal :

Hello, World!

`go run` est extrêmement pratique pendant le développement. Il vous permet de tester rapidement vos modifications sans passer par une étape de compilation explicite distincte. En coulisses, `go run` compile votre code dans un emplacement temporaire, l'exécute, puis nettoie les fichiers compilés.

Créer un exécutable autonome avec `go build`

Si votre objectif est de créer un programme que vous pouvez distribuer ou exécuter ultérieurement sans avoir besoin des fichiers source, vous utiliserez la commande `go build`. Cette commande compile les fichiers Go spécifiés (et leurs dépendances) pour créer un fichier exécutable binaire.

Toujours dans le même répertoire que `hello.go`, exécutez la commande suivante dans votre terminal :

go build hello.go

Contrairement à `go run`, `go build` ne produit aucune sortie à l'écran s'il réussit. Cependant, si vous listez les fichiers de votre répertoire (avec `ls` sur Linux/macOS ou `dir` sur Windows), vous remarquerez un nouveau fichier. Son nom sera `hello` sur les systèmes Unix (Linux, macOS) ou `hello.exe` sur Windows. Ce fichier est votre programme compilé, un exécutable autonome.

Pour exécuter ce programme compilé, tapez son nom dans le terminal. Sur Linux ou macOS, vous devrez probablement préfixer le nom par `./` pour indiquer au shell de chercher l'exécutable dans le répertoire courant :

./hello

Sur Windows, vous pouvez généralement taper simplement le nom :

.\hello.exe
# ou
hello.exe

Dans les deux cas, le résultat sera le même que celui obtenu avec `go run` : l'affichage de `Hello, World!`. La différence clé est que vous exécutez maintenant un fichier binaire autonome qui ne dépend plus du fichier source `hello.go`.

Comprendre le flux : `run` vs `build`

Vous avez maintenant découvert les deux commandes fondamentales pour interagir avec votre code Go : `go run` et `go build`. Il est important de saisir leur distinction et quand utiliser l'une ou l'autre.

Utilisez `go run` pour un retour rapide pendant le développement et le test. C'est l'équivalent de "compiler et lancer immédiatement". Il est parfait pour les petits scripts ou pour vérifier rapidement le comportement d'un morceau de code.

Utilisez `go build` lorsque vous souhaitez créer une version finale de votre application, un exécutable que vous pouvez déployer sur un serveur, partager avec d'autres utilisateurs, ou simplement exécuter de manière répétée sans recompiler à chaque fois. Le fichier binaire résultant est optimisé et contient tout le nécessaire pour fonctionner (à l'exception des dépendances externes au système, comme les bibliothèques C si vous utilisez Cgo, ce qui n'est pas le cas ici).

Maîtriser ces deux commandes constitue la première étape essentielle dans le flux de travail de tout développeur Go. Vous êtes désormais équipé pour écrire, tester et compiler vos propres programmes Go. La prochaine étape consistera à explorer les éléments fondamentaux de la syntaxe du langage, comme les variables et les types de données.