Go-Kurs

Die Grundlagen: Packages, Variablen, Typen, Konstanten, Operatoren und Ein-/Ausgabe mit dem fmt-Package.

1. 1.1Variablen und Typenvar, die Kurzdeklaration `:=`, Basis-Typen (int, float64, string, bool) und das Konzept der statischen Typisierung.~10 Min
2. 1.2Zero Value und TypkonvertierungenJede Variable hat einen Standardwert; Konvertierungen sind explizit (`int(x)`, `string(b)`).~10 Min
3. 1.3Konstanten und iota`const`, untypische Konstanten und das `iota`-Muster zur Generierung lesbarer Aufzählungen.~10 Min
4. 1.4OperatorenArithmetische, Vergleichs-, logische und bitweise Operatoren; Rangfolge und Unterschiede zu anderen Sprachen.~8 Min
5. 1.5Ein-/Ausgabe mit fmt`fmt.Println`, `fmt.Printf`, Format-Verben (`%d`, `%s`, `%v`, `%T`) und wann welches zu bevorzugen ist.~10 Min

Entscheidungen und Schleifen: if mit Initialisierung, das einzige `for`, idiomatische Switches und explizite Fehlerbehandlung.

1. 2.1if, else und InitialisierungDie Form `if v := f(); v > 0 { ... }` und warum Go keinen ternären Operator hat.~10 Min
2. 2.2for: die einzige SchleifeThe three forms of `for`: three-clause, single-condition (= while), and infinite; using `break` and `continue`.~10 Min
3. 2.3for...rangeÜber Slices, Maps und Strings iterieren; der zurückgegebene Wert ist eine Kopie; wann Index oder Wert mit `_` zu ignorieren sind.~10 Min
4. 2.4Idiomatisches switchKein impliziter Fallthrough, komplexe Ausdrücke in Cases, Switch ohne Bedingung als if-Kette.~10 Min
5. 2.5Fehler: das `if err != nil`-MusterFehler sind Werte; das grundlegende Muster `if err != nil { return err }` und warum Go keine Exceptions hat.~12 Min

Funktionen als First-Class-Citizens: Signaturen, mehrere Rückgabewerte, variadische Parameter, Closures und `defer`.

1. 3.1Signatur und Parameter`func name(p type) type`-Syntax, standardmäßig Wertübergabe (pass-by-value), Parameter des gleichen Typs zusammen gruppiert.~10 Min
2. 3.2Mehrere Rückgabewerte und benannte RückgabenMehrere Werte zurückgeben (`value, err`), benannte Rückgaben und wann man sie NICHT verwenden sollte.~12 Min
3. 3.3Variadische Funktionen`func sum(nums ...int) int`, ein Slice mit `slice...` entpacken, Beispiele aus der Standardbibliothek.~10 Min
4. 3.4Closures und Funktionen als WerteAnonyme Funktionen, die Variablen aus dem umgebenden Kontext erfassen; Adapter- und Factory-Muster.~12 Min
5. 3.5defer: garantierte BereinigungAusführung bis zum Return aufschieben; das `defer f.Close()`-Muster, LIFO-Reihenfolge, Fallstricke in Schleifen.~12 Min

Arrays, Slices (die wichtigste Struktur), Maps, Runen in Strings und Sortierung.

1. 4.1Arrays mit fester Länge`[N]T`-Syntax, warum echte Arrays in Go selten verwendet werden, Konvertierung von Array zu Slice.~8 Min
2. 4.2Slices: die idiomatische Struktur`make`, `append`, len/cap, Slicing `s[a:b]`, Teilen des zugrunde liegenden Arrays und wann kopiert werden sollte.~15 Min
3. 4.3Maps: Keys und WerteDeklaration, Comma-ok-Zugriff (`v, ok := m[k]`), `delete`, nicht-deterministische Iteration.~12 Min
4. 4.4Strings, Bytes und RunenStrings sind UTF-8-Bytes; `range` liefert Runen; `len()` zählt Bytes, nicht Zeichen.~12 Min
5. 4.5Sortieren mit dem sort-Package`sort.Ints`, `sort.Strings`, `sort.Slice` mit Vergleichsfunktion, Stabilität.~10 Min

Zusammengesetzte Datentypen: Structs, Methoden auf Wert- oder Zeiger-Receivern, Komposition (keine Vererbung) und Tags.

1. 5.1Strukturen definieren und verwenden`type Person struct { Name string; Age int }`, positionelle vs. benannte Initialisierung, anonyme Structs.~12 Min
2. 5.2Methoden: Wert- vs. Zeiger-Receiver`func (p Person) Hello()` vs. `func (p *Person) Rename(n string)`; wann welches zu verwenden ist.~14 Min
3. 5.3Komposition (Embedding)Go hat keine Vererbung: Du komponierst, indem du einen Typ in einen anderen einbettest. Methoden-Promotion.~12 Min
4. 5.4Feld-Tags und JSON`json:"name,omitempty"`, marshalling/unmarshalling with `encoding/json`, common mistakes.~12 Min
5. 5.5Das `New...`-KonstruktormusterGo hat keine Konstruktoren: Die Konvention ist eine `NewT(...) *T`-Funktion, die validiert und Fehler zurückgibt.~10 Min

Strukturelle Interfaces (kein explizites implements), Assertions, Type-Switches und die Standard-Interfaces `Stringer` und `error`.

1. 6.1Interfaces: Verhalten definierenEin Interface ist eine Reihe von Methoden; wer sie implementiert, erfüllt es automatisch (statisches Duck-Typing).~12 Min
2. 6.2Type Assertion`v, ok := i.(*MyT)`, die Comma-ok-Form zur Vermeidung von Panics, wann eine Assertion einem Type-Switch vorzuziehen ist.~10 Min
3. 6.3Type-Switch`switch v := x.(type) { case int: ... }` zur Verteilung basierend auf dem Laufzeittyp.~10 Min
4. 6.4Das Stringer-InterfaceDas Implementieren von `String() string` ändert, wie `fmt.Println` deinen Typ darstellt.~10 Min
5. 6.5Das error-Interface`error` ist einfach `Error() string`; eigene Fehler erstellen, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 Min

Das Go-Nebenläufigkeitsmodell: leichtgewichtige Goroutinen, Kanäle für Kommunikation, `select`, Synchronisation und Kontext.

1. 7.1Goroutinen: leichtgewichtiger Parallelismus`go f()`, die Kosten einer Goroutine, warum main beendet wird, ohne zu warten, und wie synchronisiert wird.~12 Min
2. 7.2Kanäle: typisierte Kommunikation`ch := make(chan int)`, `ch <- v`, `v := <-ch`, gepufferte vs. ungepufferte Kanäle, Schließen.~15 Min
3. 7.3`select`: Multiplexing von KanälenAuf den ersten bereiten Kanal warten, der `default`-Fall zur Vermeidung von Blockaden, das Timeout-Muster mit `time.After`.~12 Min
4. 7.4`sync.Mutex` und `sync.WaitGroup`Wenn Kanäle nicht ausreichen: Schützen des geteilten Zustands mit einem Mutex, Warten auf N Goroutinen mit einer WaitGroup.~14 Min
5. 7.5`context.Context`: Abbruch und DeadlinesAbbruch über Goroutinen weitergeben, `context.WithTimeout`, `ctx.Done()`, das Muster mit dem ersten Parameter.~14 Min

Die Packages, die du täglich brauchst: fmt, strings, strconv, io, os, time, encoding/json.

1. 8.1Fortgeschrittenes `fmt``Sprintf`, `Fprintf`, die Verben `%+v` und `%#v`, Breiten- und Präzisionsformatierung, die Flags `-` und `0`.~10 Min
2. 8.2`strings` und `strconv``strings.Contains/Split/Join/TrimSpace`, `strconv.Itoa/Atoi/ParseInt/FormatFloat`.~12 Min
3. 8.3`io` und `os`: Dateien und Streams`os.Open/Create/ReadFile/WriteFile`, die `io.Reader/Writer`-Interfaces, das `defer f.Close()`-Muster.~14 Min
4. 8.4Das `time`-Package`time.Now()`, Dauern, Parsen mit dem Referenz-Layout `2006-01-02 15:04:05`, Timer und Ticker.~12 Min
5. 8.5`encoding/json``json.Marshal/Unmarshal`, Struct-Tags, `json.Decoder/Encoder` für Streams, Parsing-Fehler.~14 Min

Das `go test`-Tool, datengesteuerte Tests (table-driven), Benchmarks, Abhängigkeitsverwaltung mit `go mod` und Build-Tags.

1. 9.1Das `testing`-Package`*_test.go`-Dateien, `TestXxx(t *testing.T)`-Funktionen, `t.Error` vs. `t.Fatal`, `go test ./...`.~12 Min
2. 9.2Datengesteuerte Tests (Table-driven)Das idiomatische Muster: ein Slice anonymer Structs mit Eingaben und erwarteten Ausgaben, `t.Run(name, ...)` für Sub-Tests.~14 Min
3. 9.3Benchmarks und Profile`BenchmarkXxx(b *testing.B)`-Funktionen, die `for i := 0; i < b.N; i++`-Schleife, `go test -bench=.`.~12 Min
4. 9.4Go-Module`go mod init`, `go get`, semantische Import-Versionierung, das `go.sum`-Lockfile, `go mod tidy`.~12 Min
5. 9.5Build-Constraints und TagsDie `//go:build ...`-Direktive für plattformübergreifende Builds, Trennung von Test-/Integrationscode, reale Beispiele.~10 Min

Namenskonventionen, fortgeschrittene Fehlerbehandlung, Generics (Go 1.18+) und zwei Miniprojekte: ein CLI und ein HTTP-Server.

1. 10.1Namenskonventionen und StilPascalCase für Exporte, camelCase für lokale Variablen, kurze Namen in kleinen Gültigkeitsbereichen, `gofmt` ist nicht verhandelbar.~10 Min
2. 10.2Idiomatische FehlerbehandlungSentinel-Fehler (`io.EOF`), benutzerdefinierte Fehler mit `Unwrap`, Verpacken mit `%w`, wann `panic` zu verwenden ist.~14 Min
3. 10.3Generics (Go 1.18+)Typ-Parameter `func Map[T, U any](s []T, f func(T) U) []U`, Constraints (`comparable`, eigene), Trade-offs.~15 Min
4. 10.4Miniprojekt: ein CLI mit FlagsDas `flag`-Package, Befehle und Unterbefehle, Exit-Codes, `log` vs. `fmt` für Ausgaben.~18 Min
5. 10.5Miniprojekt: ein HTTP-Server`net/http`, minimaler Handler und Router, Middleware als Dekoratoren, Graceful Shutdown mit Kontext.~18 Min