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

# Outils de développement Go

Dans cette section, je vais vous présenter quelques IDE qui peuvent vous aider à coder plus efficacement, grâce à des fonctionnalités telles la complétion de code et le formattage automatiques.
Ils sont tous multi-plate-formes, les manipulations présentées ne devraient donc pas être très éloignées, même si vous n'utilisez pas le même système d'exploitation.

## LiteIDE

LiteIDE est un IDE léger et multi-plate-formes dédié uniquement au développement en Go, développé par visualfc.

![](images/1.4.liteide.png?raw=true)

Figure 1.4 Panneau principal de LiteIDE

Fonctionnalités de LiteIDE:

- Multi-plate-formes
	- Windows
	- Linux
	- Mac OS
- Compilation croisée
	- Gestion d'environnements de compilation multiples
	- Support de la compilation croisée avec Go
- Standards en gestion de projet
	- Documentation basée sur le $GOPATH
	- Compilation basée sur le $GOPATH
	- Index la documentation de l'API basée sur le $GOPATH
- Éditeur de code source Go
	- Mise en forme du code
	- Support complet de gocode
	- Gestion de la documentation and et de l'index de l'API de Go
	- Afficher l'expression d'un code via `F1`
	- Naviguer entre déclaration de fonctions via `F2`
	- Support Gdb
	- Auto-formattage via `gofmt`
- Autres
	- Multi-langues
	- Système d'extensions
	- Thèmes d'éditeur de texte
	- Support dela syntaxe basé sur Kate
	- Complétion intelligente basée en mode full-text
	- Personnalisation des raccourcis
	- Support Markdown
		- Prévisualisation en temps réel
		- CSS personnalisé
		- Exportation en HTML et PDF
		- Conversion et fusion en HTML et PDF
		
### Installation de LiteIDE

- Installer LiteIDE
	- [Page de téléchargement](http://code.google.com/p/golangide)
	- [Code source](https://github.com/visualfc/liteide)
	
    Vous devez installer Go en premier, puis télécharger la version adaptée à votre système d'exploitation. Décompressez le paquet pour ensuite l'exécuter directement.

- Installer gocode

    Vous devez installer gocode pour utiliser la complétion intelligente
	
		go get -u github.com/nsf/gocode
		
- Environment de compilation

	Changer de configuration de LiteIDE pour correspondre à votre système d'exploitation
  Dans Windows avec la version 64-bit de Go, vous devriez utiliser win64 comme configuration de votre environnement dans la barre d'outils.
  Ensuite, choisissez `Options`, puis `LiteEnv` dans la liste de gauche et sélectionnez le fichier `win64.env` dans la liste de droite.
	
		GOROOT=c:\go
		GOBIN=
		GOARCH=amd64
		GOOS=windows
		CGO_ENABLED=1

		PATH=%GOBIN%;%GOROOT%\bin;%PATH%
		。。。
	
	Modifiez `GOROOT=c:\go` par le chemin de votre installation Go, puis sauvegardez. Si vous avez MinGW64, ajoutez `c:\MinGW64\bin` au chemin de votre variable d'environnement pour le support de `cgo`.

  Pour Linux avec Go en version 64-bit, choisissez linux64 comme configuration de votre environnement dans la barre d'outils.
  Ensuite, choisissez `Options`, puis `LiteEnv` dans la liste de gauche et sélectionnez le fichier `linux64.env` dans la liste de droite.
	
		GOROOT=$HOME/go
		GOBIN=
		GOARCH=amd64
		GOOS=linux
		CGO_ENABLED=1

		PATH=$GOBIN:$GOROOT/bin:$PATH
		。。。
		
	Modifiez `GOROOT=$HOME/go` par le chemin de votre installation Go.

- $GOPATH

	$GOPATH est le chemin du dossier de vos projets. Ouvrez l'outil commande (`Ctrl+` dans LiteIDE), puis tapez `go help gopath` pour plus de détails.
  C'est très simple de voir et modifier votre $GOPATH dans LiteIDE. Choisissez `View - Setup GOPATH` pour voir et modifier ces valeurs.
	
## Sublime Text

Dans cette partie je vais vous présenter Sublime Text 2 (Sublime tout court) + GoSublime + gocode + MarGo.

- Complétion Intelligente

	![](images/1.4.sublime1.png?raw=true)
	
	Figure 1.5 Complétion intelligente avec Sublime

- Auto-formattage du code source
- Gestion de projet

	![](images/1.4.sublime2.png?raw=true)
	
	Figure 1.6 Gestion de projet sous Sublime

- Coloration syntaxique
- Version gratuite d'essai permanente sans limitation de fonctionnalités. Vous serez invité de temps en temps à acheter une licence, que vous pourrez refuser si vous voulez.
  Bien sûr, si vous trouvez que Sublime augmente votre productivité et que vous l'appréciez vraiment, merci d'acheter une licence et de supporter son développement!

Commencez par télécharger une version de [Sublime](http://www.sublimetext.com/) adaptées à votre système d'exploitation.

1. Tapez `Ctrl+`, ouvrez l'invite de commandes et rentrez les commandes suivantes:.

		import urllib2,os; pf='Package Control.sublime-package'; ipp=sublime.installed_packages_path(); os.makedirs(ipp) if not os.path.exists(ipp) else None; urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler())); open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read()); print 'Merci de redémarrer Sublime Text pour finaliser l'installation'
		
	Redémarrez Sublime text en fin d'installation. Vous devriez trouvez une option `Package Control` dans le menu "Preferences".
	
	![](images/1.4.sublime3.png?raw=true)
	
	Figure 1.7 Gestion de paquet dans Sublime

2. Pour installer GoSublime, SidebarEnhancements et Go Build, tapez `Ctrl+Shift+p` pour ouvrir Package Control, puis tapez `pcip` (raccourci pour "Package Control: Install Package").

	![](images/1.4.sublime4.png?raw=true)
	
	Figure 1.8 Installer des paquets sous Sublime
	
	Puis tapez "GoSublime", entrez OK pour installer le paquet, et répétez ces commandes pour installer SidebarEnhancements et Go Build.
  À nouveau, redémarrez l'éditeur quand l'installation s'achève.

3. Pour vérifier la réussite de l'installation, ouvrez Sublime, puis ouvrez le fichier `main.go` pour vérifier que la coloration syntaxique est correcte.
Tapez `import` pour voir si le prompt de la complétion de code s'affiche. Après avoir tapé `import "fmt"`, tapez `fmt.` juste après `import` pour voir si oui ou non la complétion intelligente de code
des fonctions a été activée avec succès.

	Si tout fonctionne correctement, vous êtes prêt.
	
	Sinon, vérifiez à nouveau votre $PATH. Ouvrez un terminal, tapez `gocode`. S'il ne s'exécute pas, votre $PATH n'est pas configuré correctement.
	
## Vim

Vim est un éditeur très populaire chez les programmeurs, qui est une évolution de son prédécesseur, Vi.
Il a des fonctionnalités de complétion intelligente, compilation et navigation entre les erreurs.

![](images/1.4.vim.png?raw=true)
	
Figure 1.8 Complétion intelligente pour Go sous Vim

1. Coloration syntaxique sous Go

		cp -r $GOROOT/misc/vim/* ~/.vim/
		
2. Activer la coloration syntaxique

		filetype plugin indent on
		syntax on
		
3. Installer [gocode](https://github.com/nsf/gocode/)

		go get -u github.com/nsf/gocode
		
	gocode sera installé dans `$GOBIN` par défaut

4. Configurer [gocode](https://github.com/nsf/gocode/)

		~ cd $GOPATH/src/github.com/nsf/gocode/vim
		~ ./update.bash
		~ gocode set propose-builtins true
		propose-builtins true
		~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
		lib-path "/home/border/gocode/pkg/linux_amd64"
		~ gocode set
		propose-builtins true
		lib-path "/home/border/gocode/pkg/linux_amd64"
		
	Explications sur la configuration de gocode:
	
	propose-builtins: active ou non la complétion automatique; faux par défaut.

	lib-path: gocode cherche uniquement les paquets dans `$GOPATH/pkg/$GOOS_$GOARCH` et `$GOROOT/pkg/$GOOS_$GOARCH`.
  Ce paramètre peut-être utilisé pour ajouter des chemins additionnels.

5. Félicitations! lancez `:e main.go` pour explorer le monde de Go!

## Emacs

Emacs est l'arme fatale. Ce n'est pas seulement un éditeur, mais aussi un IDE très puissant.

![](images/1.4.emacs.png?raw=true)

Figure 1.10 Panneau principal de l'éditeur Go d'Emacs

1. Coloration syntaxique
	
		cp $GOROOT/misc/emacs/* ~/.emacs.d/
		
2. Installer [gocode](https://github.com/nsf/gocode/)

		go get -u github.com/nsf/gocode
		
	gocode sera installé dans `$GOBIN` par défaut

3. Configurer [gocode](https://github.com/nsf/gocode/)

		~ cd $GOPATH/src/github.com/nsf/gocode/vim
		~ ./update.bash
		~ gocode set propose-builtins true
		propose-builtins true
		~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
		lib-path "/home/border/gocode/pkg/linux_amd64"
		~ gocode set
		propose-builtins true
		lib-path "/home/border/gocode/pkg/linux_amd64"
		
4. Installer l'[Auto Completion](http://www.emacswiki.org/emacs/AutoComplete)

  Téléchargement et décompression
	
		~ make install DIR=$HOME/.emacs.d/auto-complete
	
	Configurer ~/.emacs file
	
		;;auto-complete
		(require 'auto-complete-config)
		(add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict")
		(ac-config-default)
		(local-set-key (kbd "M-/") 'semantic-complete-analyze-inline)
		(local-set-key "." 'semantic-complete-self-insert)
		(local-set-key ">" 'semantic-complete-self-insert)	
		
	Cliquez ce [lien](http://www.emacswiki.org/emacs/AutoComplete) pour plus de détails.

5. Configurer .emacs

		;; golang mode
		(require 'go-mode-load)
		(require 'go-autocomplete)
		;; speedbar
		;; (speedbar 1)
		(speedbar-add-supported-extension ".go")
		(add-hook
		'go-mode-hook
		'(lambda ()
    		;; gocode
    		(auto-complete-mode 1)
    		(setq ac-sources '(ac-source-go))
    		;; Imenu & Speedbar
    		(setq imenu-generic-expression
        		'(("type" "^type *\\([^ \t\n\r\f]*\\)" 1)
        		("func" "^func *\\(.*\\) {" 1)))
    		(imenu-add-to-menubar "Index")
    		;; Outline mode
    		(make-local-variable 'outline-regexp)
    		(setq outline-regexp "//\\.\\|//[^\r\n\f][^\r\n\f]\\|pack\\|func\\|impo\\|cons\\|var.\\|type\\|\t\t*....")
    		(outline-minor-mode 1)
    		(local-set-key "\M-a" 'outline-previous-visible-heading)
    		(local-set-key "\M-e" 'outline-next-visible-heading)
    		;; Menu bar
    		(require 'easymenu)
    		(defconst go-hooked-menu
        		'("Go tools"
        		["Go run buffer" go t]
        		["Go reformat buffer" go-fmt-buffer t]
        		["Go check buffer" go-fix-buffer t]))
    		(easy-menu-define
        		go-added-menu
        		(current-local-map)
        		"Go tools"
        		go-hooked-menu)

    		;; Other
    		(setq show-trailing-whitespace t)
    		))
		;; helper function
		(defun go ()
    		"run current buffer"
    		(interactive)
    		(compile (concat "go run " (buffer-file-name))))

		;; helper function
		(defun go-fmt-buffer ()
    		"run gofmt on current buffer"
    		(interactive)
    		(if buffer-read-only
    		(progn
        		(ding)
        		(message "Buffer is read only"))
    		(let ((p (line-number-at-pos))
    		(filename (buffer-file-name))
    		(old-max-mini-window-height max-mini-window-height))
        		(show-all)
        		(if (get-buffer "*Go Reformat Errors*")
    		(progn
        		(delete-windows-on "*Go Reformat Errors*")
        		(kill-buffer "*Go Reformat Errors*")))
        		(setq max-mini-window-height 1)
        		(if (= 0 (shell-command-on-region (point-min) (point-max) "gofmt" "*Go Reformat Output*" nil "*Go Reformat Errors*" t))
    		(progn
        		(erase-buffer)
        		(insert-buffer-substring "*Go Reformat Output*")
        		(goto-char (point-min))
        		(forward-line (1- p)))
    		(with-current-buffer "*Go Reformat Errors*"
    		(progn
        		(goto-char (point-min))
        		(while (re-search-forward "<standard input>" nil t)
        		(replace-match filename))
        		(goto-char (point-min))
        		(compilation-mode))))
        		(setq max-mini-window-height old-max-mini-window-height)
        		(delete-windows-on "*Go Reformat Output*")
        		(kill-buffer "*Go Reformat Output*"))))
		;; helper function
		(defun go-fix-buffer ()
    		"run gofix on current buffer"
    		(interactive)
    		(show-all)
    		(shell-command-on-region (point-min) (point-max) "go tool fix -diff"))

6. Félicitations,vous avez fini! Speedbar est fermé par défaut - décommentez `;;(speedbar 1)` pour activer cette fonctionnalité, ou vous pouvez l'utiliser via `M-x speedbar`.

## Eclipse

Eclipse est aussi un très bon outil de développement. Je vais vous montrer comment l'utiliser pour écrire des programmes Go.

![](images/1.4.eclipse1.png?raw=true)

Figure 1.1 Panneau principal d'Eclipse pour développer en Go

1. Téléchargez et installez [Eclipse](http://www.eclipse.org/)
2. Téléchargez [goclipse](https://code.google.com/p/goclipse/)

	[Instructions d'installation](https://github.com/GoClipse/goclipse/blob/latest/documentation/Installation.md#installation)
3. Téléchargez gocode

	gocode sur Github.
	
		https://github.com/nsf/gocode
		
  Vous devez installer git sous Windows, généralement via [msysgit](http://msysgit.github.io/)
	
	Installer gocode en ligne de commandes
	
		go get -u github.com/nsf/gocode
		
	Vous pouvez l'installer depuis les sources si vous préférez.
  .
4. Téléchargez et installez [MinGW](http://sourceforge.net/projects/mingw/files/MinGW/)
5. Configurez les extensions.

	Windows->Préférences->Go
	
	(1).Configurez le compilateur Go
	
	![](images/1.4.eclipse2.png?raw=true)
	
	Figure 1.12 Paramètres Go dans Eclipse
	
	(2).Configurez gocode(optionnel), paramètrez le chemin gocode vers l'emplacement de gocode.exe.
	
	![](images/1.4.eclipse3.png?raw=true)
	
	Figure 1.13 Paramètres gocode
	
	(3).Configurez gdb(optionnell), paramètrez le chemin de gdb vers l'emplacement de gdb.exe.
	
	![](images/1.4.eclipse4.png?raw=true)
	
	Figure 1.14 Paramètre gdb

6. Vérifiez l'installation

  Créez un nouveau projet Go et un fichier hello.go comme suit.
	
	![](images/1.4.eclipse5.png?raw=true)
	
	Figure 1.15 Créez un nouveau projet et fichier.
	
  Testez l'installation comme suit (Vous avez besoin de taper la commande dans la console d'Eclipse).
	
	![](images/1.4.eclipse6.png?raw=true)
	
	Figure 1.16 Testez Go depuis Eclipse

## IntelliJ IDEA

Les développeurs Java sont familiers de cet IDE. Il supporte la coloration syntaxique et la complétion intelligente de code sous Go, via une extension.

1. Téléchargez IDEA, il n'y a aucune différence entre les éditions Ultimate et Community

	![](images/1.4.idea1.png?raw=true)
	
2. Installer l'extension Go. Choisissez `File - Setting - Plugins`, puis `Browser repo`.

	![](images/1.4.idea3.png?raw=true)
	
3. Cherchez `golang`, double-cliquez `download and install` et patientez jusqu'à la fin du téléchargement.

	![](images/1.4.idea4.png?raw=true)
	
	Cliquez `Apply`, puis redémarrez.
4. Maintenant vous pouvez créer un projet Go.

	![](images/1.4.idea5.png?raw=true)

  Entrez le chemin de votre sdk Go dans l'étape suivante - qui correspond à votre $GOROOT.
	
## Navigation

- [Table des matières](preface.md)
- Section précédente: [Commandes Go](01.3.md)
- Section suivante: [Résumé](01.5.md)