10 Finger Schreiben Übung: Programmierung in der Sprache Go

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 führt sofort zu einem Kompilierungsfehler.

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 werden in Blöcken gruppiert. Funktionen werden mit dem Schlüsselwort func deklariert und durch geschweifte Klammern {} abgegrenzt. Einrückungen sind nicht optional - Go erzwingt Formatierung mit go fmt. Das Sprachdesign verzichtet auf Semikolons, aber der Compiler fügt sie automatisch am Ende einer Zeile ein. 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 {} folgen auf jede Funktion oder Kontrollstruktur. 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 Zuweisung 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. Schon ein = statt == bringt den Code zum Absturz.

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
}

Konkurrenz 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

Go erzwingt einen einheitlichen Stil. Das ist praktisch, bedeutet aber auch, dass man sich an Regeln zu Klammern und Zeilenumbrüchen halten muss. Ein häufiger Fehler ist ein Zeilenumbruch direkt nach return. Go meldet sofort einen Fehler. 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. Wenn sie sich natürlich anfühlen, kann man Go-Code schnell und fehlerfrei schreiben.