Go Entwicklungswerkzeuge

In diesem Abschnitt werde ich Dir ein paar IDEs (Integrated Developement Environments) vorstellen, die Dir mit Funktionen wie intelligenter Codevervollständigung und automatischer Formatierung dabei helfen, effizienter zu programmieren. Alle Entwicklungsumgebungen sind plattformunabhängig, sodass die hier gezeigten Schritte nicht sehr verschieden seien sollten, auch wenn Du ein anderes Betriebssystem nutzt.

LiteIDE

LiteIDE ist eine leichtgewichtige IDE, die open source ist und einzig für die Go Programmierung gedacht ist. Entwickelt wurde sie von visualfc.

Abbildung 1.4 Startansicht von LiteIDE

LiteIDEs Merkmale.

• Plattformunaghängigkeit
  • Windows
  • Linux
  • Mac OS
• Plattformübergreifende Kompilierung
  • Verwalte mehrere Kompilierungsumgebungen
  • Unterstützt die plattformübergreifende Kompilierung von Go-Code
• Standardisiertes Projektmanagement
  • Dokumentationsansicht basiert auf $GOPATH
  • Kompilierungsystem basiert auf $GOPATH
  • Index der API-Dokumentation basiert auf $GOPATH
• Go Quellcode Editor
  • Umschreibung von Code
  • Vollständige Unterstützung von gocode
  • Anzeige der Go Dokumentation und ein API Index
  • Hilfe zu Codefragmenten durch F1
  • Aufrufen von Funktionsdeklerationen durch F2
  • Gdb Unterstützung
  • Automatische Formatierung durch gofmt
• Anderes
  • Mehrsprachig
  • Plugin System
  • Texteditor Themes
  • Farbliche Syntaxhervorhebung basierend auf Kate
  • Intelligente Autovervollständigung basierend auf einer Volltext-Suche
  • Personalisierbare Tastenkürzel
  • Markdown Unterstützung
    • Echtzeit Vorschau
    • Personalisierbares CSS
    • Exportoptioen zu HTML und PDF
    • Konvertierung and Zusammenführung zu HTML und PDF

LiteIDE Instalation

• Installiere LiteIDE

  • Lade LiteIDE herunter

  • Quellcode

    Du musst Go zuerst installieren. Lade dafür die entsprechende Version für Dein Betriebssystem herunter. Entpacke das Archiv um es Programm direkt auszuführen.

• Installiere gocode

  Im nächsten Schritt muss gocode installiert werden, um die intelligente Autovervollständigung zu nutzen.

    go get -u github.com/nsf/gocode
  

• Kompilierungsumgebung

  Passe die Einstellungen von LiteIDE Deinen Betriebssystem entprechend an. Unter Windows mit der 64-Bit Variante von Go solltest Du win64 als Umgebung in der Symbolleiste auswählen. Dann wähle opinion, finde LiteEnv in der Liste auf der linken Seiten und öffne die Datei win64.env in der Liste zu Deiner Rechten.

    GOROOT=c:\go
    GOBIN=
    GOARCH=amd64
    GOOS=windows
    CGO_ENABLED=1
  
    PATH=%GOBIN%;%GOROOT%\bin;%PATH%
    。。。
  

  Ersetze GOROOT=c:\go mit Deinem Installationspfad von Go und speichere. Wenn Du MinGW64 nutzt, füge C:\MinGW64\bin der $PATH-Umgebungsvariable hinzu, um cgo starten zu können.

  Unter Linux mit einer 64-Bit Variante von Go, solltest Du linux64 als Umgebung in der Symbolleiste auswählen. Dann wähle opinion, finde LiteEnv in der Liste auf der linken Seiten und öffne die Datei linux64.env in der Liste zu Deiner Rechten.

    GOROOT=$HOME/go
    GOBIN=
    GOARCH=amd64
    GOOS=linux
    CGO_ENABLED=1
  
    PATH=$GOBIN:$GOROOT/bin:$PATH   
    。。。
  

  Ersetzte GOROOT=$HOME/go mit Deinem Installationspfad von Go und speichere.

• $GOPATH $GOPATH ist ein Pfad, der eine Liste von allen Go-Projekten umfasst. Öffne die Kommandozeile (oder drücke Ctrl+ in LiteIDE) und gib dann go help gopath ein, um mehr Details einzusehen. In LiteIDE ist es sehr einfach, den $GOPATH einzusehen und ihn zu verändern. Folge View - Setup GOPATH, um dies zu tun.

Sublime Text

Nun möchte ich dir Sublime Text 2 (oder einfach Sublime) in Kombination mit den Plugins GoSublime, gocode und MarGo vorstellen. Lass mich erklären, warum.

• Intelligente Autovervollständigung

  

  Abbildung 1.5 Sublimes intelligente Autovervollständigung

• Automatische Formatierung des Quellcodes

• Unterstützung für Projektmanagement

  

  Abbildung 1.6 Projektmanagement in Sublime

• Farbliche Hervorhebung des Synax

• Es gibt eine Testversion ohne Einschränkungen der Funktionen. Es kann sein, dass Du nach einer Weile daran erinnert wirst, dass Du eine Lizenz kaufen sollest, aber Du kannst diese Meldung auch einfach ignorieren. Wenn Du aber glaubst, dass Sublime Dich produktiver macht und Du den Editor magst, solltest Du eine Lizenz kaufen, um die fortwährende Entwicklung zu unterstützen.

Zu aller erst solltest Du Dir eine für Dein Betriebssystem geeignete Version von Sublime herunterladen.

1. Drücke Ctrl+` , öffne die Kommandozeile und füge folgenden Codesnippsel ein:

    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'
   

   Starte Sublime Text nach der Installation neu. Nun solltest Du im Menü unter dem Reiter Preferences die Option Package Control vorfinden.

   

   Abbildung 1.7 Die Paketverwaltung von Sublime

2. Zur Installation von GoSublime, SidebarEnhancements und Go Build, drücke Ctrl+Shift+p um die Paketverwaltung aufzurüfen und gib pcip (Kurzform für "Package Control: Install Package") ein.

   

   Abbildung 1.8 Installation von Paketen in Sublime

   Gib nun "GoSublime" ein, drücke auf OK, um das Paket zu installieren und wiederhole diese Schritte jeweils für SidebarEnhancements und Go Build. Starte den Editor nochmals neu, sobald alle Pakete installiert wurden.

3. Um sicher zu stellen, dass die Installation auch erfolgreich abgeschlossen wurde, starte Sublime und öffne die Datei main.go, um zu sehen, ob dessen Syntax farblich hervorgehoben wird. Gib import ein, um zu testen, ob die automatische Codevervollständigung nun funktioniert oder nicht.

   Wenn alles erfolgreich Verlaufen ist, können wir ja starten.

   Sollte dies nicht der Fall sein, solltest Du nochmal einen Blick auf die $PATH-Umgebungsvariable blicken. Öffne dazu die Kommandozeile und gib gocode ein. Sollte nichts ausgeführt werden, so wird $PATH wahrscheinlich nicht richtig konfiguriert worden sein.

Vim

Vim ist ein populärer Texteditor unter Programmierern, welcher sich aus seinem minimalistischeren Vorgänger Vi hervorging. Zu seinen Funktionen gehören u.a. die intelligente Autovervollständung von Codesegmenten, Kompilierung und das Springen zu Fehlern im Quellcode.

Abbildung 1.8 Vims intelligente Autovervollständigung für Go

1. Syntaxhervorhebung für Go

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

2. Syntaxhervorhebung aktivieren

    filetype plugin indent on
    syntax on
   

3. Installiere gocode

    go get -u github.com/nsf/gocode
   

   gocode wird standardmäßig unter $GOBIN installiert.

4. Konfiguriere 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"
   

   Einige Worte zur Konfiguration von gocode:

   propose-builtins: aktiviert bzw. deaktiviert die Autovervollständigung; standardmäßig auf false gesetzt. lib-path: gocode sucht lediglich unter $GOPATH/pkg/$GOOS_$GOARCH und $GOROOT/pkg/$GOOS_$GOARCH nach Paketen. Mit dieser Einstellung können weitere Pfade hinzugefügt werden..

5. Glückwunsch! Tippe :e main.go ein und mache Deine ersten Schritte in Go!

Emacs

Emacs wird auch als "Weapon of God" bezeichnet. Es handelt sich nicht nur um einen Editor, sondern vielmehr um eine mächtige IDE.

Abbildung 1.10 Emacs Hauptfenster als Go-Editor

1. Syntaxhervorhebung

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

2. Installiere gocode

    go get -u github.com/nsf/gocode
   

   gocode wird standardmäßig unter $GOBIN installiert.

3. Konfiguriere 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. Installiere Auto Completion

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

   Konfiguriere die ~/.emacs-Datei

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

   Folge diesem Link für weitere Informationen.

5. Konfiguriere .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. Glückwunsch, Du hast es geschafft! Die Schnellzugriffsleiste (Speedbar) ist standardmäßig geschlossen - Entferne die Kommentarzeichen in der Zeile ;;(speedbar 1), um diese Funktion zu aktivieren, oder Du benutzt die Speedbar via M-x speedbar.

Eclipse

Eclipse ist ebenfalls ein großartiges Entwicklungswerkzeug. Ich werde Dir zeigen, wie Du mit ihm Programme in Go schreiben kannst.

Abbildung 1.1 Eclipses Hauptfenster zum Programmieren Go

1. Herunterladen und Installation von Eclipse
2. Lade goclipse herunter http://code.google.com/p/goclipse/wiki/InstallationInstructions

3. Lade gocode

   gocode auf Github.

    https://github.com/nsf/gocode
   

   Unter Windows musst Du git installiert haben. Wir nutzen überlicherweise msysgit.

   Installiere gocode in der Kommandozeile

    go get -u github.com/nsf/gocode
   

   Du kannst die Installation mithilfe des Quellcodes selbst durchführen, wenn Du magst.

4. Installation von MinGW

5. Konfiguration der Plugins.

   Windows->Preferences->Go

   (1).Einrichtung des Go-Compiler

   

   Abbildung 1.12 Go-Einstellungen in Eclipse

   (2).Konfiguriere gocode(optional). Setze den Pfad zu gocode auf den Speicherort von gocode.exe.

   

   Abbildung 1.13 gocode-Einstellungen

   (3).Konfiguriere gdb(optional). Setze den Pfad zu gdb auf den Speicherort von gdb.exe.

   

   Abbildung 1.14 gdb-Einstellungen

6. Überprüfe, ob die Installation erfolgreich verlief

   Erstelle ein neues Go-Project und eine Datei hello.go wie folgt.

   

   Abbildung 1.15 Erstelle ein neues Projekt und eine Datei

   Überprüfe die Installation wie folgt. (Die Befehle müssen in die Konsole von Eclipse eingegeben werden).

   

   Abbildung 1.16 Teste ein Go-Programm in Eclipse

IntelliJ IDEA

Programmierer, die bereits mit Java gearbeitet haben, sollte diese IDE bekannt sein. Es unterstützt die farbliche Hervorhebung von Go-Code und intelligente Autovervollständigung, welches durch ein Plugin erreicht wird.

1. Lade IDEA herunter. Es gibt keinen Unterschied zwischen der Ultimate- und Community-Edition.

   

2. Installiere das Go-Plugin. Gehe zu File - Setting - Plugins und klicke dann auf Browser repo.

   

3. Starte eine Suche mit golang, klicke doppelt auf download and install und warte, bis der Download abgeschlossen ist.

   

   Klicke auf Apply und starte das Programm neu.

4. Nun kannst Du ein neues Go-Projekt erstellen.

   

   Gib im nächsten Schritt den Speicherort Deines Go-SDK (SDK steht für Software Developement Kit) an - normalerweise handelt es sich hierbei um $GOROOT.

( Werfe einen Blick auf diesen Blogartikel, welcher die Installation und Einrichtung von IntelliJ IDEA mit Go schrittweise erläutert. )

Links

• Inhaltsverzeichnis
• Vorheriger Abschnitt: Go Befehle
• Nächster Abschnitt: Zusammenfassung