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

# 1.2 $GOPATH et workspace

## $GOPATH

Les commandes Go reposent sur une variable d'environnement nommée $GOPATH<sup>1</sup>. Notez que ce n'est pas la variable $GOROOT où Go est installé.
Cette variable pointe vers votre espace de travail(workspace) Go de votre ordinateur (J'utilise ce chemin sur mon ordinateur; si vous n'utilisez pas
la même structure de dossiers, veillez à le faire correspondre par vous-même).

Dans un système de type Unix, la variable peut-être configurée comme suit:
	
    export GOPATH=/home/apple/mygo

Pour plus de commodité, vous devriez ajouter une ligne à votre .bashrc ou .zshrc, ou tout autre fichier de configuration de configuration du shell approprié.
	
Sous Windows, vous devez créer une variable d'environnement nommée GOPATH, et définir sa valeur à `c:\mygo`:

    GOPATH=c:\mygo 

Il est possible d'avoir plusieurs répertoires dans votre $GOPATH, à séparer par un `:` sous Unix, et `;` sous Windows

Dans votre $GOPATH vous devez avoir trois sous-répertoires:

* `src` pour héberger le code source (par exemple: .go .c .h .s, etc.)
* `pkg` pour les fichiers compilés (par exemple: .a)
* `bin` pour les fichiers exécutable compilés

Dans le reste de ce livre, j'utilise le dossier `Mygo` comme répertoire de mon $GOPATH.

## Dossier de paquets

Créez les fichiers et dossiers d'un paquet source comme `$GOPATH/src/mymath/sqrt.go` (`mymath` est le nom du paquet)

Chaque fois que vous créez un paquet, vous devriez créer un nouveau dossier dans le répertoire `src`.
Les noms de dossiers correspondent généralement à celui du paquet que vous souhaitez utiliser.
Vous pouvez avoir plusieurs niveaux de dossiers si vous le désirez.
Par exemple si vous créez le dossier `$GOPATH/src/github.com/astaxie/beedb`, alors le chemin du paquet sera `github.com/astaxie/beedb`.
Le nom du paquet sera celui du dernier dossier de votre chemin, qui est `beedb` dans notre exemple.

Exécutez les commandes suivantes:

	cd $GOPATH/src
	mkdir mymath
	
Créez un nouveau fichier `sqrt.go`, ajoutez le contenu suivant à celui-ci:

	// Code source de $GOPATH/src/mymath/sqrt.go
	package mymath
	
	func Sqrt(x float64) float64 {
		z := 0.0
		for i := 0; i < 1000; i++ {
			z -= (z*z - x) / (2 * x)
		}
		return z
	}
	
Maintenant le dossier de mon paquet a été créé et son code écrit. Je vous recommande d'utiliser le même nom pour vos paquets et leurs dossiers,
et que les dossiers contiennent tous les fichiers sources du paquet.

## Compilation des paquets

Nous avons créé notre paquet précédemment, mais comment le compiler pour un usage concret? Il y a deux méthodes différentes.

1. Placez-vous dans le dossier contenant votre paquet, puis exécutez la commande `go install`.
2. Exécutez la commande précédente mais en passant un nom de fichier en paramètre, comme `go install mymath`.

Après compilation, on peut ouvrir le dossier suivant:

	cd $GOPATH/pkg/${GOOS}_${GOARCH}
	// On peut y trouver le fichier compilé
	mymath.a
	
Le fichier dont le suffixe est `.a` est le fichier binaire de notre paquet. Comment l'utiliser?

Assurément, nous devons créer une application pour l'utiliser.

Créez un nouveau paquet appelé `mathapp`.

	cd $GOPATH/src
	mkdir mathapp
	cd mathapp
	vim main.go
	
Le code de `main.go`

	//code source de $GOPATH/src/mathapp/main.go.
	package main
	
	import (
		"mymath"
		"fmt"
	)
	
	func main() {
		fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))
	}
	
Pour compiler cette application, vous devez vous placer dans le dossier du paquet

    cd $GOPATH/src/mathapp

puis exécutez

    go install

Vous devriez désormais voir un fichier exécutable `mathapp` généré dans le dossier `$GOPATH/bin/`.
Pour lancer ce programme, utilisez la commande

    ./mathapp

Vous devriez voir le contenu suivant dans votre temrinal:

    Hello world. Sqrt(2) = 1.414213562373095
	
## Installer des paquets distants

Go a un outil pour installer des paquets distants, qui est l'outil `go get`.Il supporte la majorité des communautés libres, comme
GitHub, Google Code, BitBucket, et Launchpad.

    go get github.com/astaxie/beedb

>Vous pouvez utiliser `go get -u` pour mettre à jour vos paquets distants, cela mettra aussi à jour les dépendances.

Vous obtiendrez le code source des paquets désirés grâce à cette commande, depuis différentes plate-formes, utilisant chacune leur système de gestion de version.
Par exemple, `git` pour GitHub et `hg` pour Google Code. Ainsi vous devrez au préalable installer le client du système de gestion de version approprié
avant d'utiliser`go get`.

Après avoir utilisé les commandes précédentes, votre structure de dossier devrait ressembler à celle-ci:

	$GOPATH
		src
		 |-github.com
		 	 |-astaxie
		 	 	 |-beedb
		pkg
		 |--${GOOS}_${GOARCH}
		 	 |-github.com
		 	 	 |-astaxie
		 	 	 	 |-beedb.a

En fait, `go get` clone le source code dans le dossier $GOPATH/src en local, puis exécute `go install`.

Vous pouvez utiliser des paquets distants de manière similaire aux paquets locaux.

	import "github.com/astaxie/beedb"
	
##  Arborescence complète de dossier

Si vous avez suivi toutes les étapes précédentes, la structure de votre dossier ressemble désormais à ceci:

	bin/
		mathapp
	pkg/
		${GOOS}_${GOARCH}, such as darwin_amd64, linux_amd64
      mymath.a
      github.com/
        astaxie/
          beedb.a
	src/
		mathapp
			main.go
		mymath/
			sqrt.go
		github.com/
			astaxie/
				beedb/
					beedb.go
					util.go
					
Vous pouvez désormais vous rendre compte de manière plus claire de l'arborescence; `bin` contient les exécutables, `pkg` les fichiers compilés et
`src` les paquets sources.

 - - -
[1] Le format des variables d'environnement sous Windows est `%GOPATH%`, pourtant ce livre suit principalement la norme Unix,
les utilisateurs Windows devront faire les modifications appropriées.

## Navigation

- [Table des matières](preface.md)
- Section précédente: [Installation](01.1.md)
- Section suivante: [Go commands](01.3.md)