Go est un langage de programmation typé statiquement avec un support solide pour la concurrence. Il est soutenu par Google et est destiné aux projets à usage général tels que le développement d'applications système ou les applications Web. Golang devient de plus en plus populaire en raison de son ensemble de fonctionnalités robustes et de sa prise en charge des dernières pratiques de programmation. Un grand nombre d'entreprises recherchent des développeurs Go actifs en raison de son utilisation croissante dans les applications modernes. Les développeurs peuvent utiliser un certain nombre de commandes go pour augmenter leur productivité de programmation ou leur gestion du flux de travail. Dans ce guide, nous aborderons certaines de ces commandes pour les aspirants développeurs Go.
Exemples de commandes Go utiles sous Linux
Go fournit une suite d'outils utiles pour gérer le processus de construction et le flux de travail pour les programmeurs. Ils sont invoqués au moyen d'un ensemble de commandes simples intégrées à go. Nous décrivons 40 de ces commandes utiles dans la section suivante.
1. Créer un programme
La commande go build permet aux développeurs de construire l'exécutable binaire d'un programme donné. Nous avons créé un programme serveur simple appelé server.go pour en faire la démonstration. Maintenant, nous allons construire ce programme en utilisant go build.
$ go build server.go
Cette commande créera un fichier exécutable binaire nommé server dans notre répertoire de travail go. Vous pouvez trouver le code du programme serveur dans cette section du site Web de Golang. Maintenant, nous pouvons exécuter le programme comme n'importe quel autre outil de ligne de commande Linux.
$ ./server
2. Exécuter un programme sans le créer
Les développeurs apportent généralement des modifications progressives à leurs programmes en fonction des tests. Il n'est pas pratique de construire le programme à chaque fois que vous faites une légère modification. Heureusement, go nous permet d'exécuter un programme même sans le construire en premier lieu.
$ go run server.go- -
Cette commande exécutera le programme directement sans vous obliger à créer le code source. C'est extrêmement utile lorsque vous jouez avec des sous-programmes plus petits.
3. Afficher le GOPATH actuel
Go gère les codes sources, les objets et les fichiers binaires d'un programme à l'aide de l'espace de travail Go. La racine de cet espace de travail est spécifiée en utilisant le GOPATH variable. Vous pouvez trouver le chemin actuel vers votre espace de travail Go en utilisant la commande suivante.
$ go env GOPATH
C'est là que vous devez placer vos fichiers sources et les compiler. Bien que vous puissiez configurer plusieurs espaces de travail Go, il est conseillé d'utiliser un espace de travail distinct. La sous-commande env fournit également de nombreuses autres informations, comme nous le verrons plus tard.
4. Définir un nouveau GOPATH
À partir de la version 1.8 de Go, les systèmes Unix spécifient le $HOME/go répertoire comme GOPATH par défaut. Cependant, vous pouvez facilement changer cela en un emplacement différent à l'aide de la simple commande suivante.
$ go env -w GOPATH=$HOME/projects/go
Cela changera votre GOPATH en $HOME/projects/go . Vous pouvez également définir le GOPATH en ajoutant la ligne suivante à votre ~/.bash_profile . Ouvrez simplement le fichier à l'aide de votre éditeur de texte Linux préféré et ajoutez la ligne suivante à la fin.
export GOPATH=$HOME/projects/go
Après avoir enregistré le fichier, quittez et exécutez la commande suivante pour refléter les modifications.
$ source ~/.bash_profile
5. Installer les packages Go
Chaque programme go que vous écrivez ou utilisez fait partie d'un package go. Les packages Go ne sont rien d'autre qu'un répertoire contenant des fichiers go dans /src annuaire. Nous pouvons installer les packages go très facilement en utilisant la commande go install.
$ go install test-app
Lorsque vous exécutez cette commande, go recherchera d'abord le répertoire test-app dans $GOROOT/src puis dans $GOPATH/src . Une fois trouvé, go déterminera le point d'entrée du paquet en recherchant le paquet main dans les fichiers source. Go procédera ensuite à l'installation de ce package et placera le binaire test-app dans le dossier /bin répertoire de votre espace de travail.
6. Télécharger et installer des packages
Golang jouit d'une popularité croissante parmi un grand nombre de développeurs FOSS. En conséquence, de nombreux programmes utiles sont écrits en utilisant go. Vous pouvez facilement télécharger un package go tiers et l'installer à l'aide de la simple commande suivante.
$ go get host/example-project $ go get github.com/fatih/color
Cette commande téléchargera et installera le package de couleurs populaire avec toutes ses dépendances. Vous pouvez également mettre à jour le package à l'avenir en utilisant le -u drapeau, comme indiqué ci-dessous.
$ go get -u github.com/fatih/color
7. Répertorier les packages avec les dépendances
Votre espace de travail Go s'agrandit avec le temps et peut héberger des packages qui ne sont plus nécessaires. Vous pouvez répertorier tous les packages go installés ainsi que leurs dépendances. Cela vous aidera à déterminer les packages à supprimer de votre espace de travail.
$ go list
Cette commande go nécessite un chemin d'importation et fournira des informations sur un package spécifique. Pour obtenir des informations sur tous les packages installés, vous devez utiliser un caractère générique spécial.
$ go list ./...
Exécutez cette commande depuis votre GOPATH et go affichera tous les packages installés dans votre espace de travail.
8. Forfaits Fix Go
Lorsque vous mettez à jour votre version Go, les programmes qui utilisent des fonctionnalités plus anciennes peuvent être endommagés. Go fournit un outil pratique pour réparer ces programmes et les réécrire pour utiliser les nouvelles fonctionnalités du langage. Vous devrez utiliser la commande go fix pour ce faire.
$ go fix app/app.go
Cette commande réécrira le fichier app.go pour prendre en charge les nouvelles API et fonctionnalités Go. Utilisez la commande suivante pour réparer des applications entières.
$ go tool fix app/
9. Supprimer les objets Go
Go crée des fichiers d'objets lors de la construction du programme et les stocke dans un répertoire temporaire. De plus, de nombreux outils de go créent également divers objets qui prennent de l'espace de stockage. Vous voudrez vous débarrasser des objets inutilisés au fil du temps.
$ go clean
Il supprimera tous les objets go créés avant l'exécution de cette commande. Utilisez la commande ci-dessous pour supprimer tous les objets d'un package spécifique.
$ go clean -i app/
Le -i l'option de nettoyage supprimera également tous les fichiers binaires ou archives correspondants.
10. Afficher les informations sur l'environnement
Les programmeurs peuvent facilement trouver des informations sur diverses variables d'environnement go. La commande go env peut être utilisée pour afficher toutes les variables d'environnement go dans votre émulateur de terminal Linux.
$ go env
Il affichera toutes les variables go, que leurs valeurs soient définies ou non. Pour imprimer la valeur d'une variable go spécifique, utilisez le format suivant.
$ go env VARIABLE $ go env GOCACHE
Nous avons imprimé le GOPATH plus tôt en utilisant la syntaxe ci-dessus. Il est utile pour récupérer des variables d'environnement particulières.
11. Créer des rapports de bogues
Go est un langage relativement nouveau et déploie assez souvent de nouvelles fonctionnalités. Bien qu'il soit conçu avec beaucoup de soin, vous pouvez parfois rencontrer des bogues ou des problèmes indésirables. Heureusement, il est très pratique de générer des rapports de bogues pour l'exécution Go.
$ go bug
Lorsque vous exécutez la commande ci-dessus, elle ouvre votre navigateur par défaut et crée un rapport de bogue dans le référentiel GitHub officiel de Go. Il ajoutera toutes les informations essentielles telles que les informations système ainsi que les configurations go.
12. Reformater les sources du paquet
Le runtime Go rend le formatage extrêmement pratique pour les développeurs. Vous pouvez simplement lancer votre éditeur de code Linux et commencer à écrire du code sans penser aux indentations ou aux alignements. Une fois cela fait, utilisez la commande go ci-dessous pour formater votre code selon la recommandation de Go.
$ go fmt [packages] $ go fmt server.go
La deuxième commande formate le fichier server.go. Vous pouvez également passer un répertoire contenant un tas de fichiers go pour les formater tous. Go utilisera des tabulations pour les indentations et des espaces pour les alignements de code.
13. Gérer les modules
Toutes les commandes Go ont un support pré-construit pour les modules. Les modules dans Go ne sont rien d'autre qu'une collection de plusieurs packages go. Le go.mod contient tous les packages tiers pour une application Go. Vous pouvez facilement créer ce fichier en utilisant la commande suivante.
$ go mod <command> [arguments] $ go mod init app
Cette commande créera un go.mod fichier pour notre package d'application personnalisé. Il contiendra le nom du module ainsi que les informations de version go. L'utilitaire mod prend diverses autres commandes en dehors de init . Tapez ce qui suit pour afficher les options disponibles.
$ go help mod
14. Générer des fichiers Go
Golang permet aux développeurs de créer ou de mettre à jour des fichiers source Go en utilisant des directives dans les sources existantes. La commande generate est utilisée pour ce faire. Bien que generate soit destiné à créer ou à mettre à jour des fichiers Go, il peut également être utilisé pour effectuer d'autres tâches.
$ go generate [-run regexp] [-n] [-v] [-x] [build flags] [file.go... | packages]
Lorsque vous exécutez go generate, il recherchera les directives du format suivant dans vos fichiers source go.
//go:generate command argument...
Generate exécutera la commande une fois qu'il aura trouvé la directive dans votre source go. Notez qu'il ne peut y avoir d'espace avant ou dans "//go ".
15. Mettre à niveau les dépendances du package
Plus tôt, nous avons montré comment installer ou mettre à jour des packages à l'aide de l'utilitaire go get. Cependant, lorsque vous travaillez sur des projets plus importants, vous devrez souvent mettre à jour les dépendances de votre package. La commande suivante met à jour tous les packages Go qui se trouvent dans votre GOPATH.
$ go get -u all
Cependant, vous devez utiliser différents GOPATH pour différents projets. Cela garantira que la mise à jour des packages dans le projet A n'endommagera pas le projet B. Vous pouvez également mettre à niveau un package vers une version spécifique en utilisant le suffixe '@ ‘.
$ go get [email protected]
16. Mises à niveau du package de test
Une fois la mise à niveau terminée, assurez-vous que tous vos anciens projets fonctionnent parfaitement. Vous pouvez utiliser la commande simple suivante pour le faire depuis votre terminal.
$ go test all
Cette commande vérifiera si les applications fonctionnent comme prévu après les mises à niveau du package. Vous pouvez également tester un seul projet en spécifiant le chemin d'importation du projet.
$ go test app/
Cela affichera des informations résumées sur les résultats du test.
17. Trouver des erreurs dans les packages
Go fournit un outil flexible pour détecter les erreurs ou erreurs insoupçonnées dans votre fichier source. La commande go vet utilise des heuristiques pour trouver des utilisations suspectes de constructions, qui conduisent souvent à de véritables erreurs. La commande ci-dessous vérifie le package qui se trouve dans le répertoire actuel pour de telles erreurs.
$ go vet
Vous pouvez également spécifier les packages à l'aide du chemin d'importation, comme indiqué dans l'exemple ci-dessous.
$ go vet app/
Utilisez la commande ci-dessous pour trouver plus d'informations sur le vétérinaire et ses options disponibles.
$ go doc cmd/vet
18. Télécharger les modules dans le cache
Vous pouvez télécharger les modules Go dans votre cache local. Ceci est très utile lorsque vous travaillez sur des projets plus importants et facilitera les mises à jour des applications au fil du temps. La commande pour cela ressemble à ci-dessous.
$ go mod download [-x] [-json] [modules]
Passez simplement le nom du module, comme indiqué ci-dessous.
$ go mod download example-project/app
Depuis la version 1.11 de Go, les modules téléchargés sont stockés dans $GOPATH/pkg/mod . Le -x les options affichent les commandes qui seront exécutées par le téléchargement du mod. Le -json flag imprime un ensemble d'objets JSON décrivant le module téléchargé sur la sortie du terminal.
19. Maintenir les dépendances du module
La commande go mod tidy nous permet d'ajouter des dépendances manquantes ou de supprimer des modules inutilisés. Cette commande go aide à maintenir les dépendances des modules et à garder vos applications aussi légères que possible. Exécutez simplement la commande simple suivante pour ce faire.
$ go mod tidy [-v]
Assurez-vous de l'exécuter à partir du répertoire racine de votre projet. Vous pouvez vérifier le fichier go.mod pour voir quelles dépendances ont été ajoutées ou supprimées. Le -v flag, s'il est utilisé, fait que tidy affiche les modules qui ont été supprimés à l'erreur standard.
20. Créer une copie fournisseur des dépendances
Go permet aux développeurs de créer une copie commerciale des dépendances du module. Cela réinitialise simplement le répertoire du fournisseur du module principal et inclut tous les packages nécessaires pour créer ou tester les packages qui se trouvent dans le module principal.
$ go mod vendor [-v]
La commande ci-dessus crée une copie commerciale des dépendances du module principal. Si vous utilisez l'option -v, elle affichera les noms des modules et des packages vendus dans l'erreur standard du système.
21. Vérifier les dépendances du module
Les programmeurs peuvent facilement vérifier si toutes les dépendances des modules actuels ont le contenu attendu ou non. La commande de vérification "go mod" vérifie si des dépendances dans le cache local ont été modifiées depuis le téléchargement. La commande prend le format ci-dessous.
$ go mod verify
La commande ci-dessus affichera 'tous les modules vérifiés ' si les dépendances du module ne sont pas modifiées. Sinon, il signalera quels modules ont été modifiés et provoquera une sortie non nulle. Cet outil simple peut aider les développeurs à déterminer l'intégrité de leurs dépendances.
22. Afficher pourquoi les packages/modules sont nécessaires
Vous pouvez voir pourquoi certains modules ou packages sont requis dans votre application. Ceci est utile si vous travaillez avec le code de quelqu'un d'autre ou essayez de comprendre ce que certaines choses font dans un projet spécifique. La commande "pourquoi" de l'outil mod nous permet de le faire.
$ go mod why [-m] [-vendor] packages... $ go mod why golang.org/x/text/language golang.org/x/text/encoding
Le premier est la syntaxe générale, et le second est un exemple. Il imprime pourquoi la langue et encodage packages sont requis dans votre application.
23. Désassembler les binaires Go
Si vous utilisez Go pour la programmation système ou des applications intensives comme les jeux, vous devrez analyser vos exécutables de temps en temps. Go fournit un ensemble d'outils pour analyser les fichiers binaires. Dans cet exemple, nous examinerons la commande objdump. Il désassemble les exécutables go et fonctionne comme la commande Linux objdump.
$ go tool objdump [-s symregexp] binary
Il s'agit de la syntaxe prise en charge pour objdump. Vous devez utiliser l'utilitaire go tool pour utiliser objdump. La commande ci-dessous désassemble un binaire go nommé server.go.
$ go tool objdump ./server
Vous pouvez limiter le désassemblage à des symboles spécifiques en utilisant l'option -s. Il ne désassemblera que les symboles dont le nom correspond à symregexp . Vous souhaiterez généralement enregistrer la sortie pour une inspection détaillée.
$ go tool objdump ./server > disassembled-data
24. Afficher l'API exportée pour les packages
Vous pouvez facilement afficher les API exportées par un ensemble de packages Go. Vous devrez utiliser l'outil api de la commande go pour ce faire. Examinez attentivement la commande ci-dessous pour voir comment cela fonctionne.
$ go tool api
Cela imprimera les API de vos packages go dans la sortie standard. Redirigez la sortie vers un fichier si vous souhaitez enregistrer la sortie de cette commande.
25. Utiliser Go Assembler
Go est livré avec un assembleur intégré qui permet aux développeurs de créer des fichiers objets à partir du code source de l'assembleur. Bien que vous utiliserez rarement l'assemblage avec go, avoir la possibilité de le faire ne fait pas de mal. Écrivez simplement le code d'assemblage à l'intérieur de votre package go. Vous pouvez ensuite invoquer l'assembleur go, comme illustré ci-dessous.
$ go tool asm test.s $ go tool asm new-test.asm
Habituellement, les programmeurs système utilisent l'assemblage pour augmenter les performances d'une section critique du code. Même go implémente une partie du package mathématique en utilisant l'assemblage, comme le calcul pi.
26. Imprimer l'ID de construction des binaires
L'identifiant de construction d'un binaire ELF est une représentation unique des informations de construction. Go fournit un utilitaire simple pour afficher ces informations directement depuis votre terminal. Voir l'exemple ci-dessous pour voir comment cela fonctionne.
$ go tool buildid server
Cela affichera l'identifiant de construction de l'exécutable binaire nommé server. Ceci est créé lorsque vous générez le binaire via go build ou d'autres outils de construction. Vous pouvez le faire correspondre avec la sortie de la commande file. Exécutez la commande ci-dessous et recherchez la section Go BuildID.
$ file server
27. Utiliser l'outil CGO
L'une des principales caractéristiques de Go est son interopérabilité avec les bases de code C. Vous pouvez utiliser des codes C dans les sources Go et vice versa. Vous pouvez ensuite générer le binaire en utilisant le go build ou install habituel à partir de la racine de votre package. Alternativement, vous pouvez utiliser le cgo outil du runtime go.
$ go tool cgo [cgo options] [-- compiler options] gofiles...
$ go tool cgo app/ccode.go
Consultez la documentation ci-dessous pour voir quelles options sont disponibles pour cgo.
$ go doc cmd/cgo
28. Utiliser Go Compile
Par défaut, la commande go build ou run ne crée pas de fichiers objet. Vous pouvez utiliser l'utilitaire de compilation de la commande go pour générer un fichier objet. Cela ne fonctionnera que lorsque vous utiliserez l'outil go, comme illustré dans l'exemple ci-dessous.
$ go tool compile server.go
Cette commande crée un exécutable binaire nommé server ainsi qu'un fichier objet nommé server.o. L'utilitaire de compilation offre également une pléthore de fonctionnalités utiles. Vous pouvez consulter un aperçu détaillé de la compilation en exécutant la commande suivante.
$ go doc cmd/compile
29. Utiliser Go Dist
L'utilitaire dist permet aux développeurs d'amorcer, de créer et de tester l'environnement d'exécution go à partir de leur terminal. Il a la syntaxe suivante.
$ go tool dist [command]
Certaines des commandes disponibles sont banner, bootstrap, clean, list, env et version. Vous pouvez trouver une liste de toutes les commandes prises en charge en exécutant ce qui suit.
$ go doc cmd/dist
Par exemple, l'extrait de code suivant imprime la bannière d'installation de Go à l'aide de l'outil dist.
$ go tool dist banner
Utilisez la commande ci-dessous pour répertorier toutes les plates-formes prises en charge pour Go. Il affichera une sortie JSON indiquant la prise en charge du système d'exploitation, de l'architecture et du CGO.
$ go tool dist list -json
30. Utilisez l'outil Gofmt
Gofmt est un autre utilitaire de formatage source de Go. Cela fonctionne assez similaire à fmt . En fait, lorsque vous utilisez go fmt, cela s'appelle sous le capot. Gofmt a la syntaxe suivante.
$ gofmt [flags] [path ...]
Par exemple, la commande ci-dessous reformatera le fichier source test.go et l'imprimera sur la sortie standard. Si vous donnez un nom de chemin au lieu d'un nom de fichier, gofmt essaiera de reformater tous les fichiers .go à l'intérieur de ce répertoire.
$ gofmt test.go
Contrairement à fmt, gofmt ne réécrit pas les modifications dans le fichier d'origine. Vous devrez utiliser le -w drapeau pour le faire. Utilisez la commande suivante pour obtenir une liste de tous les drapeaux disponibles.
$ go doc cmd/gofmt
31. Utilisez l'outil Lien
L'utilitaire Link lit l'archive go ou l'objet d'un package main et crée un exécutable binaire contenant toutes ses dépendances. Il est appelé à l'aide de l'outil go et a la syntaxe ci-dessous.
$ go tool link [flags] main.a
Par exemple, la commande ci-dessous combinera le fichier server.o avec ses dépendances et créera un binaire.
$ go tool link server.o
Link prend en charge un grand nombre d'indicateurs qui permettent aux développeurs de gérer ou de contrôler le processus de construction. Vous pouvez en trouver une liste détaillée en exécutant la commande suivante.
$ go doc cmd/link
32. Imprimer la liste des symboles
Vous pouvez imprimer la liste des symboles contenus dans un fichier objet, une archive ou un exécutable à l'aide de l'outil go nm. Les symboles sont simplement des noms d'objets globaux tels que des méthodes utilisées par un fichier objet. La syntaxe de cette commande est illustrée ci-dessous.
$ go tool nm [options] file...
$ go tool nm server.o
La sortie imprime chaque symbole dans une nouvelle ligne. Ils sont séparés par trois champs séparés par des espaces, représentant l'adresse, le type et le nom du symbole. Vous pouvez afficher la liste des types de symboles à partir de cette page de la documentation Go. Les options incluent la taille, le type, le tri et n.
33. Gérer les archives Go
Go permet aux développeurs de créer, modifier ou extraire des archives. L'outil go nm nous permet de faire de telles opérations binaires. Il s'agit d'une simulation de base de l'outil ar traditionnel sous Unix. La syntaxe de cette commande est indiquée ci-dessous.
$ go tool pack op file.a [name...]
L'op signifie opérations. Pack permet plusieurs opérations, y compris la création d'une archive, l'ajout à l'archive et l'extraction.
$ go tool pack r server.a server.o
Cette commande ajoute le fichier server.o au serveur d'archives.a. Vous pouvez voir la liste de tous les codes OP disponibles en exécutant la commande suivante.
$ go doc cmd/pack
34. Afficher les données de profilage
Go est livré avec un excellent support de profilage. Si vous développez des applications gourmandes en ressources ou si vous programmez pour des machines à faible spécification, le profilage vous aidera à augmenter considérablement les performances. L'utilitaire pprof de la commande go nous permet d'afficher et d'interpréter les données de profilage.
$ go tool pprof binary profile $ go tool pprof ./app cpu.prof
Vous pouvez travailler avec les profils CPU et Mémoire. De plus, pprof permet également aux développeurs d'analyser les données de profilage à distance sur le Web. Bien que les programmeurs Go débutants puissent trouver l'API un peu compliquée, nous avons trouvé que le gain de performances valait la courbe d'apprentissage.
35. Afficher les fichiers de trace
Go fournit un excellent support de simultanéité via des goroutines. Cependant, nous voyons souvent des développeurs écrire du code concurrent qui ne profite guère à leurs programmes. Cela se produit en raison d'une parallélisation inefficace, qui entraîne une latence, des conflits et d'autres problèmes de performances. Heureusement, vous pouvez utiliser l'utilitaire go trace pour visualiser le fonctionnement de vos goroutines.
$ go tool trace trace.out
Cette commande affichera le fichier de trace trace.out pour un programme donné, qui peut être généré de plusieurs façons. Vous pouvez utiliser le test de démarrage commande, runtime/trace.Start , ou le net/http/pprof package pour créer un fichier de trace pour votre application. Consultez ce lien pour en savoir plus à ce sujet.
36. Convertir la sortie de test en JSON
L'utilitaire de ligne de commande go fournit un moyen efficace de convertir la sortie de test en JSON. Vous pouvez enregistrer cette sortie JSON pour une inspection ultérieure ou l'utiliser pour un traitement ultérieur. La commande ci-dessous nous montre comment faire cela en utilisant l'utilitaire test2json de Golang.
$ go tool test2json [-p pkg] [-t] [./pkg.test -test.v]
$ go tool test2json -p example.go -t example_test.go
La première ligne contient la syntaxe pour le test2json commande, tandis que la seconde est un exemple de travail. Il affichera la sortie JSON directement sur la console. Vous pouvez enregistrer ces données facilement en utilisant une simple redirection.
37. Utilisez l'outil Addr2line
Go fournit une simulation minimale de l'outil GNU addr2line au moyen de la commande go addr2line. Il traduit les adresses en numéros de ligne dans votre programme. Cela peut être vraiment bénéfique pour les programmeurs système et les débogueurs.
$ go tool addr2line binary
Lorsqu'elle est invoquée de cette manière, cette commande lira les adresses hexadécimales. Pour chaque adresse, il affiche le nom de la fonction et le numéro de ligne correspondant à cette adresse. Vous pouvez trouver plus d'informations sur cet outil en utilisant la commande suivante.
$ go doc cmd/addr2line
38. Afficher la page d'aide
La page d'aide de go contient des informations résumées sur les commandes go standard. Il est utile pour rechercher rapidement l'utilisation et la syntaxe des commandes quotidiennes. Vous pouvez appeler la page d'aide en exécutant l'une des commandes simples suivantes.
$ go help $ go --help
De plus, vous pouvez également imprimer des informations pour une commande spécifique en utilisant la syntaxe ci-dessous.
$ go help <topic> $ go help install
39. Afficher la documentation Go
Go fournit une documentation détaillée pour les utilitaires d'exécution ainsi que les commandes standard. Ceux-ci sont extrêmement utiles si vous souhaitez maîtriser les fondamentaux de Golang et apprendre les meilleures pratiques. Vous pouvez appeler la documentation de l'une des manières suivantes.
$ man go
Cela imprimera un manuel de base pour Go. Cependant, go fournit des manuels individuels pour chaque commande. Vous pouvez trouver des informations détaillées pour une commande spécifique en exécutant ce qui suit.
$ man go-<topic> $ man go-install
Pour accéder à la documentation de divers outils go, utilisez la commande go doc. La commande ci-dessous affiche la documentation de l'utilitaire go link.
$ go doc cmd/link
40. Afficher les informations de version
Golang est un langage relativement nouveau, et il est donc très courant d'avoir des différences entre les différentes versions. De nombreuses fonctionnalités ne sont pas du tout disponibles pour les anciennes versions de Go. Vous devez donc vous assurer que votre installation go répond aux exigences de certaines fonctionnalités.
$ go version
La commande ci-dessus vous montrera quelle version du runtime go est installée sur votre machine. Vous pouvez l'utiliser pour vous assurer que votre code fonctionne de la même manière sur l'environnement de production que sur votre machine de développement.
Fin des pensées
Golang jouit d'une énorme popularité en raison de son ensemble de fonctionnalités et de ses performances robustes. Des géants de la technologie comme Google et Netflix utilisent Go pour créer leurs applications phares. L'une des principales raisons de la popularité continue de Go est sa chaîne d'outils standard. Les utilitaires standard sont souvent plus que suffisants, même pour les projets les plus importants. Et ils sont facilement accessibles au moyen de simples commandes go. Dans ce guide, nous avons décrit toutes les principales commandes nécessaires pour augmenter votre expertise Go ainsi que le flux de travail. Espérons qu'ils vous aideront à devenir un maître du go en un rien de temps.