TOC

Comment installer Go et configurer un environnement de programmation local sur macOS

introduction

Go est un langage de programmation né de la frustration de Google. Les développeurs devaient continuellement choisir un langage qui s'exécutait efficacement mais mettait beaucoup de temps à compiler, ou un langage facile à programmer, mais dont la production était inefficace. Go a été conçu pour avoir les trois disponibles en même temps: compilation rapide, facilité de programmation et exécution efficace en production.

Alors que Go est un langage de programmation polyvalent qui peut être utilisé pour de nombreux projets de programmation, il est particulièrement bien adapté aux programmes réseau / distribués, et a acquis une réputation de «langage du cloud». Il vise principalement à aider les programmeurs modernes à plus avec un ensemble complet d’outils, supprimant les débats sur le formatage en faisant du format une partie de la spécification de la langue, et facilitant le déploiement en compilant en un seul fichier binaire. Go est facile à apprendre, avec un très petit ensemble de mots-clés, ce qui en fait un excellent choix pour les développeurs débutants et expérimentés.

Ce didacticiel vous guidera à travers l’installation de Go sur votre ordinateur macOS local et la configuration d’un espace de travail de programmation via la ligne de commande.

Conditions préalables

Vous aurez besoin d’un ordinateur macOS doté d’un accès administratif connecté à Internet.

[[step-1 -—- opening-terminal]] == Étape 1 - Ouverture du terminal

Nous effectuerons la majeure partie de notre installation et configuration sur la ligne de commande, ce qui constitue un moyen non graphique d'interagir avec votre ordinateur. Autrement dit, au lieu de cliquer sur des boutons, vous saisissez du texte et recevez également les commentaires de votre ordinateur. La ligne de commande, également appelée shell, peut vous aider à modifier et à automatiser de nombreuses tâches quotidiennes sur un ordinateur. Elle constitue un outil essentiel pour les développeurs de logiciels.

Le terminal macOS est une application que vous pouvez utiliser pour accéder à l'interface de ligne de commande. Comme toute autre application, vous pouvez le trouver en accédant au Finder, en accédant au dossier Applications, puis au dossier Utilitaires. À partir de là, double-cliquez sur le terminal comme sur toute autre application pour l'ouvrir. Vous pouvez également utiliser Spotlight en maintenant les touchesCMD etSPACE enfoncées pour trouver Terminal en le tapant dans la case qui apparaît.

macOS Terminal

Il y a beaucoup d'autres commandes Terminal à apprendre qui peuvent vous permettre de faire des choses plus puissantes. L’article «https://www.digitalocean.com/community/tutorials/an-inintroduction-to-the-linux-terminal[ Une introduction au terminal Linux] peut vous aider à mieux vous orienter avec le terminal Linux, qui est similaire vers le terminal macOS.

Maintenant que vous avez ouvert Terminal, vous pouvez télécharger et installerXcode, un package d'outils de développement dont vous aurez besoin pour installer Go.

[[step-2 -—- Installing-xcode]] == Étape 2 - Installation de Xcode

Xcode est unintegrated development environment (IDE) qui comprend des outils de développement logiciel pour macOS. Vous pouvez vérifier si Xcode est déjà installé en tapant ce qui suit dans la fenêtre du terminal: 

xcode-select -p

La sortie suivante signifie que Xcode est installé: 

Output/Library/Developer/CommandLineTools

Si vous recevez une erreur, installezXcode from the App Store dans votre navigateur Web et acceptez les options par défaut.

Une fois Xcode installé, retournez à la fenêtre de votre terminal. Ensuite, vous devrez installer l’application distincte Outils de ligne de commande de Xcode, ce que vous pouvez faire en tapant: 

xcode-select --install

À ce stade, Xcode et son application Outils de ligne de commande sont entièrement installés et nous sommes prêts à installer le gestionnaire de paquets Homebrew.

[[step-3 -—- installation-and-setup-homebrew]] == Étape 3 - Installation et configuration de Homebrew

Bien que le terminal macOS dispose de nombreuses fonctionnalités des terminaux Linux et d'autres systèmes Unix, il n'est pas livré avec un gestionnaire de paquets qui respecte les meilleures pratiques. Unpackage manager est un ensemble d'outils logiciels qui fonctionnent pour automatiser les processus d'installation qui incluent l'installation initiale du logiciel, la mise à niveau et la configuration du logiciel, et la suppression du logiciel si nécessaire. Ils conservent les installations dans un emplacement central et peuvent gérer tous les packages logiciels du système dans des formats couramment utilisés. Homebrew fournit à macOS un système de gestion de progiciels gratuit et open source qui simplifie l'installation de logiciels sur macOS.

Pour installer Homebrew, tapez ceci dans la fenêtre de votre terminal: 

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Homebrew est fait avec Ruby, il modifiera donc le chemin Ruby de votre ordinateur. La commandecurl extrait un script de l'URL spécifiée. Ce script explique ce qu'il va faire, puis met en pause le processus pour vous demander de confirmer. Cela vous donne beaucoup de commentaires sur ce que le script va faire sur votre système et vous donne l'occasion de vérifier le processus.

Si vous devez entrer votre mot de passe, sachez que vos séquences de touches ne s'affichent pas dans la fenêtre du terminal, mais qu'elles sont enregistrées. Appuyez simplement sur la touchereturn une fois que vous avez entré votre mot de passe. Sinon, appuyez sur la lettrey pour «oui» chaque fois que vous êtes invité à confirmer l'installation.

Passons en revue les indicateurs associés à la commandecurl:

  • L'indicateur-f ou--fail indique à la fenêtre du terminal de ne donner aucune sortie de document HTML sur les erreurs du serveur.

  • L'indicateur-s ou--silent coupecurl afin qu'il n'affiche pas l'indicateur de progression, et combiné avec l'indicateur-S ou--show-error, il garantira quecurl affiche un message d'erreur en cas d'échec.

  • L'indicateur-L ou--location indiquera àcurl de refaire la demande vers un nouvel emplacement si le serveur signale que la page demandée a été déplacée vers un autre emplacement.

Une fois le processus d'installation terminé, nous placerons le répertoire Homebrew en haut de la variable d'environnementPATH. Cela garantira que les installations Homebrew seront appelées via les outils que macOS pourrait sélectionner automatiquement et qui pourraient aller à l’encontre de l’environnement de développement que nous créons.

Vous devez créer ou ouvrir le fichier~/.bash_profile avec l'éditeur de texte de ligne de commandenano en utilisant la commandenano: 

nano ~/.bash_profile

Une fois le fichier ouvert dans la fenêtre du terminal, écrivez ce qui suit: 

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

Pour enregistrer vos modifications, maintenez la toucheCTRL et la lettreo enfoncées, et lorsque vous y êtes invité, appuyez sur la toucheRETURN. Vous pouvez maintenant quitter nano en maintenant la toucheCTRL et la lettrex enfoncées.

Activez ces modifications en exécutant les opérations suivantes dans Terminal: 

source ~/.bash_profile

Une fois que vous avez fait cela, les modifications que vous avez apportées à la variable d'environnementPATH entreront en vigueur.

Vous pouvez vous assurer que Homebrew a été installé avec succès en tapant: 

brew doctor

Si aucune mise à jour n'est requise pour le moment, la sortie du terminal indiquera: 

OutputYour system is ready to brew.

Sinon, vous pouvez recevoir un avertissement pour exécuter une autre commande telle quebrew update pour vous assurer que votre installation de Homebrew est à jour.

Une fois que Homebrew est prêt, vous pouvez installer Go.

[[step-4 -—- Installing-go]] == Étape 4 - Installation de Go

Vous pouvez utiliser Homebrew pour rechercher tous les packages disponibles avec la commandebrew search. Dans le cadre de ce tutoriel, vous allez rechercher des packages ou des modules liés à Go: 

brew search golang

[.note] #Note: Ce tutoriel n'utilise pasbrew search go car il renvoie trop de résultats. Commego est un si petit mot et correspondrait à de nombreux packages, il est devenu courant d'utilisergolang comme terme de recherche. C'est également une pratique courante lors de la recherche sur Internet d'articles liés à Go. Le termeGolang est né du domaine pour Go, qui estgolang.org.
#

Le terminal affichera une liste de ce que vous pouvez installer: 

Outputgolang  golang-migrate

Go sera parmi les éléments de la liste. Allez-y et installez-le: 

brew install golang

La fenêtre Terminal vous donnera des informations sur le processus d’installation de Go. Cela peut prendre quelques minutes avant que l’installation soit terminée.

Pour vérifier la version de Go que vous avez installée, tapez ce qui suit: 

go version

Cela produira la version spécifique de Go actuellement installée, qui sera par défaut la version la plus récente et la plus stable de Go disponible.

À l'avenir, pour mettre à jour Go, vous pouvez exécuter les commandes suivantes pour mettre d'abord à jour Homebrew, puis mettre à jour Go. Vous n’avez pas à le faire maintenant, car vous venez d’installer la dernière version: 

brew update
brew upgrade golang

brew update mettra à jour les formules pour Homebrew lui-même, en s'assurant que vous avez les dernières informations sur les paquets que vous souhaitez installer. brew upgrade golang mettra à jour le packagegolang vers la dernière version du package.

Il est judicieux de vous assurer que votre version de Go est à jour.

Avec Go installé sur votre ordinateur, vous êtes maintenant prêt à créer un espace de travail pour vos projets Go.

[[step-5 -—- creating-your-go-workspace]] == Étape 5 - Création de votre espace de travail Go

Maintenant que Xcode, Homebrew et Go sont installés, vous pouvez créer votre espace de travail de programmation.

L'espace de travail Go contient deux répertoires à la racine:

  • src: répertoire contenant les fichiers source Go. Un fichier source est un fichier que vous écrivez en utilisant le langage de programmation Go. Les fichiers sources sont utilisés par le compilateur Go pour créer un fichier binaire exécutable.

  • bin: le répertoire contenant les exécutables créés et installés par les outils Go. Les exécutables sont des fichiers binaires qui s'exécutent sur votre système et exécutent des tâches. Ce sont généralement les programmes compilés par votre code source ou un autre code source Go téléchargé.

Le sous-répertoiresrc peut contenir plusieurs référentiels de contrôle de version (tels queGit,Mercurial etBazaar). Vous verrez des répertoires commegithub.com ougolang.org lorsque votre programme importe des bibliothèques tierces. Si vous utilisez un référentiel de code commegithub.com, vous placerez également vos projets et fichiers source dans ce répertoire. Cela permet une importation canonique de code dans votre projet. Les importationsCanonical sont des importations qui font référence à un package complet, tel quegithub.com/digitalocean/godo.

Voici à quoi peut ressembler un espace de travail typique: 

.
├── bin
│   ├── buffalo                                      # command executable
│   ├── dlv                                          # command executable
│   └── packr                                        # command executable
└── src
    └── github.com
        └── digitalocean
            └── godo
                ├── .git                            # Git reposistory metadata
                ├── account.go                      # package source
                ├── account_test.go                 # test source
                ├── ...
                ├── timestamp.go
                ├── timestamp_test.go
                └── util
                    ├── droplet.go
                    └── droplet_test.go

Le répertoire par défaut de l'espace de travail Go à partir de la version 1.8 est le répertoire de base de votre utilisateur avec un sous-répertoirego ou$HOME/go. Si vous utilisez une version de Go antérieure à la 1.8, il est recommandé d'utiliser toujours l'emplacement$HOME/go pour votre espace de travail.

Exécutez la commande suivante pour créer la structure de répertoires pour votre espace de travail Go: 

mkdir -p $HOME/go/{bin,src}

L’option-p indique àmkdir de créer tous lesparents dans le répertoire, même s’ils n’existent pas actuellement. L'utilisation de{bin,src} crée un ensemble d'arguments pourmkdir et lui dit de créer à la fois le répertoirebin et le répertoiresrc.

Cela garantira que la structure de répertoire suivante est maintenant en place: 

└── $HOME
    └── go
        ├── bin
        └── src

Avant Go 1.8, il était nécessaire de définir une variable d'environnement locale appelée$GOPATH. Bien que cela ne soit plus explicitement requis, cela reste une bonne pratique car de nombreux outils tiers dépendent toujours de la définition de cette variable.

Vous pouvez définir vos$GOPATH en l'ajoutant à vos~/.bash_profile.

Tout d'abord, ouvrez~/.bash_profile avecnano ou votre éditeur de texte préféré: 

nano ~/.bash_profile

Définissez vos$GOPATH en ajoutant ce qui suit au fichier:

~/.bash_profile

export GOPATH=$HOME/go

Lorsque Go compile et installe les outils, il les place dans le répertoire$GOPATH/bin. Pour plus de commodité, il est courant d’ajouter le sous-répertoire/bin de l’espace de travail à vosPATH dans vos~/.bash_profile:

~/.bash_profile

export PATH=$PATH:$GOPATH/bin

Vous devriez maintenant avoir les entrées suivantes dans vos~/.bash_profile:

~/.bash_profile

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

Cela vous permettra maintenant d'exécuter tous les programmes que vous compilez ou téléchargez via les outils Aller n'importe où sur votre système.

Pour mettre à jour votre shell, lancez la commande suivante pour charger les variables globales que vous venez de créer: 

. ~/.bash_profile

Vous pouvez vérifier que votre$PATH est mis à jour en utilisant la commandeecho et en inspectant la sortie: 

echo $PATH

Vous devriez voir vos$GOPATH/bin qui apparaîtront dans votre répertoire personnel. Si vous étiez connecté en tant quesammy, vous verriez/Users/sammy/go/bin dans le chemin. 

Output/Users/sammy/go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

Maintenant que vous avez créé la racine de l'espace de travail et que votre variable d'environnement$GOPATH est définie, vous allez créer vos futurs projets avec la structure de répertoires suivante. Cet exemple suppose que vous utilisezgithub.com comme référentiel: 

$GOPATH/src/github.com/username/project

Si vous travailliez sur le projethttps://github.com/digitalocean/godo, vous le mettriez dans le répertoire suivant: 

$GOPATH/src/github.com/digitalocean/godo

Structurer vos projets de cette manière rendra les projets disponibles avec l'outilgo get. Cela facilitera également la lisibilité plus tard.

Vous pouvez vérifier cela en utilisant la commandego get pour récupérer la bibliothèquegodo: 

go get github.com/digitalocean/godo

Nous pouvons voir qu'il a téléchargé avec succès le packagegodo en listant le répertoire: 

ls -l $GOPATH/src/github.com/digitalocean/godo

Vous recevrez une sortie similaire à celle-ci: 

Output-rw-r--r--  1 sammy  staff   2892 Apr  5 15:56 CHANGELOG.md
-rw-r--r--  1 sammy  staff   1851 Apr  5 15:56 CONTRIBUTING.md
.
.
.
-rw-r--r--  1 sammy  staff   4893 Apr  5 15:56 vpcs.go
-rw-r--r--  1 sammy  staff   4091 Apr  5 15:56 vpcs_test.go

Au cours de cette étape, vous avez créé un espace de travail Go et configuré les variables d’environnement nécessaires. Dans l'étape suivante, vous testerez l'espace de travail avec du code.

[[step-6 -—- creation-a-simple-program]] == Étape 6 - Création d'un programme simple

Maintenant que votre espace de travail Go est configuré, il est temps de créer un simple programme «Hello, World!». Cela garantira le bon fonctionnement de votre espace de travail et vous permettra de vous familiariser davantage avec Go.

Comme vous créez un seul fichier source Go et non un projet réel, vous n'avez pas besoin d'être dans votre espace de travail pour le faire.

Depuis votre répertoire personnel, ouvrez un éditeur de texte en ligne de commande, tel quenano, et créez un nouveau fichier: 

nano hello.go

Une fois le fichier texte ouvert dans Terminal, tapez votre programme: 

package main

import "fmt"

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

Quittez nano en tapant les touchescontrol etx, et lorsque vous êtes invité à enregistrer le fichier, appuyez sury.

Ce code utilisera le packagefmt et appellera la fonctionPrintln avecHello, World! comme argument. Cela entraînera l'impression de la phraseHello, World! sur le terminal lorsque le programme est exécuté.

Une fois que vous quitteznano et revenez à votre shell, exécutez le programme: 

go run hello.go

Le programmehello.go que vous venez de créer entraînera la production par Terminal de la sortie suivante: 

OutputHello, World!

Au cours de cette étape, vous avez utilisé un programme de base pour vérifier que votre espace de travail Go est correctement configuré.

Conclusion

Toutes nos félicitations! À ce stade, vous avez un espace de travail de programmation Go configuré sur votre ordinateur macOS local et pouvez commencer un projet de codage!

Related