Skip to content

Latest commit

 

History

History
400 lines (312 loc) · 14.2 KB

01.4.md

File metadata and controls

400 lines (312 loc) · 14.2 KB
Raw

Herramientas de Desarrollo para Go

En esta sección les mostraré algunos IDEs que pueden ayudarte a volverte un programador más eficiente, con características cómo completamiento de código inteligente y auto formato. Todos son multi-plataforma, así que los pasos que mostraré no deberían de ser muy diferentes aún en el caso que no estés utilizando el mismo sistema operativo.

LiteIDE

LiteIDE es un IDE de código libre, ligero para programar únicamente proyectos Go, es desarrollado por visualfc.

Imagen 1.4 Panel principal de LiteIDE

Características de LiteIDE

  • Multi-platforma
    • Windows
    • Linux
    • Mac OS
  • Cross-compile
    • Maneja múltiples ambientes de compilación
    • Soporta la compilación para diferentes sistemas
  • Manejo de Proyectos estándar
    • Vista de documentación basada en $GOPATH
    • Sistema de compilación basado en $GOPATH
    • Indice de documentación del API basado en $GOPATH
  • Editor de código fuente Go
    • Delineado de código
    • Soporte completo de gocode
    • Indice del API y vista de la documentaciónd de Go
    • Ver expresiones de código usando F1
    • Saltar a la declaración de funciones usando F2
    • Soporte Gdb
    • Auto-formateo con gofmt
  • Otras
    • Multi-lenguaje
    • Sistema de plugin
    • Temas
    • Soporte de sintaxis basado en Kate
    • Completamiento inteligente basado en texto-completo
    • Atajos configurables (shortcuts)
    • Soporte de Markdown
      • Previsualizar en tiempo real
      • CSS personalizado
      • Exportar HTML y PDF
      • Convertir y unir a HTML y PDF

Instalación de LiteIDE

  • Instalar LiteIDE

    Primeramente debes instalar Go, luego descarga la versión apropiada para tu sistema operativo. Descomprime el paquete para poder usarlo directamente.

  • Instala gocode

    Debes instalar gocode para poder usar el completamiento inteligente

		go get -u github.com/nsf/gocode

  • Entorno de compilación

    Cambia la configuración en LiteIDE para que se ajuste a tu sistema operativo. En Windows y usando al versión de 64-bits de Go, debes usar win64 cómo la configuración de entorno en la barra de herramientas. Luego escoge Options, busca LiteEnv en la lista de la izquierda y abre el archivo win64.env en la lista de la derecha.

		GOROOT=c:\go
		GOBIN=
		GOARCH=amd64
		GOOS=windows
		CGO_ENABLED=1

		PATH=%GOBIN%;%GOROOT%\bin;%PATH%
		。。。
Reemplaza `GOROOT=c:\go` con tu ruta de instalación de Go y guarda. Si tienes MinGW64, agrega `c:\MinGW64\bin` a la variable de entorno de tu path para soportar `cgo`.

En Linux y usando la versiónd de 64-bits de Go, debes escoger linux64 como la configuración de entorno en la barra de herramientas. Luego escoge `Options`, busca `LiteEnv` en la lista de la izquierda y abre el archivo `linux64.env` en la lista de la derecha.
		GOROOT=$HOME/go
		GOBIN=
		GOARCH=amd64
		GOOS=linux
		CGO_ENABLED=1

		PATH=$GOBIN:$GOROOT/bin:$PATH
		。。。
Reemplaza `GOROOT=$HOME/go` con tu ruta de instalación de Go y guarda.
  • $GOPATH $GOPATH es la ruta que contiene la lista de proyectos. Abre la herramienta de comandos (o presiona Ctrl+ en LiteIDE), luego escribe go help gopath para más detalles. Es bien fácil ver y cambiar $GOPATH en LiteIDE.

Sublime Text

Ahora voy a introducir Sublime Text 2 (o simplemente Sublime) + GoSublime + gocode + MarGo. Déjenme explicar el porqué.

  • Completamiento inteligente

    Imagen 1.5 Completamiento inteligente con Sublime

  • Auto-formateo de los archivos de código

  • Manejo de proyectos

    Imagen 1.6 Manjo de proyectos con Sublime

  • Realce de sintaxis

  • Prueba gratis eterna sin limitaciones funcionales. Te recuerda de vez en cuando la compra de una licencia, pero simplemente puedes ignorarla si lo deseas. Por supuesto, si encuentras que realmente mejora tu productividad y realmente disfrutas usarlo, compra una copia y apoya el desarrollo de nuevas versiones!

Primero, descarga la versión de Sublime adecuada para tu sistema operativo.

  1. Presiona Ctrl+, abre la herramienta de comandos e ingresa los siguientes comandos

     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'

    Reinicia Sublime Text cuando la instalación ha finalizado. Luego busca la opción de Package Control en el menú de "Preferences".

    Imagen 1.7 Sublime Package Control

  2. Para instalar GoSublime, SidebarEnhancements y Go Build, presiona Ctrl+Shift+p para abrir Package Control, luego escribe pcip (atajo para "Package Control: Install Package").

    Imagen 1.8 Sublime Install Packages

    Ahora escribe "GoSublime", presiona OK para instalar el paquete y repite los mismos pasos para instalar SidebarEnhancements y Go Build. Una vez más reinicia el editor cuando se complete la instalación.

  3. Para verificar que la instalación fue exitosa, abre Sublime, luego abre el achivo main.go para ver si tiene el realce de sintaxis adecuado, escribe import para ver si el completamiento de código se muestra. Luego de escribir import "fmt", escribe fmt. en cualquier parte luego de la declaración import para ver si el completamiento inteligente de funciones está funcionando.

    Si todo está bien, estamos listos.

    Si no, revisa tu $PATH nuevamente. Abre la terminal, escribe gocode. Si no se ejecuta, tu $PATH no fue configurado correctamente.

Vim

Vim es un editor de texto popular para los programadores, que evolucionó de su predecesor más ligero, Vi. Tiene funciones para completamiento inteligente, compilació y saltar a los errores.

Imagen 1.8 Completamiento inteligente en Vim para Go

  1. Realce de sintaxis para Go
		cp -r $GOROOT/misc/vim/* ~/.vim/
  1. Habilitando el realce de sintaxis
		filetype plugin indent on
		syntax on
  1. Instalar gocode
		go get -u github.com/nsf/gocode
gocode se instalará por defecto en `$GOBIN`
  1. Configura 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: especifica si abrir o no el completamiento inteligente; falso por defecto.
lib-path: gocode solamente busca paquetes en `$GOPATH/pkg/$GOOS_$GOARCH` y `$GOROOT/pkg/$GOOS_$GOARCH`. Esta configuración puede usarse para agregar rutas adicionales.
  1. Felicitaciones! Prueba :e main.go para experimentar el mundo de Go!

Emacs

Emcas es la llamada arma de Dios. No es solamente un editor, sino un poderoso IDE.

Imagen 1.10 Panel principal de Emacs editando Go

  1. Realce de sintaxis
		cp $GOROOT/misc/emacs/* ~/.emacs.d/
  1. Instalar gocode
		go get -u github.com/nsf/gocode
	gocode se instalará por defecto en `$GOBIN`
  1. Configura 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"
  1. Instalar Auto Completion Descarga y descomprime
		~ make install DIR=$HOME/.emacs.d/auto-complete
Configura 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)
Visita este [link](http://www.emacswiki.org/emacs/AutoComplete) para más detalles.
  1. Configura .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"))
  1. Felicitaciones, ya estás listo! Speedbar está cerrada por defecto -remueve los símbolos de comentarios en la línea ;;(speedbar 1) para habilitar esta característica o puedes usarla a través de M-x speedbar.

Eclipse

Eclipse también es una grandiosa herramienta de desarrollo. Te mostraré como usarla para escribir programas en Go.

Imagen 1.1 Panel principal de Eclipse editando Go

  1. Descarga e instalaEclipse

  2. Descarga goclipse http://code.google.com/p/goclipse/wiki/InstallationInstructions

  3. Descarga gocode

    gocode in Github.

     https://github.com/nsf/gocode

    Necesitas instalar git en Windows, usualmente usamos msysgit

    Instala gocode en la herramienta de comandos

		go get -u github.com/nsf/gocode
También puedes instalar desde el código fuente si gustas.

  1. Descarga e instala MinGW

  2. Configura los plugins.

    Windows->Preferences->Go

    (1).Configura el compilador Go

    Imagen 1.12 Configuración de Go en Eclipse

    (2).Configura gocode(opcional), estable la ruta de gocode a dónde se encuentra el archivo gocode.exe

    Imagen 1.13 Configuración gocode

    (3).Configura gdb(opcional), establece la ruta gdb a dónde se encuentra el archivo gdb.exe

    Imagen 1.14 Configuración gdb

  3. Verifica la instalación

    Crea un nuevo proyecto Go y un archivo hello.go

    Imagen 1.15 Crea un nuevo proyecto Go y un archivo

    Prueba la instalación a cómo sigue (necesitas escribir el comando en la consola en Eclipse)

    Imagen 1.16 Prueba el programa Go en Eclipse

IntelliJ IDEA

Las personas que han trabajado con Java deben estar familiarizadas con este IDE. Soporta el realce de sintaxis y completamiento de código inteligente, implementado por un plugin.

  1. Descarga IDEA, no hay diferencia entre la edición Ultimate y Community

  2. Instala el plugin Go. Escoge File - Setting - Plugins, luego da click en Browser repo.

  3. Busca golang, doble click download and install y espera que la descarga se complete.

    Click Apply, luego reinicia.

  4. Ahora puedes crear un proyecto Go.

    Introduce la ubicación de tu Go sdk en el siguiente paso - básicamente es tu $GOROOT.

(Revisa este artíclo de blog para una configuración paso a paso )

Links