Go

Google Go ist eine moderne imperative Sprache für modulare, objektorientierte und vor allem nebenläufige Systemprogrammierung.

Versionen

Datum Version Neuerungen
2007 Idee von Robert Griesemer, Rob Pike und Ken Thompson
2009 Start des Open Source Projekts
2012 1.0 Stabile Ersteveröffentlichung
2015 1.5 Compiler und Linker vollständig in Go

Beispiel

hello.go
package main import ( "fmt" "os" ) func main () { if len (os.Args) == 1 { fmt.Printf("Hello, World!\n") } else { for _, arg := range os.Args { fmt.Printf("Hello, %s!\n", arg) } } os.Exit(0); }

Übersetzen und ausführen mit:

go run hello.go
Hello, World!

Programmierstil

Das Programm gofmt formatiert den Quelltext.

Syntax

Pakete

Die Ausführung beginnt in der Funktion main im gleichnamigen Paket.

package main

import (
	"package"
)

func main {
	…
}

Datentypen

Primitive Datentypen

Typ Bits Default Beschreibung
bool 1 false Wahrheitswert
byte 8 0 Kleinste Speichereinheit, Alias für uint8
rune 32 0 Unicode Zeichen, Alias für uint32
[u]int{8,16,32,64} 8–64 0 Ganze zahlen mit und ohne Vorzeichen
float{32,64} 32–64 0.0 Näherung des reelle Zahlenraumraums
complex{64,128} 64–128 0 + 0i Komplexe Zahl mit imaginärem Anteil
string "" Zeichenkette: read-only slice of bytes

Zusammengesetzte Datentypen

Typ Beispiel Beschreibung
[size]type a := [3]int {1, 2, 3} Array, feste Länge
[]type s := []int {1, 2, 3} Slice, wächst dynamisch
[type]type m := [string]int {"foo":1, "bar":2} Map

Slices können dynamisch wachsen.

s := make([]int, 5, 10)
s = {1, 2, 3, 4, 5}
s[0:3] // [1, 2, 3]
len(s) // 5
cap(s) // 10
append(s, 6, 7, 8) // [1, 2, 3, 4, 5, 6, 7, 8]
for i, val := range []int {1, 2, 3} { … }

Maps erzeugen

m := make(map[string]int)
val, present := m["foo"]
delete (m, "foo")

Struktur

type Point struct {
	x, y, z int
}

l := Point{1, 2, 0}
r := point{z: 23}
r.x = 7

Variablen

Konstanten werden symbolisch ersetzt und brauchen keinen Typ

const pi = 3.14159
var name[, …] [type] [= value, …]

Deklaration mit Name und Typ setzt Default Werte.

var a, b, c int

Der Typ kann entfallen, wenn die Variablen initialisiert werden.

var a, b, c = 1, 2, 3

Innerhalb von Funktionen bestimmt der Inferenz-Operator den korrekten Typ:

n := 23 // var n int = 23

Zuweisung erfordert explizite Konvertierung

a := float32(n)

Go hat Zeiger aber keine Zeiger-Arithmetik.

x := 23
p := &x  // p -> x
y := *p  // y == 23
z := nil // z -> null

Funktionen

Funktionen haben keinen skalaren Rückgabewert, sondern jeweils eine Liste mit Eingabe- und eine Liste mit Ausgabeparametern. Parameter mit dem selben Typ kann man zusammenfassen.

func [(obj)] name [(in)] [(out)] { … }

Zum Beispiel:

func split (a, b int) (c, d, e float32) {
	c = a / b
	d = (a * a) / (b * b)
	e = (a * a * a) / (b * b * b)
	return
}

Kontrollstrukturen

Go deckt alle Varianten von Schleifen mit einem Schlüsselwort ab. Ohne Argumente produziert es eine Endlosschleife. Die initialisierte Variable ist nur im Rumpf der Schleife sichtbar.

for [[init;] cond[; post]] { … }

Die einfache Verzweigung kann mehrere Bedingungen prüfen. Optional kann sie zuerst eine Variable initialisieren, die nur innherhalb des Rumpfs sichtbar ist.

if [init;] cond; … { … } [ else]

Die Mehrfachverzweigung ohne Argumente funktioniert wie eine if-else-Kaskade.

switch [[init;] cond] {
	case type: …
	case cond: …
	case cond: …
		fallthrough
	case cond, cond… : …
}

Ressourcen werden balanciert, indem man die Funktionsaufrufe zum Freigeben auf einem Stack ablegt, der beim verlassen der Funktion abgearbeitet wird.

defer func

new (type)

Literatur

  1. The Go Programming Language
  2. Effective Go