Skip to content

Latest commit

 

History

History
400 lines (281 loc) · 15.5 KB

01.4.md

File metadata and controls

400 lines (281 loc) · 15.5 KB
Raw

Ferramentas para desenvolvimento Go

Nesta seção, vamos mostrar alguns IDEs (Integrated Development Environment ou Ambiente de Desenvolvimento Integrado) que podem ajudar você a ser um programador Go mais eficiente, com recursos como auto-complete inteligente e auto-formatação. Todas elas são compatíveis com todos os sitemas operacionais (cross-platform), então os passos descritos abaixo devem ser semelhantes independentemente do sistema que esteja utilizando.

LiteIDE

LiteIDE é um IDE leve e de código aberto para desenvolvimento exclusivo de projetos Go. Foi desenvolvido por visualfc.

Figure 1.4 Painel principal do LiteIDE

Recursos do LiteIDE.

  • Cross-platform
    • Windows
    • Linux
    • Mac OS
  • Cross-compile
    • Gerenciamento de múltiplos ambientes de compilação
    • Suporte a compilação cruzada (cross-compilation) da linguagem Go
  • Gerenciamento do projeto
    • Visão da documentação baseada na variável $GOPATH
    • Sistema de compilação baseado na variável $GOPATH
    • Indíce da documentação da API baseado na variável $GOPATH (N. do T.: Necessita de adaptações para o português)
  • Editor de código fonte Go
    • Alinhamento e identação de código
    • Suporte total ao gocode
    • Visualização da documentação Go e da API
    • Visualização de expressões de código usando F1
    • Movimentação entre as funções (Function declaration jump) usando F2
    • Suporte ao Gdb (debug)
    • Auto-formatação com gofmt
  • Outros
    • Multi-linguagem
    • Sistema de plugins
    • Temas para o editor de textos
    • Suporte a sintaxe baseado no Kate
    • Auto-complete inteligente baseado no texto completo
    • Atalhos customizados
    • Suporte a Markdown
      • Preview em tempo real
      • CSS customizado
      • Exportação para PDF e HTML
      • Conversão para PDF e HTML

Instalação do LiteIDE

  • Instale o LiteIDE

    Você precisa instalar Go primeiro (conforme a seção 1.1), depois faça o download da versão do LiteIDE mais apropriada para o seu sistema. Apenas descompacte e use diretamente.

  • Instale o gocode

    Você precisa instalar o gocode para poder usar o auto-complete inteligente.

      go get -u github.com/nsf/gocode

  • Ambiente de compilação

    Troque a configuração no LiteIDE para configurá-lo corretamente para o seu sistema operacional. Por exemplo, no Windows e usando a versão 64-bit da linguagem Go, você deve escolher win64 como ambiente de configuração na barra de ferramentas. Escolha opinion, encontre LiteEnv e na lista esquerda, abro o arquivo win64.env. Ele deve ser parecido como modelo a seguir.

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

  PATH=%GOBIN%;%GOROOT%\bin;%PATH%
  。。。

    Substitua GOROOT=c:\go para o caminho de instalação configurado anteriormente, salve o arquivo. Para ter suporte completo ao cgo no windowns, você precisar ter instalado o MinGW64 e deve adicionar c:\MinGW64\bin a a sua variável de ambiente.

    No Linux, usando uma versão 64-bit da linguagem Go, você deve escolher linux64 como configuração de ambiente na barra de ferramentas. Em seguida, escolha opinion, encontre LiteEnv no menu a esquerda e abra o arquivo linux64.env. Edite-o conforme segue.

      GOROOT=$HOME/go
  GOBIN=
  GOARCH=amd64
  GOOS=linux
  CGO_ENABLED=1

  PATH=$GOBIN:$GOROOT/bin:$PATH   
  。。。

    Substitua GOROOT=$HOME/go para o caminho da sua instalação, salve o arquivo.

  • $GOPATH

    $GOPATH é o caminho do diretório que contém seus projetos Go. Abra a linha de comando (ou apenas use Ctrl+` no LiteIDE) e então digite go help gopath para maiores detalhes. É bastante fácil visualizar e alterar a variável $GOPATH no LiteIDE. Use o menu View - Setup GOPATH para visualizar e alterar esses valores.

Sublime Text

Nesse ponto, iremos introduzir o Sublime Text (ou apenas Sublime) + GoSublime + gocode + MarGo. Vamos lá.

  • Auto-complete inteligente

    Figura 1.5 Auto-complete inteligente no Sublime

  • Formatação automática

  • Gerenciamento de Projetos

    Figura 1.6 Gerenciamento de Projetos no Sublime

  • Destaque de sintaxe (Syntax highlight)

  • A versão trial é gratuita para sempre sem nenhuma limitação nas funções. Você será lembrado em algumas ocasiões com um prompt solicitando a compra da licença, mas você pode ignorá-lo, se assim quiser. Claro, se você considerar que o editor melhora sua produtividade e você gostar realmente do produto, considere adquirir uma licença e ajudar a manter o desenvolvimento do mesmo!

Primeiro, faça o download da versão apropriada do Sublime para o seu sistema operacional.

  1. Pressione Ctrl+` , abra a linha de comando e insera o seguintes 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'

    Reinicie o Sublime Text para finalizar a instalação. Ao reabri-lo, você deverá encontrar uma opção Package Control no menu "Preferences".

    Figura 1.7 Sublime Package Control

  2. Para instalar o GoSublime, SidebarEnhancements e Go Build, pressione Ctrl+Shift+p para abrir o Package Control e então digite pcip (um atalho para "Package Control: Install Package").

    Figure 1.8 Instalando pacotes no Sublime

    Busque por "GoSublime", pressione OK para instalar o pacote e repita o mesmo procedimento para instalar os pacotes SidebarEnhancements e Go Build. Mais uma vez, reinicie o editor para completar a instalação.

  3. Para verificar se a instalação foi bem sucedida, abra o arquivo main.go no Sublime e veja se ele está destacando a sintaxe corretamente. Digite import e confira se aparece um prompt com sugestões de auto-complete. Inclua import "fmt" e em seguida insira fmt. em qualquer lugar depois da declaração de import para verificar se a função de auto-complete inteligente está corretamente ativada.

    Se funcionar corretamente, está tudo pronto.

    Se não funcionar, verifique seu $PATH novamente. Abra um terminal e digite gocode. Se mesmo isto não funcionar, possivelmente seu $PATH não está corretamente configurado.

Vim

Vim é um popular editor de textos para programadores que evolui de seu predecessor mais simples, chamado Vi. Ele possui funções para auto-complete inteligente, compilação e também funções para iterar sobre os erros.

Figure 1.8 Auto-complete inteligente para Go no Vim

  1. Primeiramente, copie as configurações padrão para o seu diretório de configuração do Vim

     cp -r $GOROOT/misc/vim/* ~/.vim/

  2. Ative o destaque de sintaxe (syntax highlighting)

     filetype plugin indent on
 syntax on

  3. Instale o gocode

     go get -u github.com/nsf/gocode

    O gocode será instalado em $GOBIN por padrão

  4. Configure o gocode digitando os comandos abaixo

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

    Explicações sobre a configuração do gocode:

    propose-builtins: determina se deve ou não ligar o auto-complete inteligente; false por padrão. lib-path: Por padrão, o gocode apenas busca por pacotes em $GOPATH/pkg/$GOOS_$GOARCH e $GOROOT/pkg/$GOOS_$GOARCH. Esta configuração é usada para adicionar novos diretórios como fonte.

  5. Parabéns! Tente digitar :e main.go no modo de comandos do Vim para experimentar o mundo de Go!

Emacs

Emacs (também conhecida como Arma de Deus) não é apenas um editor, mas também um poderoso IDE.

Figure 1.10 Painel principal do Emacs para editor Go

  1. Primeiramente, copie as configurações padrão para o seu diretório de configuração da Emacs

     cp $GOROOT/misc/emacs/* ~/.emacs.d/

  2. Instale o gocode

     go get -u github.com/nsf/gocode

    O gocode será instalado em $GOBIN por padrão

  3. Configure o gocode digitando os comandos abaixo

     ~ 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. Instale o Auto Completion Faça o download, descompacte e execute

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

    Configure o arquivo ~/.emacs conforme abaixo

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

    Veja este link para maiores detalhes desse processo.

  5. Finalize a configuração do arquivo .emacs para usar Go

     ;; 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. Parabéns, está tudo pronto! O Speedbar está desativado por padrão, mas remova os símbolos de comentário na linha ;;(speedbar 1) para ativar esse recurso, ou ainda use o comando M-x speedbar com a mesma finalidade.

Eclipse

O Eclipse é outra excelente ferramenta de desenvolvimento. Veja como usá-la para programar em Go.

Figure 1.1 Painel principal do Eclipse para Go

  1. Faça o download e instale o Eclipse

  2. Faça o download do goclipse e instale seguindo as instrução nesse link

  3. Faça o download do gocode

    Se você estiver usando no Windows, você deve instalar o git para Windows para poder instalar o gocode. Uma opção bastante usada para este fim é usar o msysgit

Instale pela linha de comando

	go get -u github.com/nsf/gocode

Ou ainda instale diretamente pelo código-fonte se preferir.

  1. Faça o download e instale o MinGW

  2. Configure os plugins.

    Windows->Preferences->Go

    (1).Configure o compilador Go

    Figure 1.12 Configuração Go no Eclipse

    (2).Configure o gocode(opcional), usando o diretório onde você o instalou (gocode.exe)

    Figure 1.13 Configuração do gocode

    (3).Configure o gdb(opcional), usando o diretório onde você o instalou (gdb.exe).

    Figure 1.14 Configuração do gdb

  3. Verifique a instalação

    Crie um novo projeto Go e um novo arquivo hello.go conforme segue.

    Figure 1.15 Criar novo projeto e arquivo hello.go

    Teste a instalação conforme abaixo.(você precisará digitar um comando no console do Eclipse)

    Figure 1.16 Teste de um programa Go no Eclipse

IntelliJ IDEA

As pessoas que trabalham com Java tem familiaridade com este IDE. Ela também suporta a sintaxe para linguagem Go e auto-complete inteligente através de um plugin.

  1. Faça o download da IDEA, não há diferença entre as versões Ultimate e Community para uso com Go

  2. Instale o Go plugin. Selecione File - Setting - Plugins, e então clique em Browser repo.

  3. Procure por golang, duplo-clique em download and install e aguarde a finalização do download.

    Clique em Apply e reinicie o IDE.

  4. Agora você está apto para criar um projeto Go.

    Se for solicitado o caminho para o seu sdk Go em alguma etapa, apenas insira o caminho para seu $GOROOT.

( Veja este post para um passo-a-passo de configuração e uso da IntelliJ IDEA com a linguagem Go )

Links