Go-Dokumentation
Kompakte, beispielorientierte Go-Referenz. Konzept lesen, Code ansehen, dann in einem Coddy-Lernweg üben.
Geführten Go-Lernweg startenErste Schritte
- Was ist Go?Go (oft Golang genannt) ist eine statisch typisierte, kompilierte Sprache, die bei Google entworfen wurde, um schnelle, zuverlässige Server und Tools zu bauen. Diese Seite erklärt, was sie ist, wofür sie genutzt wird und wo sie an Grenzen stößt.
- Go installierenSo lädst du Go unter Windows, macOS und Linux herunter und installierst es, prüfst die Installation mit go version, verstehst GOPATH und behebst den Fehler „go: command not found“.
- Hello WorldDas Go-Hello-World-Programm Zeile für Zeile: package main, der Import-Block, func main und fmt.Println, dazu wie du es ausführst und welche Compilerfehler Einsteiger zuerst sehen.
- go run und go buildWas go run, go build und go install jeweils tun, wie Go das Binary benennt, wie du mit GOOS und GOARCH cross-kompilierst und welche Prüfungen mit go fmt und go vet vor dem Commit laufen sollten.
- Go-ModuleWie Go-Module funktionieren: eins mit go mod init anlegen, einen Modulpfad wählen, Abhängigkeiten mit go get hinzufügen, mit go mod tidy aufräumen, wofür go.sum da ist und replace für die lokale Entwicklung.
- Pakete und ImportsWie Go-Pakete funktionieren: die package-Klausel, Standard- und Modulpakete importieren, exportierte vs nicht exportierte Namen, ein Paket auf mehrere Dateien verteilen, interne Pakete, Import-Aliase, Blank Imports und der „undefined“-Fehler bei go run main.go.
Grundlagen
- VariablenSo deklarierst du Variablen in Go mit var und der Kurzform :=, was Nullwerte sind, Mehrfachzuweisung, und die Fehler durch Shadowing und ungenutzte Variablen, über die neue Go-Programmierer stolpern.
- KonstantenSo funktioniert const in Go: Konstanten deklarieren, der Unterschied zwischen typisierten und untypisierten Konstanten, konstante Ausdrücke mit beliebiger Genauigkeit und warum Go keine konstanten Slices, Maps oder Structs hat.
- Enums und iotaGo hat kein Schlüsselwort enum. Diese Seite zeigt den idiomatischen Ersatz, einen benannten Typ plus einen const-Block mit iota, und wie du String(), Validierung, Parsen, Bit-Flags und JSON-Unterstützung hinzufügst.
- DatentypenDie eingebauten Typen von Go: Größen und Wertebereiche der Ganzzahlen, float32 und float64, bool, string, byte und rune, komplexe Zahlen, Nullwerte und wie du den Typ eines Werts mit %T ausgibst.
- TypkonvertierungSo konvertierst du in Go zwischen Typen: int zu string und string zu int mit strconv, Floats zu Ganzzahlen, numerische Konvertierungen mit T(v), Bytes und Runes, die Falle string(65) und der Umgang mit Konvertierungsfehlern.
- StringsArbeiten mit Strings in Go: das Paket strings (Split, Join, Contains, Replace, Fields, TrimSpace, ToUpper), Strings effizient mit strings.Builder bauen, mehrzeilige Raw Strings, Unveränderlichkeit und warum len Bytes zählt.
- Runes und BytesWas rune und byte in Go bedeuten, wie Strings UTF-8 speichern, warum len Bytes zählt, wie range Runes dekodiert, Konvertieren zwischen string, []byte und []rune und die Arbeit mit dem Paket bytes.
- fmt.Printf und SprintfWie das Paket fmt von Go Werte ausgibt und formatiert: Println vs Printf vs Sprintf vs Errorf, die vollständige Tabelle der Format-Verben (%v, %+v, %d, %s, %q, %f, %T, %w und mehr), Breite, Genauigkeit und Padding.
Kontrollfluss
- if / elseSo funktionieren if, else if und else in Go: keine Klammern, Pflicht-Klammern um den Block, die if-Anweisung mit Init-Klausel und ihr Scope, das Idiom if err != nil und frühe Returns statt tiefer Verschachtelung.
- for-SchleifeGo hat ein einziges Schleifen-Schlüsselwort, for, und es deckt alles ab: die Zählschleife mit drei Klauseln, die while-Schleife nur mit Bedingung, die Endlosschleife und range über Slices, Maps, Strings, Channels, Ganzzahlen und Funktionen. Dazu break und continue mit Label und die Änderung der Schleifenvariablen in Go 1.22.
- while-SchleifeGo hat kein while-Schlüsselwort. Eine for-Schleife mit nur einer Bedingung ist die while-Schleife von Go, for ohne Bedingung ist eine Endlosschleife, und ein do-while ist eine Endlosschleife mit der Prüfung am Ende.
- range-SchleifenWas for range für Slices, Arrays, Strings, Maps, Channels, Ganzzahlen und Iterator-Funktionen liefert, warum die Wertvariable eine Kopie ist, was passiert, wenn du einen Slice oder eine Map beim Durchlaufen änderst, und range über Funktionen ab Go 1.23.
- switch-AnweisungSo funktioniert switch in Go: Cases fallen standardmäßig nicht durch, ein Case kann mehrere Werte auflisten, switch ohne Bedingung ersetzt if/else-Ketten, switch mit Init-Anweisung, das Schlüsselwort fallthrough und ein kurzer Blick auf Type Switches.
- Ternärer OperatorGo hat keinen ternären Operator (cond ? a : b). Diese Seite erklärt warum und zeigt den idiomatischen if/else-Ersatz, cmp.Or für Standardwerte und eine generische Hilfsfunktion samt der Falle, die sie von einem echten Ternary unterscheidet.
Funktionen
- FunktionenSo deklarierst und rufst du Funktionen in Go auf: Parameter, gemeinsame Parametertypen, Rückgabewerte, Übergabe als Wert und Funktionen als Werte, die du speichern und weiterreichen kannst.
- Mehrere RückgabewerteGo-Funktionen können mehrere Werte zurückgeben. Diese Seite behandelt die Syntax, die Konvention (value, error), das Comma-ok-Idiom, benannte Ergebnisse, Naked Returns und den Blank Identifier.
- Variadische FunktionenEine variadische Go-Funktion nimmt beliebig viele abschließende Argumente eines Typs an. Die ...T-Syntax, wie du mit s... einen Slice übergibst, die Aliasing-Falle und wie fmt.Println ...any nutzt.
- ClosuresAnonyme Funktionen in Go können Variablen aus dem umgebenden Scope einfangen. Daraus entstehen Closures: Zähler, Generatoren, Middleware und Callbacks mit eigenem Zustand.
- defer-Anweisungdefer plant einen Aufruf ein, der läuft, wenn die umgebende Funktion zurückkehrt. LIFO-Reihenfolge, wann Argumente ausgewertet werden, Dateien schließen und Mutexe entsperren, defer in Schleifen und benannte Ergebnisse ändern.
- MethodenEine Methode ist eine Funktion mit einem Receiver. So deklarierst du Methoden, wann du einen Value oder Pointer Receiver nimmst, Method Sets und Interfaces sowie Methoden auf Typen, die keine Structs sind.
Sammlungen
- ArraysEin Go-Array hat eine feste Länge, die Teil seines Typs ist, und wird bei der Zuweisung kopiert. So deklarierst, durchläufst, vergleichst und übergibst du Arrays, und warum der meiste Go-Code stattdessen Slices nutzt.
- SlicesSlices sind der alltägliche Listentyp von Go. make, append und Wachstum, len vs cap, wie Slicing das Backing-Array teilt (und welchen Bug das verursacht), copy, das Paket slices, 2D-Slices und nil vs leer.
- MapsGo-Maps speichern Schlüssel-Wert-Paare mit schnellem Lookup. So erzeugst du sie, prüfst mit Comma-ok, ob ein Schlüssel existiert, löschst, durchläufst sie (in zufälliger Reihenfolge), sortierst Schlüssel, speicherst Structs und vermeidest die Panics bei nil-Maps und nebenläufigem Schreiben.
- SetsGo hat keinen eingebauten Set-Typ. Das übliche Idiom ist eine Map mit leeren Struct-Werten. Hinzufügen, prüfen und entfernen, Vereinigung, Schnittmenge und Differenz, und wie du ein kleines generisches Set schreibst.
- SortierenSlices in Go mit slices.Sort und slices.SortFunc sortieren, Structs mit cmp.Compare nach einem oder mehreren Feldern sortieren, gleiche Elemente mit einer stabilen Sortierung in ihrer Reihenfolge halten und älteren Code mit sort.Slice lesen.
Structs, Interfaces und Generics
- StructsStructs fassen benannte Felder zu einem Typ zusammen. So definierst und initialisierst du sie, Nullwerte, Pointer auf Structs, anonyme Structs, Vergleiche, Struct Tags und die Konvention der NewX-Konstruktoren.
- PointerEin Pointer enthält die Adresse eines Werts. & und *, new, Pointer auf Structs, warum du gefahrlos einen Pointer auf eine lokale Variable zurückgeben kannst, wann sich Pointer lohnen und die Panic bei nil pointer dereference.
- InterfacesGo-Interfaces werden implizit erfüllt: Jeder Typ mit den passenden Methoden implementiert sie. Kleine Interfaces wie io.Reader und fmt.Stringer, das leere Interface any, die Falle mit nil-Interfaces und die Regel: Interfaces annehmen, Structs zurückgeben.
- Struct EmbeddingEmbedding setzt einen Typ ohne Feldnamen in einen anderen, sodass seine Felder und Methoden in den äußeren Typ befördert werden. Wie die Promotion funktioniert, Interfaces einbetten, Namenskonflikte und warum Embedding keine Vererbung ist.
- Type AssertionsEine Type Assertion holt den konkreten Wert aus einem Interface. x.(T), die Comma-ok-Form ohne Panic, Assertion auf ein anderes Interface, Type Switches und errors.As für gewrappte Fehler.
- GenericsMit Generics (ab Go 1.18) funktioniert eine Funktion oder ein Typ mit vielen Typen und bleibt dabei typsicher. Typparameter, die Constraints any, comparable und cmp.Ordered, eigene Constraints mit ~, generische Typen und wann du sie besser nicht nutzt.
Fehler
- FehlerbehandlungGo behandelt Fehler als gewöhnliche Werte, die Funktionen zurückgeben. Das Interface error, if err != nil, errors.New und fmt.Errorf, Fehler mit Kontext zurückgeben, sie mit errors.Is und errors.As prüfen und jeden Fehler nur einmal behandeln.
- Eigene FehlerSentinel-Fehler und eigene Fehlertypen definieren, Fehler mit %w wrappen, mit errors.Is und errors.As prüfen, mehrere mit errors.Join zusammenfassen und bei Bedarf Unwrap- und Is-Methoden schreiben.
- panic und recoverEine Panic stoppt die normale Ausführung und baut den Stack ab, wobei per defer eingeplante Aufrufe laufen. Was Panics auslöst, wie recover in einer defer-Funktion eine stoppt, welche Laufzeit-Fehlermeldungen du siehst und wann eine Panic die richtige Wahl ist.
Nebenläufigkeit
- GoroutinenSo führst du Funktionen mit dem Schlüsselwort go nebenläufig aus, wartest, bis sie fertig sind, bekommst Ergebnisse zurück und vermeidest die Data Races, Leaks und Abstürze, die Goroutinen leicht machen.
- ChannelsWie Go-Channels Werte zwischen Goroutinen übergeben: ungepufferte und gepufferte Channels, Schließen und range, Richtungstypen, der Deadlock-Fehler und eine daraus gebaute Pipeline.
- select-AnweisungWie select auf mehrere Channel-Operationen gleichzeitig wartet: Auswahl unter bereiten Cases, nicht blockierendes Senden und Empfangen mit default, Timeouts mit time.After und Schleifen mit einem Quit-Channel oder Context beenden.
- WaitGroupWie sync.WaitGroup darauf wartet, dass eine Gruppe von Goroutinen fertig wird: die Regeln für Add, Done und Wait, warum sie per Pointer übergeben werden muss, Ergebnisse und Fehler einsammeln und ein Worker-Pool darauf aufgebaut.
- MutexSo schützt du geteilten Zustand zwischen Goroutinen mit sync.Mutex und sync.RWMutex, wann sync/atomic reicht, wie sync.Once die Initialisierung genau einmal ausführt und welche Fehler beim Sperren zu Deadlocks führen.
- Paket contextWie context.Context Abbruchsignale, Deadlines und Werte eines Requests durch ein Go-Programm trägt: Background, WithCancel, WithTimeout, WithValue, ctx.Done in select und Context in HTTP-Servern und Clients.
Standardbibliothek
- Paket timeSo arbeitest du in Go mit Datum und Uhrzeit: time.Now und time.Sleep, Rechnen mit Duration, das Referenzlayout 2006-01-02 15:04:05 für Format und Parse, Zeitzonen, Unix-Zeitstempel sowie Timer und Ticker.
- JSONSo kodierst und dekodierst du JSON in Go mit encoding/json: Marshal und Unmarshal, Struct Tags wie omitempty und omitzero, formatierte Ausgabe, Dekodieren in map[string]any, unbekannte Felder ablehnen und Streaming mit Decoder.
- Dateien lesen und schreibenSo liest und schreibst du Dateien in Go: os.ReadFile und os.WriteFile, zeilenweise lesen mit bufio.Scanner, mit os.OpenFile anhängen, prüfen, ob eine Datei existiert, und mit Verzeichnissen arbeiten.
- HTTP-ServerSo baust du einen Webserver mit dem Standardpaket net/http von Go: Handler, Routing mit ServeMux samt Methoden und Pfad-Wildcards (Go 1.22), JSON-Antworten, Statuscodes, Middleware, Timeouts und Graceful Shutdown.
- HTTP-ClientSo stellst du in Go mit net/http HTTP-Requests: http.Get, den Body lesen und schließen, Statuscodes prüfen, Timeouts mit http.Client, Requests mit Context und Headern, Query-Parameter und JSON per POST senden.
- KommandozeilenargumenteWie ein Go-Programm seine Kommandozeile liest: os.Args, das Paket flag für typisierte Optionen, Unterbefehle mit FlagSet, Umgebungsvariablen mit os.Getenv und os.LookupEnv und Exit-Codes mit os.Exit.
- Reguläre AusdrückeSo nutzt du reguläre Ausdrücke in Go mit dem Paket regexp: MustCompile, MatchString, FindString und FindAllString, Capture Groups und benannte Gruppen, ReplaceAllString und die Grenzen der RE2-Syntax wie das fehlende Lookbehind.
- LoggingSo loggst du in Go: das klassische Paket log mit seinen Flags und log.Fatal und log/slog (Go 1.21) für strukturierte Logs mit Levels, Schlüssel-Wert-Attributen, Text- und JSON-Handlern und Loggern, die per With Kontext mitführen.
Tests und Projektstruktur
- TestingSo testest du Go-Code mit dem Standardpaket testing und go test: _test.go-Dateien, TestXxx-Funktionen, t.Errorf gegenüber t.Fatalf, tabellengesteuerte Tests mit t.Run, Helfer und temporäre Verzeichnisse, Coverage, Benchmarks mit b.Loop und Example-Tests.
- ProjektstrukturSo strukturierst du ein Go-Projekt: flach anfangen, in Pakete aufteilen, wenn es einen Grund gibt, cmd/ für mehrere Binaries und internal/ für Code, den niemand sonst importieren darf, Pakete gut benennen und Tests neben den Code legen.
