Programmieren in Go und 10-Finger-Schreiben hängen eng zusammen. Go hat klare Syntaxregeln und spezielle Zeichen, die beim schnellen Tippen eine Herausforderung sein können. 10-Finger-Schreiben bedeutet, ohne auf die Tastatur zu schauen zu tippen. Im Kontext von Go ist das wichtig, weil die Sprache sehr genau ist: eine fehlende geschweifte Klammer oder ein falsch getippter Operator kann zu einem Kompilierungsfehler führen.

Was ist charakteristisch an der Go-Syntax?

Go ist eine kompilierte Sprache engl.: compiled language mit einem klaren, minimalistischen Stil. Quellcode beginnt immer mit einer package-Deklaration. Imports können einzeln deklariert oder in Blöcken gruppiert werden. Funktionen werden mit dem Schlüsselwort func deklariert und durch geschweifte Klammern {} abgegrenzt. Einrückungen bestimmen in Go nicht die Grenzen eines Blocks; go fmt formatiert den Code nach einem einheitlichen Standard. Semikolons werden im Quellcode meist weggelassen und vom Compiler nach bestimmten Regeln an Zeilenumbrüchen eingefügt. Das bedeutet, dass ein korrektes Setzen von Enter nicht nur eine Konvention, sondern eine Regel ist.

package main

import "fmt"

func main() {
 fmt.Println("Hello, Go")
}

Zeichen, auf die man achten sollte

Beim Schreiben von Go-Code begegnet man bestimmten Zeichen sehr häufig. Geschweifte Klammern {} begrenzen Funktionskörper und Blöcke in Kontrollstrukturen. Runde Klammern () umschließen Funktionsparameter und -aufrufe. Eckige Klammern [] definieren Arrays und Slices engl.: arrays, slices. Anführungszeichen " und Backticks engl.: backticks ` werden für Strings verwendet. Der Kurzdeklarationsoperator := wird ständig verwendet, um Variablen zu erzeugen. Kanäle engl.: channels nutzen den Operator <-, der in anderen Sprachen kaum vorkommt.

Variablen und Deklarationen

Go unterscheidet zwischen Deklaration mit var und kurzer Variablendeklaration mit :=. Dieser Operator kombiniert Doppelpunkt und Gleichheitszeichen - am Anfang etwas ungewohnt. Da er in fast jedem Programm vorkommt, lohnt es sich, die Fingerbewegungen zu trainieren.

var count int = 10
message := "typed correctly"

Kontrollstrukturen

Go verwendet if, for und switch. Eine while-Schleife gibt es nicht. Die Syntax ist kompakt, aber Vergleichsoperatoren wie ==, !=, <, > und der Inkrementoperator ++ müssen präzise getippt werden. Die Verwendung von = statt == in einer Bedingung führt zu einem Kompilierungsfehler.

for i := 0; i < 5; i++ {
 if i%2 == 0 {
 fmt.Println("even")
 }
}

Funktionen und Mehrfachrückgaben

Funktionen in Go können mehrere Werte zurückgeben. Das ist mächtig, erfordert aber oft Kommas in Rückgabelisten und Zuweisungen. Typisch ist das Muster result, err :=, das man so lange üben sollte, bis es automatisch geht.

func divide(a, b int) (int, error) {
 if b == 0 {
 return 0, fmt.Errorf("division by zero")
 }
 return a/b, nil
}

result, err := divide(10, 2)

Slices, Maps und Literale

Eckige Klammern [] und geschweifte Klammern {} tauchen ständig bei Arrays, Slices und Maps auf. Maps nutzen zusätzlich Doppelpunkte : zwischen Schlüssel und Wert. Diese Kombination macht das schnelle, fehlerfreie Tippen manchmal knifflig.

nums := []int{1, 2, 3}
scores := map[string]int{"alice": 5, "bob": 7}

Structs und Methoden

Der Typ struct gruppiert Daten. Methoden werden über Receiver engl.: receivers definiert und über den Punkt-Operator . aufgerufen. Hat man das ein paarmal gemacht, tippt es sich ganz automatisch.

type User struct {
 Name string
}

func (u User) Greet() string {
 return "Hello " + u.Name
}

u := User{Name: "A"}
fmt.Println(u.Greet())

Interfaces

Interfaces in Go werden implizit erfüllt, ohne ein Schlüsselwort wie implements. Bei ihrer Definition tippt man meist Klammern und Methodensignaturen.

type Stringer interface {
 String() string
}

Nebenläufigkeit und Kanäle

Ein sehr spezielles Merkmal von Go ist der Kanal-Operator <-. Er kommt in den meisten anderen Sprachen nicht vor und ist anfangs etwas gewöhnungsbedürftig. Man schreibt ihn in beide Richtungen: Senden ch <- value und Empfangen value := <-ch. Es lohnt sich, diese Bewegung einzuüben.

ch := make(chan int)
go func() { ch <- 42 }()
value := <-ch

Strings und Runes

Go verwendet doppelte Anführungszeichen für normale Strings, Backticks für Rohstrings engl.: raw strings und einfache Anführungszeichen für Runes (einzelne Zeichen, Typ rune). Ein kleiner Tippfehler hier reicht für einen Kompilierungsfehler. Daher sollte man sehr genau zwischen ", ` und ' unterscheiden.

text := "normal string"
raw := `path\to\file`
r := 'a'

Einrückung und Formatierung

gofmt formatiert den Code einheitlich. Beim Tippen musst du außerdem die Regeln zu Klammern und Zeilenumbrüchen beachten. Ein häufiger Fehler ist ein Zeilenumbruch zwischen return und dem Rückgabewert. Go fügt an diesem Zeilenumbruch ein Semikolon ein und beendet damit die return-Anweisung. Mit der Zeit gewöhnt man sich an den Rhythmus.

Zusammenfassung

Programmieren in Go erfordert Aufmerksamkeit beim Tippen. Die wichtigsten Zeichen sind geschweifte Klammern {}, runde Klammern (), eckige Klammern [], der Kurzdeklarationsoperator := und der Kanal-Operator <-. Diese Symbole tauchen überall im Go-Code auf. Übe das Eingeben dieser Zeichen, um Go-Code zügig und genau zu tippen.