PPA¶

Adresszeile zum Hinzufügen des PPAs:

• ppa:gophers/go

Damit Pakete aus dem PPA genutzt werden können, müssen die Paketquellen neu eingelesen werden.

Nach dem Aktualisieren der Paketquellen kann das folgende Paket installiert ^[2] werden:

• golang (ppa)

Darin enthalten sind Compiler, Linker und verschiedene Werkzeuge zur Formatierung des Quellcodes oder zum Nachinstallieren von Bibliotheken.

Gedit¶

Wer sich etwas mehr Komfort bei der Quellcode-Erstellung wünscht, aber nicht gleich auf eine Entwicklungsumgebung umsteigen möchte, kann sich Gedit etwas verschönern. Gedit unterstützt zwar von Haus aus viele Sprachen, Go ist allerdings noch nicht dabei. Eine Anleitung zum nachträglichen Hinzufügen von Syntax-Highlighting ist hier zu finden.

GolangIDE¶

Sucht man eine vollständige Entwicklungsumgebung, sollte man sich GolangIDE ansehen, eine auf Go spezialisierte Version der Entwicklungsumgebung LiteIDE. Sie unterstützt einiges, was den Programmieralltag erleichtert:

• Syntax-Highlighting, konfigurierbar

• Projektmanagement

• Gut integriertes Debugging

• Automatische Formatierung des Quellcodes mit gofmt

• Baumansicht von Funktionen und Variablen

• Übersichtliche Bedienung et cetera.

Zur Zeit wird sie auf der Projektseite für Linux, Windows und Mac OS X als Download angeboten.

1
2
3
4

GOROOT=/usr/lib/go
GOBIN=/usr/bin
GOARCH=amd64 #(oder GOARCH=386 bei 32-Bit Systemen)
GOOS=linux

Variablen¶

In Go gibt es verschiedene Möglichkeiten, Variablen zu deklarieren und zu initialisieren:

1
2
3
4
5
6

//Beispiel 1
var txt1 string    //Deklaration
txt1 = "zugewiesen" //Initialisierung

//Beispiel 2
txt2 := txt1

Hier wird zunächst die Variable "txt1" mit dem Schlüsselwort "var" (bekannt aus JavaScript) vom Typ "string" deklariert. Auffällig ist, dass im Gegensatz zu C/C++/etc. der Typ der Variable hinter dem Namen steht. Im nächsten Schritt wird dann der Variable ein String zugewiesen.

Das zweite Beispiel arbeitet mit dem Zuweisungsoperator ":=". Dieser kombiniert die beschriebenen Schritte: er legt eine Variable "txt2" an und weist ihr den Wert von "txt1" zu. Hier muss kein Typ angegeben werden, da der Compiler diesen automatisch aus dem zugewiesenen Wert (hier string) erkennt.

Funktionen¶

Funktionen können in Go sehr umfangreich definiert werden:

1
2
3

func (t typ) funktionsname(q int) (r,s int) {
    return 0,0
}

Wie bereits erwähnt, wird jede Funktion mit dem Schlüsselwort "func" eingeleitet. Im folgenden wird die Syntax dieses Prototyps erläutert:

1
2
3

func merge(a,b string) string {
    return a+b, a, b
} 

1
2
3
4
5

//Möglichkeit 1
add, a, b := merge("zusammen", "führen")
fmt.Println(add)
fmt.Println(a)
fmt.Println(b)

zusammenführen
zusammen
führen

1
2
3

//Möglichkeit 2
add, _, _ := merge("zusammen", "führen")
fmt.Println(add)

zusammenführen

1
2
3

func printStuff() {
    fmt.Println("Some stuff....")
}

Nebenläufigkeit - Concurrency¶

Ein weiteres Schmankerl der neuen Programmiersprache ist die sogenannte "Nebenläufigkeit". Dieses von Erlang inspirierte Feature ermöglicht es, auf vergleichsweise einfache Weise parallel zu programmieren, eine Art Thread-Programmierung:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main
import (
    "fmt"
    "time"
)
func wake(zeit int, grund string) {
    time.Sleep(zeit*1e9)
    fmt.Println("Zeit abgelaufen: ", grund)
}

func main() {
    go wake(180, "Tee!")
    go wake(200, "Wichtiger Termin!")
    time.Sleep(500e9)
}

Zuerst wird die Funktion "wake" definiert. Sie akzeptiert als Parameter eine Zeit (in Sekunden) und einen Grund als String. Wird sie aufgerufen, wartet sie die übergebene Zeit und gibt dann eine Meldung mit dem Grund des Aufrufs aus.

Das Entscheidende kommt erst in der main-Funktion: Die Funktion "wake" wird hier mit dem Schlüsselwort go aufgerufen. Ohne go würde die zweite wake-Funktion erst aufgerufen werden, wenn die erste beendet wird, also nach 3 Minuten. Ein go startet die Funktionen jedoch nebenläufig, also parallel. So wird man nach 3 Minuten an den Tee, und 20 Sekunden später an den wichtigen Termin erinnert.

Im Gegensatz zu diesem Beispiel ist die einfache Nebenläufigkeit z.B. bei Spielen erforderlich, wo gleichzeitig die Eingaben vom Benutzer interpretiert werden, und im Hintergrund z.B. Timer laufen.

Die Sleep-Funktion danach ist hier erforderlich, da sich sonst nach den Funktionsaufrufen das Hauptprogramm und somit auch die sog. Go-Routinen beenden würden. Professionell ist das nicht, da man meistens nicht weiß, wie lange man warten muss. Dann würde man die Routinen entweder zu früh abwürgen oder unnötig Rechenzeit verschwenden.