Herramientas de desarrollo para Go

En esta sección, les voy a mostrar algunos IDEs que tienen la habilidad de completar y dar formato de manera inteligente. Ellos son multiplataforma, por esto algunos de los pasos que vamos a mostrar no deberían ser muy diferentes si no estas utilizando el mismo sistema operativo.

LiteIDE

LiteIDE es un IDE de código abierto, liviano para el desarrollo unicamente de proyectos creados con Go, desarrollado por visualfc.

Imagen 1.4 Panel principal de LiteIDE

Características de LiteIDE.

Multiplataforma
- Windows
- Linux
- Mac OS
Compilación cruzada
- Maneja un entorno para la compilación múltiple
- Soporta la compilación cruzada de Go
Manejo de proyectos estándar
- Vista de la documentación basado en el $GOPATH
- Sistema de compilación basado en el $GOPATH
- Documentación de la API ordenada por índice basada en el $GOPATH
Editor de código fuente en Go
- Esquematización de código
- Soporte completo para gocode
- Vista de la documentación de Go e índice de la API
- Vista del código por medio de F1
- Salto entre declaración de funciones con F2
- Soporte para Gdb
- Auto-formato con gofmt
Otros
- Multi-lenguage
- Sistema de plugin
- Temas para el editor de texto
- Soporte para la sintaxis basado en Kate
- Completado inteligente basado en full-text
- Configuración de atajos
- Soporte para formato
  - Vista previa en tiempo real
  - Configuración por CSS
  - Exportar en HTML y PDF
  - Convertir y unir en HTML y PDF

LiteIDE instalación

Instalar LiteIDE
- Página de descarga
- Código fuente
Va a necesitar instalar antes Go, entonces descargue la versión para su sistema operativo. Descomprima el archivo para poder usarlo directamente.
Instalar gocode

Debe instalar gocode para poder utilizar el auto-completado inteligente
```
  go get -u github.com/nsf/gocode
```
Entorno para la compilación

Cambie la configuración en LiteIDE para ajustar su sistema operativo. En Windows y la versión de 64-bit para Go, usted debería elegir su entorno win64 en la barra de configuración para el entorno. Entonces elija opinion, busque LiteEnv en la lista de la izquierda, abra el archivo win64.env en la lista derecha.
```
  GOROOT=c:\go
  GOBIN=
  GOARCH=amd64
  GOOS=windows
  CGO_ENABLED=1

  PATH=%GOBIN%;%GOROOT%\bin;%PATH%
  。。。
```
Reemplace GOROOT=c:\go por el PATH de su instalación de Go y guardela. Si tiene MinGW64, agregue c:\MinGW64\bin en el PATH de su variable de entorno para soportar cgo.

En Linux y versiones de 64-bit para Go, debería elegir linux64 en la opción de configuración de la barra de herramienta. Entonces elija opinion, busque LiteEnv en la lista izquierda, abra el archivo linux64.env en la lista derecha.
```
  GOROOT=$HOME/go
  GOBIN=
  GOARCH=amd64
  GOOS=linux
  CGO_ENABLED=1

  PATH=$GOBIN:$GOROOT/bin:$PATH   
  。。。
```
Reemplace GOROOT=$HOME/go por el PATH de su instalación de GO y guárdelo.
$GOPATH $GOPATH es la ruta que contiene la lista de proyectos, abra la herramienta de comandos (o presione Ctrl+ en LiteIDE) entonces tipee go help gopath para más detalles. Es muy sencillo para ver y modificar el $GOPATH en el LiteIDE. Vaya a View - Setup GOPATH para ver y modificar este valor.

Sublime Text

Aquí los voy a introducir a ver Sublime Text 2 (solo Sublime para abreviar) + GoSublime + gocode + MarGo. Déjeme explicarles porque.

Auto-completado inteligente

Imagen 1.5 Completado inteligente en Sublime
Auto-formateado de los archivos fuentes
Manejo del proyecto

Imagen 1.6 Manejo del proyecto en Sublime
Resaltado de sintaxis
Versión gratuita de pruebas por siempre, sin funcionalidades limitadas. Aunque les va a mostrar un pop-up cada cierto tiempo recordándonos de que no nos hemos registrado, pero usted solo puede ignorarlo.

Primero, descargue la versión de Sublime y elija la versión para su sistema operativo.

Presione Ctrl+ ` para abrir la herramienta de comandos, eh ingrese el siguiente comando.

 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 'Please restart Sublime Text to finish installation'

Reinicie cuando termine la instalación. Entonces va a poder encontrar la opción de Package Control como un ítem en el menú de preferencias.

Imagen 1.7 Control de paquete en Sublime

Para instalar GoSublime, SidebarEnhancements y Go Build, presione Ctrl+Shift+p para abrir la herramienta Package Control, entonces tipee pcip (abreviación para "Package Control: Install Package").

Imagen 1.8 Instalación de paquetes en Sublime

Ahora va a poder tipear GoSublime, presione OK para instalar, siga los mismos pasos para instalar SidebarEnhancements y Go Build. Reinicie cuando termine la instalación.
Para verificar que se instalo todo correctamente, abra Sublime, entonces abra el archivo main.go para ver si tiene el resaltado de sintaxis, tipee import para ver la ayuda import "fmt", luego tipee fmt. Para ver si tiene las funciones de completado inteligente.

Si todo esta bien, entonces ya esta todo configurado.

Si no, verifique su $PATH nuevamente. Abra una terminal, tipee gocode, si no puede ejecutarlo, su $PATH no debe estar configurado correctamente.

Vim

Vim es un popular editor de texto para programadores, que fue desarrollado a partir del editor vi. Tiene funciones para el completado inteligente, compilación y resaltado de errores.

Imagen 1.8 Completado inteligente de Vim para Go

Resaltado de sintaxis para Go
```
 cp -r $GOROOT/misc/vim/* ~/.vim/
```
Configuración del resaltado de sintaxis
```
 filetype plugin indent on
 syntax on
```
Instalar gocode
```
 go get -u github.com/nsf/gocode
```
gocode va a ser instalado en $GOBIN por defecto

Configuración de 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"

Explicación de la configuración de gocode.

propose-builtins: Completado inteligente o no, false es el valor por defecto.

lib-path: gocode solo busca los paquetes en $GOPATH/pkg/$GOOS_$GOARCH y $GOROOT/pkg/$GOOS_$GOARCH, en esta configuración se pueden agregar otras rutas adicionales.

Felicitaciones! Pruebe ejecutar :e main.go para experimentar el mundo de Go!

Emacs

Emacs llamado muchas veces el armar de Dios. Este no es solo un editor, también puede ser un IDE muy poderoso.

Imagen 1.10 Panel principal del editor de Emacs para Go

Resaltado de sintaxis
```
 cp $GOROOT/misc/emacs/* ~/.emacs.d/
```
Instalar gocode
```
 go get -u github.com/nsf/gocode
```
gocode va a ser instalado por defecto en $GOBIN

Configurar 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"

Instalar Auto Completado Descargue y descomprima

 ~ make install DIR=$HOME/.emacs.d/auto-complete

Configure el archivo ~/.emacs

 ;;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)

Siga el siguiente link para más detalles.

Configure el archivo .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"))

Felicitaciones! speedbar esta cerrado por defecto, quite los símbolos de comentarios en la linea ;;(speedbar 1) para tener esta característica, o puede realizarlo a través del comando M-x speedbar.

Eclipse

Eclipse es otra gran herramienta de desarrollo, le voy a mostrar como utilizarla para escribir programas en Go.

Imagen 1.1 Panel principal del editor de Eclipse para Go

Descargue e instale Eclipse
Descargue goclipse http://code.google.com/p/goclipse/wiki/InstallationInstructions
Descargue gocode

gocode en Github.
```
 https://github.com/nsf/gocode
```
Va a necesitar instalar git en Windows, normalmente usamos msysgit

Instalar gocode desde la linea de comandos
```
 go get -u github.com/nsf/gocode
```
Puede instalarlo desde el código fuente si lo desea.
Descargue e instale MinGW
Configure los plugins.

Windows->Preferences->Go

(1).Configuración del compilador de Go

Imagen 1.12 Configuración de Go en Eclipse

(2).Configuración de gocode(opcional), configure el path de donde tenga el archivo gocode.exe.

Imagen 1.13 Configuración de gocode

(3).Configuración de gdb(opcional), configure el path de gdb donde se encuentre el archivo gdb.exe.

Imagen 1.14 Configuración de gdb
Verifique la instalación

Cree un nuevo proyecto Go y un archivo hello.go como el siguiente.

Imagen 1.15 Cree un nuevo proyecto y archivo

Testee la instalación de la siguiente forma.(necesita tipear estos comandos en la consola de Eclipse)

Imagen 1.16 Testeo de programas Go en Eclipse

IntelliJ IDEA

Las personas que trabajan con Java deben estar familiarizados con este IDE, el mismo soporta el resaltado de sintaxis para Go, auto-completado y mas por medio de plugins.

Descargue el IDE, no hay diferencia entre la versión Ultimate y la Community Edition
Instale el plugin para Go. Elija File - Setting - Plugins, y entonces haga click en Browser repo.
Busque golang, realice doble click en download and install, espere a que termine la descarga.

Realice click en Apply, y entonces reinicie.
Ahora vas a poder crear proyectos Go.

Ingrese la ubicación del SDK de Go en los pasos siguientes, básicamente es su $GOROOT.

( Mire también el post para configurar y utilizar el IntelliJ IDEA con Go paso a paso )

Enlaces

Indice
Sección anterior: Comandos con Go
Siguiente sección: Resumen

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

01.4.md

01.4.md

Herramientas de desarrollo para Go

LiteIDE

LiteIDE instalación

Sublime Text

Vim

Emacs

Eclipse

IntelliJ IDEA

Enlaces

Files

01.4.md

Latest commit

History

01.4.md

File metadata and controls

Herramientas de desarrollo para Go

LiteIDE

LiteIDE instalación

Sublime Text

Vim

Emacs

Eclipse

IntelliJ IDEA

Enlaces