Exercice - Hello World

  • 6 minutes

Dans cette section, vous allez écrire votre premier programme Go pour afficher un message à l’écran. Cet exercice est un moyen classique de démarrer l’utilisation d’un langage de programmation. Vous en apprendrez davantage sur l’interface de ligne de commande (CLI) Go et découvrirez comment générer et exécuter une application Go.

Configurer l’environnement IDE pour l’ouvrir à partir de l’interface CLI

Vous pouvez ouvrir l’environnement IDE de Visual Studio Code à partir de l’invite de l’interface CLI et commencer à modifier les fichiers dans votre espace de travail actuel. Cette fonctionnalité IDE est implémentée à l’aide de la variable d’environnement système $PATH (ou $Path). Quand la fonctionnalité est activée, vous pouvez utiliser la commande code . à partir de l’interface CLI pour ouvrir l’environnement IDE et modifier les fichiers de votre répertoire actuel.

Certaines installations de Visual Studio Code ajoutent la prise en charge de l’interface CLI à la variable $PATH par défaut. Vous pouvez voir cette option pendant le processus d’installation. Si vous avez déjà configuré ce paramètre, vous êtes prêt à commencer. Dans le cas contraire, vous devrez peut-être effectuer les étapes suivantes pour utiliser cette fonctionnalité.

Linux ou macOS

Procédez comme suit pour inscrire l’interface CLI de Visual Studio Code dans votre variable d’environnement $PATH :

  1. Ouvrez Visual Studio Code.

  2. Sous Affichage, sélectionnez Palette de commandes.

  3. Dans la zone de recherche, entrez commande shell. Les résultats sont filtrés pendant la saisie.

  4. Choisissez la commande Commande Shell : installer la commande 'code' dans PATH.

  5. Fermez l’invite de commande ou de terminal ouverte.

    Important

    Si une invite est restée ouverte après l’exercice précédent, fermez l’invite et ouvrez-en une nouvelle. Cette étape est nécessaire pour que la nouvelle valeur $PATH prenne effet.

  6. Fermez Visual Studio Code.

Windows

Procédez comme suit pour ajouter l’emplacement de l’interface CLI de Visual Studio Code à votre variable d’environnement système $Path :

Notes

Si vous êtes familiarisé avec les variables d’environnement et savez comment ajouter un nouvel emplacement à votre variable système $Path, vous pouvez utiliser la méthode qui vous convient le mieux. La procédure suivante est un peu longue, mais il s’agit d’une méthode vérifiée pour garantir la mise à jour correcte de la variable.

  1. Ouvrez le Panneau de configuration de Windows.

  2. Sélectionnez Système, puis Paramètres système avancés.

  3. Dans la boîte de dialogue Propriétés système, sous Avancé, sélectionnez Variables d’environnement. La boîte de dialogue Modifier les variables d’environnement s’ouvre.

    La boîte de dialogue Modifier les variables d’environnement affiche deux listes :

    • Variables utilisateur pour <user-name> : définitions de variables locales pour l’utilisateur spécifique.
    • Variables système : définitions de variables système pour tous les utilisateurs.

    Dans cette procédure, nous travaillons avec les variables système.

  4. Dans la boîte de dialogue Variables d’environnement, dans la zone de liste Variables système, faites défiler la liste pour rechercher la variable Path.

  5. Sélectionnez la variable Path pour mettre la ligne en surbrillance. Sélectionnez Modifier. La boîte de dialogue Modifier les variables d’environnement s’ouvre. La boîte de dialogue répertorie tous les emplacements de dossier définis dans la variable.

  6. Dans la boîte de dialogue Modifier les variables d’environnement, sélectionnez Nouveau. Une ligne vide s’ouvre à la fin de la liste.

  7. Dans la ligne vide, entrez l’emplacement du fichier exécutable de l’interface CLI de Visual Studio Code. Remplacez <user-name> par votre ID d’utilisateur.

    C:\Users\<user-name>\AppData\Local\Programs\Microsoft VS Code\bin

  8. Sélectionnez OK pour fermer chaque boîte de dialogue.

  9. Fermez la boîte de dialogue Propriétés système et le Panneau de configuration de Windows.

Étape 1 : ouvrir votre espace de travail Go et l’environnement IDE

Une fois que vous avez confirmé que Visual Studio Code est prêt à être utilisé à partir de l’interface CLI, vous pouvez ouvrir votre espace de travail Go.

  1. Ouvrez une nouvelle invite de commande ou de terminal.

  2. Ouvrez le répertoire de votre espace de travail Go en exécutant la commande suivante :

    cd $GOPATH/src

    cd %GOPATH%/src

  3. Utilisez la commande suivante pour ouvrir Visual Studio Code à partir de votre espace de travail :

    code .

Visual Studio Code démarre. La vue Explorateur s’affiche à gauche et une page d’accueil s’affiche à droite.

Dans la vue Explorateur, la section SRC de votre projet Go doit être ouverte (développée). Cette section correspond au dossier /src de votre projet. Il est vide actuellement mais nous allons ajouter du contenu à l’étape suivante.

Étape 2 : créer un dossier et un fichier Go

Ajoutons un dossier et un fichier à votre projet Go. Visual Studio Code permet de créer de nouveaux éléments de plusieurs façons :

  • Actions dans le menu de la barre d’outils :
    • Sélectionnez Fichier>Ouvrir le dossier, puis créez un Nouveau dossier.
    • Sélectionnez Fichier>Nouveau fichier, puis commencez un nouveau fichier.
  • Liens sur la page d’accueil, qui sont similaires aux actions du menu de la barre d’outils.
  • Icônes dans la vue Explorateur, à droite de la section SRC :
    • Sélectionnez l’icône Nouveau dossier. Dans la zone de texte, tapez le nom du dossier, puis appuyez sur Entrée.
    • Sélectionnez l’icône Nouveau fichier. Dans la zone de texte, tapez le nom de dossier, puis appuyez sur Entrée.

Procédez comme suit dans Visual Studio Code. Pour créer le nouveau fichier et le nouveau dossier, utilisez le processus qui vous convient le mieux.

  1. Créez un nouveau dossier nommé helloworld.

  2. Créez un nouveau fichier nommé main.go pour le code de votre application.

  3. Développez la vue Explorateur>SRC pour afficher l’arborescence de la structure des dossiers. Elle doit ressembler à cet exemple :

    SRC/
        helloworld/
            main.go

Installer les outils d’extension Go

Si main.go est le premier fichier Go que vous ouvrez dans Visual Studio Code, vous pouvez être invité à installer d’autres outils pour l’extension Go. Quand vous y êtes invité, sélectionnez Installer. Un terminal s’ouvre en bas de l’IDE pour afficher la sortie du processus. Vous devriez voir un résultat similaire à cet exemple :

Environnement d’outils : GOPATH=C:\Projects\Go
Installation de 5 outils sur C:\Projects\Go\bin en mode module.
Installation de github.com/uudashr/gopkgs/v2/cmd/gopkgs (C:\Projects\Go\bin\gopkgs.exe) RÉUSSIE

Pendant le processus d’installation, vérifiez la barre d’état dans Visual Studio Code. Si un message s’affiche en bas à droite, par exemple « Tous les outils ne sont pas installés », sélectionnez le message. Dans le menu contextuel, sélectionnez Installer.

Quand le processus d’installation a réussi, la sortie du terminal affiche un résumé :

Tous les outils ont bien été installés. Vous êtes prêt, Go ! :).

Étape 3 : ajouter du code à votre fichier Go

Ajoutons maintenant du code à votre fichier Go.

  1. Dans le fichier main.go, ajoutez le code suivant :

    package main

import "fmt"

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

  2. Enregistrez le fichier .

Ne vous préoccupez pas de la mise en forme du code, comme des tabulations ou des espaces. Visual Studio Code met en forme le code automatiquement chaque fois que vous enregistrez le fichier.

Étape 4 : exécuter votre programme Go

Vous pouvez exécuter le programme Go dans une invite de commande ou de terminal, ou bien dans un terminal qui s’exécute dans Visual Studio Code.

Vous pouvez utiliser une invite existante ou en ouvrir une nouvelle. Si vous ouvrez une nouvelle invite, pensez à remplacer l’emplacement du répertoire par votre espace de travail Go. Veillez également à exécuter le programme à partir du dossier qui contient votre fichier Go : $GOPATH/src/helloworld.

Ouvrir un terminal dans Visual Studio Code

Si vous souhaitez exécuter le programme à partir de Visual Studio Code, plutôt qu’une commande autonome ou une invite de terminal, procédez comme suit :

  1. Dans Visual Studio Code, sélectionnez Terminal, puis sélectionnez Nouveau terminal.

  2. Dans la zone de liste déroulante en haut à droite du terminal, sélectionnez Nouvelle invite de commandes.

  3. Dans le terminal, exécutez la commande suivante pour modifier l’emplacement du répertoire de votre espace de travail Go et le dossier qui contient votre fichier Go :

    cd $GOPATH/src/helloworld

    cd %GOPATH%/src/helloworld

Exécuter votre application Go

Pour exécuter votre application Go, utilisez la commande suivante dans votre terminal ou invite :

go run main.go

Vous devez normalement voir la sortie suivante :

Hello World!

La commande go run effectue deux opérations. Elle compile l’application, puis une fois la compilation réussie, elle exécute l’application.

Générer un fichier exécutable

Pour générer un fichier exécutable pour votre programme, utilisez la commande suivante :

go build main.go

Quand la commande go build est terminée, elle génère une application exécutable que vous pouvez exécuter à tout moment sans traitement supplémentaire. La commande produit uniquement un fichier exécutable. Elle n’exécute pas le programme comme la commande go run.

Passer en revue le contenu de /src

Voici à quoi votre projet doit ressembler à présent dans la vue Explorateur>SRC :

SRC/
    helloworld/
        main
        main.go

Dans la vue Explorateur, le nom du fichier sans l’extension est le fichier exécutable que vous pouvez utiliser pour exécuter votre programme. (Sur Windows, ce fichier a en fait l’extension .exe). Quand vous développez, vous utilisez la commande go run. Pour générer les fichiers binaires pour votre application, vous utilisez la commande go build et vous déployez le fichier exécutable binaire dans un environnement approprié.

Qu’est-ce que vous venez d’écrire en Go ?

Vous avez créé votre première application Go et vous vous êtes assuré qu’elle est compilée et exécutée. Examinons le code ligne par ligne.

Nous allons commencer par la première instruction de votre fichier Go :

package main

L’instruction package main indique à Go que l’application que nous créons est un programme exécutable (un fichier qui peut s’exécuter). Notre application « Hello World! » fait partie du package main. Un package est un ensemble de fichiers de code source communs. Chaque application exécutable a cette première ligne, même si le nom du projet ou du fichier est différent.

Nous examinerons plus en détail ces concepts dans le module suivant. Pour le moment, nous devons savoir que chaque programme exécutable doit faire partie du package main.

Défi : modifier le nom du package

Pouvez-vous confirmer l’importance du package main ?

  1. Dans votre fichier Go, modifiez le nom du package à la première ligne.
  2. Enregistrez le fichier, puis exécutez à nouveau votre programme dans le terminal.

  Ce qu’il se passe ? Voyez-vous « Hello World! » ? Un fichier exécutable binaire est-il produit ?

 

Afficher la réponse
"Hello World!" n’est pas affiché. Un exécutable binaire n’est pas produit. Vous devriez voir une erreur : `go run: cannot run non-main package`. Pourquoi ? Chaque programme exécutable doit faire partie du package `main`.

Voici la ligne suivante dans votre fichier Go :

import "fmt"

L’instruction import permet à votre programme d’accéder à un autre code dans différents packages. Dans ce cas, fmt est un package de bibliothèque standard. Pour en savoir plus sur le package fmt, consultez le site officiel de la documentation Go.

Vous avez besoin de cette instruction import car vous utilisez une fonction de ce package pour afficher un message à l’écran ultérieurement dans le programme. Vous pouvez inclure autant d’instructions import que vous le voulez ou que nécessaire dans votre programme. Go est cependant idiomatique à cet égard. Si vous importez un package, mais que vous n’utilisez pas une fonction correspondante à partir du package, l’application n’est pas compilée. Une fonctionnalité intéressante de Visual Studio Code est qu’il supprime automatiquement les importations inutilisées dans un programme quand vous enregistrez le fichier.

Visual Studio Code a-t-il supprimé l’importation quand vous avez enregistré le fichier ? Essayez d’éditer le fichier sans Visual Studio Code, puis essayez d’exécuter l’application. Quelle sortie voyez-vous maintenant ?

Défi : ajouter une autre importation

Pouvez-vous vérifier ce que vous avez appris sur les importations inutilisées ?

  1. Restaurez votre fichier Go dans le code d’origine.
  2. Ajoutez une autre instruction import comme math ou io.
  3. Enregistrez le fichier, puis exécutez à nouveau votre programme dans le terminal.

  Ce qu’il se passe ? Est-ce que Visual Studio Code supprime l’importation inutilisée ? Si c’est le cas, quand est-elle supprimée ?

  1. Modifiez à nouveau votre fichier Go, mais n’utilisez pas Visual Studio Code.
  2. Enregistrez le fichier et exécutez votre programme dans une nouvelle invite.

  Ce qu’il se passe ? Quelle sortie voyez-vous maintenant ?

 

Afficher la réponse
Si vous modifiez votre fichier Go dans l'IDE, lorsque vous enregistrez votre fichier, Visual Studio Code détecte les paquets non utilisés et supprime les déclarations `import` correspondantes. Lorsque vous modifiez votre fichier Go en dehors de Visual Studio Code, le code échoue. Vous devriez voir une erreur, telle que `# command-line-arguments .\main.go:5:2: imported and not used: "math"`.

Examinons le bloc de code dans votre fichier Go :

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

L’instruction func est un mot réservé qui est utilisé pour déclarer une fonction. La première fonction est nommée « main » car il s’agit du point de départ de notre programme. Vous ne pouvez avoir qu’une seule fonction main() dans package main (celle que vous avez définie à la première ligne). Dans la fonction main(), vous avez appelé la fonction Println à partir du package fmt. Vous avez envoyé un message texte que vous souhaitiez voir à l’écran.

Il y a davantage de choses à expliquer sur les fonctions et nous le ferons dans le module suivant.