Guide de démarrage pour la programmation en Go

Introduction

Dans ce laboratoire, nous allons officiellement commencer à apprendre la programmation en Go. Nous aborderons les concepts de base et compléterons nous-mêmes un simple programme en Go.

Points de connaissance :

• Instruction de sortie standard
• Structure du code
• Exécution d'un programme
• Fonctions courantes dans le package fmt

Skills Graph

💡 Premier programme en Go

Commençons par créer notre premier programme en Go. Cliquez avec le bouton droit sur la barre latérale pour créer un nouveau fichier appelé helloWorld.go dans votre dossier de projet.

Remarque : Nous recommandons d'utiliser WebIDE (similaire à VS Code) pour une meilleure expérience. En savoir plus sur le guide d'utilisation de WebIDE ici.

Vous pouvez également créer un nouveau fichier en utilisant la commande touch :

touch helloWorld.go

Maintenant, ouvrez le fichier et écrivez le code suivant :

package main

import "fmt"

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

La première ligne, package main, indique que ce programme appartient au package main. La deuxième ligne, import "fmt", importe le package Go fmt, qui nous permet de formater les entrées et sorties de texte. La fonction main est le point de départ de l'exécution du programme, et à l'intérieur, fmt.Println("hello, world") affichera hello, world dans le terminal.

Pour exécuter le programme, ouvrez le terminal et entrez la commande suivante :

go run helloWorld.go

Si tout est configuré correctement, vous devriez voir la sortie suivante :

hello, world

Ceci est un simple programme "Hello World". Maintenant, expliquons le code et les opérations ligne par ligne.

Structure et syntaxe du programme

En Go, un package est l'unité de base de gestion du code. Chaque programme Go commence par une déclaration package. Dans ce cas, package main indique à Go que le code fait partie du programme principal qui sera exécuté.

L'instruction import "fmt" importe le package Go fmt, qui est utilisé pour les entrées et sorties. Go dispose d'une riche bibliothèque standard, qui nous permet d'effectuer de nombreuses tâches facilement. Le package fmt est utilisé pour formater la sortie de texte, comme nous l'avons vu à l'étape précédente.

Ensuite, nous définissons la fonction main :

func main() {
}

En Go, toutes les fonctions doivent commencer par func. Notez que l'accolade ouvrante { est placée à la fin de la ligne. C'est une convention de Go, et cela diffère d'autres langages de programmation qui pourraient placer l'accolade ouvrante sur une nouvelle ligne.

Si vous placez par erreur l'accolade ouvrante sur une nouvelle ligne comme ceci :

func main()
{
}

Vous obtiendrez une erreur de compilation :

$ go run helloWorld.go
### command-line-arguments
./helloWorld.go:7:1: syntax error: unexpected semicolon or newline before {

C'est parce que Go s'attend à ce que l'accolade ouvrante soit directement sur la même ligne.

L'instruction clé du programme est fmt.Println("hello, world"), qui appelle la fonction Println du package fmt pour afficher la chaîne de caractères "hello, world" dans la console. Cette fonction ajoute automatiquement un caractère de nouvelle ligne à la fin de la chaîne.

Exécution du programme

Go est un langage compilé, mais lorsque nous utilisons la commande go run, Go compile d'abord le code source, puis exécute l'exécutable résultant. Ainsi, la commande :

go run helloWorld.go

est équivalente à l'exécution de ces deux commandes :

## Compile le programme
go build helloWorld.go

## Exécute le programme compilé
./helloWorld

Pour tester un nouvel exemple, modifions le programme pour saluer d'autres Gophers. Créez un nouveau fichier appelé helloGopher.go et remplacez le code par :

Vous pouvez créer un nouveau fichier en utilisant la commande touch :

touch helloGopher.go

package main

import "fmt"

func main() {
 fmt.Println("hello Gopher.")
 fmt.Println("hello Gopher.")
 fmt.Println("hello Gopher.")
}

Maintenant, au lieu d'utiliser go run, nous allons utiliser go build pour compiler le programme, puis exécuter l'exécutable généré :

## Compile le programme
go build helloGopher.go

## Exécute l'exécutable compilé
./helloGopher

Cela produira la sortie suivante :

hello Gopher.
hello Gopher.
hello Gopher.

Fonctions courantes dans le package fmt

Dans l'Étape 1, nous avons utilisé la fonction Println() du package fmt pour afficher une sortie. Le package fmt est l'un des packages les plus couramment utilisés en Go et propose plusieurs fonctions pour formater la sortie.

Voici trois fonctions de sortie courantes :

1. fmt.Print() – Affiche le texte sans saut de ligne.
2. fmt.Println() – Affiche le texte avec un saut de ligne.
3. fmt.Printf() – Affiche du texte formaté.

Explorons ces fonctions plus en détail. Créez un nouveau fichier appelé fmt.go et entrez le code suivant :

package main

import "fmt"

func main() {
    // Standard output
    fmt.Print("hello")
    fmt.Print("world")

    // Println adds a newline character after the standard output
    fmt.Println()
    fmt.Println("labex")

    // Printf provides formatted output
    fmt.Printf("%s\n", "London")
}

Exécutez le programme en utilisant la commande go run :

go run fmt.go

Explication :

• fmt.Print("hello") et fmt.Print("world") affichent le texte sur la même ligne car Print n'ajoute pas de saut de ligne.
• fmt.Println() affiche un saut de ligne pour séparer les lignes.
• fmt.Printf("%s\n", "London") formate la sortie en utilisant le marqueur de position %s pour la chaîne de caractères "London".

Voici une rapide comparaison des fonctions :

Le package fmt propose également d'autres fonctions pour la lecture des entrées, la gestion des erreurs, etc., qui seront abordées dans des exercices ultérieurs.

Résumé

Dans ce laboratoire, nous avons écrit notre premier programme en Go, appris la structure des programmes Go et exploré les fonctions de base du package fmt pour l'affichage. Nous avons également pratiqué l'exécution de programmes Go et appris la différence entre Print, Println et Printf. Vous devriez maintenant avoir une compréhension de base de la syntaxe Go et de l'exécution des programmes.