Go Spickzettel
Zuletzt aktualisiert
Hello World & Programmaufbau
Jedes Go-Programm liegt in einem Package; der Einstiegspunkt ist func main im Package main.
| Operation | Syntax |
|---|---|
| Package-Deklaration | package main |
| Ein Package importieren | import "fmt" |
| Mehrere Packages importieren | import (\n "fmt"\n "os"\n) |
| Einstiegspunkt | func main() { ... } |
| Eine Zeile ausgeben | fmt.Println("Hello, World!") |
| Formatierte Ausgabe | fmt.Printf("%d items\n", n) |
| Eine Datei ausführen | go run main.go |
| Eine Binärdatei bauen | go build |
Variablen & Typen
Go ist statisch typisiert, kann Typen aber mit := ableiten.
| Operation | Syntax |
|---|---|
| Mit Typ deklarieren | var age int = 30 |
| Mit Inferenz deklarieren | var name = "Ada" |
| Kurze Deklaration | count := 0 |
| Mehrere auf einmal | x, y := 1, 2 |
| Konstante | const Pi = 3.14 |
| Nullwerte | 0, "", false, nil |
| Basistypen | int, float64, string, bool, byte, rune |
| Typumwandlung | f := float64(i) |
Kontrollfluss
Go hat ein einziges Schleifen-Schlüsselwort - for - und keine Klammern um Bedingungen.
| Operation | Syntax |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If mit Init-Anweisung | if v, ok := m[k]; ok { ... } |
| For-Schleife (C-Stil) | for i := 0; i < 10; i++ { ... } |
| While-artige Schleife | for x < 100 { ... } |
| Endlosschleife | for { ... } |
| Range über ein Slice | for i, v := range items { ... } |
| Switch | switch day { case 1: ...; default: ... } |
| Switch ohne Ausdruck | switch { case x > 0: ... } |
| Break / continue | break, continue |
Funktionen
Funktionen sind Werte erster Klasse und können mehrere Ergebnisse zurückgeben.
| Operation | Syntax |
|---|---|
| Einfache Funktion | func add(a int, b int) int { return a + b } |
| Gemeinsamer Parametertyp | func add(a, b int) int { ... } |
| Mehrere Rückgabewerte | func divmod(a, b int) (int, int) { return a / b, a % b } |
| Benannte Rückgabewerte | func split(sum int) (x, y int) { x = sum / 2; return } |
| Variadische Funktion | func sum(nums ...int) int { ... } |
| Anonyme Funktion | f := func() { ... } |
| Closure | func counter() func() int { ... } |
| Defer (läuft beim Return) | defer file.Close() |
Slices & Arrays
Arrays haben eine feste Größe; Slices sind dynamische Sichten auf Arrays.
| Operation | Syntax |
|---|---|
| Array fester Größe | var a [3]int |
| Slice-Literal | nums := []int{1, 2, 3} |
| Ein Slice erstellen | s := make([]int, 0, 10) |
| Anhängen | s = append(s, 4) |
| Länge / Kapazität | len(s), cap(s) |
| Ein Slice teilen | s[1:3] |
| Kopieren | copy(dst, src) |
| Durchlaufen | for i, v := range s { ... } |
Maps
Maps sind die eingebauten Hashtabellen von Go.
| Operation | Syntax |
|---|---|
| Eine Map erstellen | m := make(map[string]int) |
| Map-Literal | m := map[string]int{"a": 1, "b": 2} |
| Einen Wert setzen | m["c"] = 3 |
| Einen Wert lesen | v := m["a"] |
| Existenz prüfen | v, ok := m["x"] |
| Einen Schlüssel löschen | delete(m, "a") |
| Länge | len(m) |
| Durchlaufen | for k, v := range m { ... } |
Structs & Methoden
Structs gruppieren Felder; Methoden hängen Verhalten über einen Empfänger an.
| Operation | Syntax |
|---|---|
| Ein Struct definieren | type Point struct { X, Y int } |
| Eine Instanz erstellen | p := Point{X: 1, Y: 2} |
| Auf ein Feld zugreifen | p.X |
| Zeiger auf ein Struct | p := &Point{1, 2} |
| Methode mit Wert-Empfänger | func (p Point) Dist() float64 { ... } |
| Methode mit Zeiger-Empfänger | func (p *Point) Move(dx int) { p.X += dx } |
| Eingebettetes Struct | type Circle struct { Point; R int } |
| Struct-Tags | Name string mit einem in Backticks gesetzten json:"name"-Tag |
Interfaces
Interfaces werden implizit erfüllt - jeder Typ mit den passenden Methoden qualifiziert sich.
| Operation | Syntax |
|---|---|
| Ein Interface definieren | type Shape interface { Area() float64 } |
| Implementieren (implizit) | func (c Circle) Area() float64 { ... } |
| Leeres Interface (any) | var x interface{} oder var x any |
| Typzusicherung | s, ok := x.(string) |
| Type Switch | switch v := x.(type) { case int: ... } |
| Stringer-Interface | func (p Point) String() string { ... } |
Goroutinen & Channels
Goroutinen sind leichtgewichtige Threads; Channels reichen Werte zwischen ihnen weiter.
| Operation | Syntax |
|---|---|
| Eine Goroutine starten | go doWork() |
| Einen Channel erstellen | ch := make(chan int) |
| Gepufferter Channel | ch := make(chan int, 5) |
| An einen Channel senden | ch <- 42 |
| Von einem Channel empfangen | v := <-ch |
| Einen Channel schließen | close(ch) |
| Range über einen Channel | for v := range ch { ... } |
| Select auf Channels | select { case v := <-ch: ...; default: ... } |
| Wait Group | var wg sync.WaitGroup; wg.Add(1); wg.Wait() |
| Mutex | var mu sync.Mutex; mu.Lock(); mu.Unlock() |
Fehlerbehandlung
Go gibt Fehler als Werte zurück - es gibt keine Exceptions.
| Operation | Syntax |
|---|---|
| Einen Fehler zurückgeben | func read() (string, error) { return "", err } |
| Einen Fehler prüfen | if err != nil { return err } |
| Einen Fehler erstellen | errors.New("not found") |
| Formatierter Fehler | fmt.Errorf("bad id %d", id) |
| Einen Fehler umhüllen | fmt.Errorf("load: %w", err) |
| Auspacken / abgleichen | errors.Is(err, os.ErrNotExist) |
| Nach Typ abgleichen | errors.As(err, &target) |
| Panic / recover | defer func() { recover() }() |
Die Go-Syntax, die du am häufigsten brauchst, auf einer Seite. Dieser Go-Spickzettel ist eine Schnellreferenz für die Kernsprache - Variablen und Typen, Slices und Maps, Structs und Interfaces sowie die Goroutinen und Channels, mit denen Golang bei Nebenläufigkeit glänzt.
Alles hier ist Standard-Go und kompiliert mit der offiziellen Toolchain. Kopiere, was du brauchst, oder probiere jeden Codeschnipsel live im Go-Playground aus - keine Installation nötig.
Go-Spickzettel FAQ
Ist dieser Go-Spickzettel kostenlos?
Ja. Dieser Go-Spickzettel ist völlig kostenlos, ohne erforderliche Anmeldung. Setze ein Lesezeichen und komm jederzeit wieder, wenn du eine Slice-Operation, ein Channel-Muster oder eine Struct-Methode nachschlagen möchtest.
Was ist der Unterschied zwischen := und var in Go?
var x = 0 deklariert eine Variable und funktioniert überall, auch auf Package-Ebene. x := 0 ist die kurze Variablendeklaration: Sie deklariert und weist zugleich zu, leitet den Typ ab und kann nur innerhalb einer Funktion verwendet werden. Verwende var, wenn du einen expliziten Typ oder eine Variable auf Package-Ebene brauchst, und := für kompakte lokale Deklarationen.Was sind Goroutinen und Channels?
Eine Goroutine ist ein leichtgewichtiger Thread, der von der Go-Laufzeit verwaltet wird - du startest eine, indem du
go someFunc() schreibst. Channels sind typisierte Pipes, über die Goroutinen sicher kommunizieren: Eine Goroutine sendet mit ch <- v und eine andere empfängt mit <-ch. Zusammen bilden sie das zentrale Nebenläufigkeitsmodell von Go, festgehalten im Leitsatz „Teile Speicher durch Kommunikation".Kann ich Go online üben?
Ja. Öffne den Go-Playground, um jeden Codeschnipsel aus diesem Spickzettel in deinem Browser auszuführen - keine Go-Toolchain zu installieren. Wenn du Struktur möchtest, führt dich Coddys kostenloser interaktiver Go-Kurs Schritt für Schritt von Variablen und Slices zu Goroutinen und Channels.
Ist dieser Spickzettel für Anfänger geeignet?
Ja. Er ist von den häufigsten Themen (Variablen, Kontrollfluss, Funktionen) hin zu den fortgeschrittenen (Goroutinen, Channels, Fehlerbehandlung) gegliedert, sodass du die oberen Abschnitte schon am ersten Tag nutzen und in den Rest hineinwachsen kannst.
Verwandte Ressourcen
Weitere Spickzettel
