build-web-application-with-golang/fr/01.3.md

# 1.3 Commandes Go

## Commandes Go

Le langage Go est disponible par défaut avec un ensemble complet d'outils. Vous pouvez exécuter la ligne de commande `go` pour les afficher:

![](images/1.3.go.png?raw=true)

Figure 1.3 Informations détaillées affichées par la commande `go`

Elles ont toutes une utilité. Voyons l'utilisation de certaines d'entre elles.

## go build

Cette commande sert de tests de compilation. Elle compilera les paquets dépendants au besoin.

- Si le paquet n'est pas le paquet `main`, comme `mymath` en section 1.2, rien ne sera généré après l'exécution de `go build`.
Si vous avez besoin de fichier de paquet `.a` dans `$GOPATH/pkg`, utilisez plutôt `go install` à la place.
- Si le paquet est le paquet `main`, la commande générera un exécutable dans le même dossier.
Si vous voulez que l'exécutable soit généré dans `$GOPATH/bin`, utilisez `go install` ou `go build -o ${VOTRE_CHEMIN}/a.exe.`
- S'il y a plusieurs fichiers dans le dossier, mais que vous voulez juste compiler un d'entre eux, ajoutez le nom de ce fichier après `go build`.
Par exemple, `go build a.go`. `go build` va compiler les fichiers dans ce dossier.
- Vous pouvez également définir le nom du fichier généré. Par exemple, dans le projet `mathapp` (section 1.2), lancer `go build -o astaxie.exe` va générer `astaxie.exe` au lieu de `mathapp.exe`.
Le nom par défaut est le nom du dossier (package nom `main`) ou celui du premier fichier source (paquet `main`).

(D'après [Les Spécifications du Langage Go](https://golang.org/ref/spec), les noms de paquets devraient être ceux suivant la déclaration `package` en première ligne de vos fichiers sources.
Cela n'a pas à être le même que celui du dossier, et que le nom de fichier de l'exécutable soit celui du dossier par défaut.)

- `go build` ignore les fichiers dont le nom commence par `_` ou `.`.
- Si vous voulez avoir différents fichiers sources par système d'exploitation, vous pouvez nommer vos fichiers avec pour suffixe le nom du système.
Supposez qu'il y ait plusieurs fichiers pour charger des tableaux. Ces fichiers peuvent être nommés comme suit:
	
    array_linux.go | array_darwin.go | array_windows.go | array_freebsd.go
	
`go build` choisira celui qui correspondra à votre système d'exploitation. Par exemple, seul sera compilé `array_linux.go` sous Linux,
les autres seront ignorés.

## go clean

Cette commande sert à supprimer les fichiers générés par le compilateur, comprenant les fichiers suivants:
	
	_obj/            // Ancien dossier objet, créé par les Makefiles
	_test/           // Ancien dossier test, créé par les Makefiles
	_testmain.go     // Ancien dossier de gotest, créé par les Makefiles
	test.out         // Ancien fichier de test, créé par les Makefiles
	build.out        // Ancien fichier de test, créé par les Makefiles
	*.[568ao]        // fichiers objets, créés par les Makefiles

	DIR(.exe)        // généré par go build
	DIR.test(.exe)   // généré par go test -c
	MAINFILE(.exe)   // généré par go build MAINFILE.go
	
J'utilise généralement cette commande pour supprimer les fichiers avant de mettre à jour mon projet sur Github.
Ils sont utiles lors de tests en local, mais inutiles à avoir dans votre système de gestion de version.

## go fmt

Les développeurs C/C++ doivent avoir l'habitude des débats sur quelle convention d'écriture de code est la meilleure: le style K&R ou ANSI.
Avec Go, il n'existe qu'une convention à appliquer. Par exemple, les parenthèses ouvrantes doivent être en fin de ligne, et ne peuvent être sur une ligne toutes seules,
sinon vous aurez des erreurs à la compilation!

Par chance, vous n'avez pas à retenir toutes ces règles.
`go fmt` le fait à votre place. exécutez simplement `go fmt <File name>.go` dans un terminal.
Je n'utilise pas souvent cette commande car les IDE l'exécutent normalement automatiquemennt lorsque vous sauvegardez un fichier.
Nous reviendrons sur les IDE dans la section suivante.

On utilise généralement `gofmt -w` au lieu de `go fmt`.
Ce dernier ne modifie pas vos fichiers source après formattage. `gofmt -w src` formatte tout votre projet.

## go get

Cette commande récupère des paquets distants. Sont supportés BitBucket, GitHub, Google Code et Launchpad.
Il se passe en fait deux choses à l'exécution de cette commande.
En premier lieu, Go télécharge le code source, puis il exécute `go install`.
Avant d'utiliser cette commande, assurez-vous d'installer les outils nécessaires.

	BitBucket (Mercurial Git)
	GitHub (git)
	Google Code (Git, Mercurial, Subversion)
	Launchpad (Bazaar)
	
Pour utiliser cette commande, vous devez installer ces outils correctement.
N'oubliez pas de définir votre `$PATH`.
Notez que `go get` supporte également vos noms de domaine personnalisés. Exécutez `go help remote` pour en connaître les détails.

## go install

Cette commande compile tous les paquets et génére les fichiers, puis les déplace dans `$GOPATH/pkg` ou `$GOPATH/bin`.

## go test

Cette commande charge tous les fichiers qui ont pour nom `*_test.go` et génére les fichiers de test, puis affiche des informations similaires à celles-ci.

	ok   archive/tar   0.011s
	FAIL archive/zip   0.022s
	ok   compress/gzip 0.033s
	...
	
Elle teste tous vos fichiers de test par défaut. Utilisez la commande `go help testflag` pour plus de détails.

## go doc

Beaucoup de personnes disent qu'il est inutile d'avoir une quelconque documentation tiers pour programmer en Go
(bien qu'en fait j'ai déjà développé [CHM](https://github.com/astaxie/godoc)).
Go a par défaut un outil très élaboré pour travailler avec la documentation.

Alors comment rechercher des informations sur un paquet dans la documentation? Par exemple, si vous voulez plus d'informations sur le paquet `builtin`,
utilisez la commande `go doc builtin`.
De la même manière, utilisez la commande `go doc net/http` pour rechercher la documentation du paquet `http`.
Si vous voulez plus de détails spécifiques à une fonction, utilisez `godoc fmt Printf`, ou `godoc -src fmt Printf` pour voir le code source.

Exécutez la commande `godoc -http=:8080`, puis ouvrez `127.0.0.1:8080` dans votre navigateur. Vous devriez voir un `golang.org` local.
Il peut non seulement afficher les informations des paquets standards, mais aussi les paquets de votre dossier `$GOPATH/pkg`.
C'est très bien pour ceux bloqués derrière la Grande Muraille de Chine.

## Autres commandes

Go fournit d'autres commandes que celles vues précédemment:

	go fix     // mise à jour du code d'une version antérieure
             // à go1 vers une version plus récente que go1
	go version // obtenir des informations sur votre version de Go
	go env     // afficher vos variables d'environnement Go
	go list    // lister tous les paquets installés
	go run     // compiler les fichiers temporaires et lancer l'application
	
Les commandes que l'on a vues proposent également plus d'options que ce que nous avons vu. Vous pouvez utiliser `go help <command>` pour les visualiser.

## Navigation

- [Table des matières](preface.md)
- Section précédente: [$GOPATH et workspace](01.2.md)
- Section suivante: [Outils de développement Go](01.4.md)