Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang A: Spickzettel

Getestet mit Go 1.26.9 und golangci-lint 2.14.0 auf macOS (Apple Silicon). Die Code-Schnipsel sind Ausschnitte aus übersetzten und getesteten Dateien; in eckigen Klammern steht der Tag, an dem das Thema ausführlich vorkommt.

Syntax und Idiome

Typen, Konstanten, Methoden und Funktionen auf Paketebene [Tag 1, 2]:

type Level int

const (
    Debug Level = iota // 0, 1, 2 …
    Info
    Warn
)

type Entry struct {
    Path   string `json:"path"` // Struct-Tag für encoding/json
    Status int    `json:"status,omitempty"`
}

type Summary struct{ n int }

func (s *Summary) Add(e Entry) { s.n++ } // Pointer-Receiver: darf ändern
func (s Summary) Count() int   { return s.n }

type Server struct {
    *slog.Logger // Embedding: s.Info(...) ruft s.Logger.Info(...)
    addr         string
}

func div(a, b int) (int, error) { // mehrere Rückgabewerte, Fehler zuletzt
    if b == 0 {
        return 0, fmt.Errorf("division durch 0")
    }
    return a / b, nil
}

In einer Funktion:

var n int    // Nullwert: 0, "", false, nil
s := "Grüße" // Typ wird abgeleitet
x, y := 1, 2
x, y = y, x   // Tausch ohne Hilfsvariable
p := new(int) // *int auf 0; seit Go 1.26 auch new(42)
e := Entry{Path: "/", Status: 200}
ep := &Entry{Path: "/api"} // Pointer auf Struct-Literal
ep.Status = 201            // automatisch dereferenziert

if v, ok := m["k"]; ok { // Init-Anweisung, Gültigkeit nur im if
    fmt.Println(v)
}
switch {
case n < 0:
    fmt.Println("negativ")
case n == 0, n == 1:
    fmt.Println("klein") // kein break nötig, fallthrough explizit
default:
    fmt.Println("groß")
}
for i := range 3 { // 0, 1, 2 (Go 1.22)
    fmt.Println(i)
}
for i, r := range s { // Byte-Index und Rune
    fmt.Println(i, string(r))
}
for n < 10 { // "while"
    n++
}
defer f.Close()                         // läuft beim Verlassen, LIFO
add := func(a int) int { return a + n } // Closure sieht n
Verb Ausgabe Beispiel
%v / %+v Wert / mit Feldnamen {/api 201} / {Path:/api Status:201}
%#v Go-Syntax main.Entry{Path:"/api", Status:201}
%q / %T gequotet / Typ "a\tb" / main.Entry
%w nur in fmt.Errorf: Fehler einwickeln fmt.Errorf("x: %w", err)

Zeitformate schreibst du mit dem Referenzdatum 2006-01-02 15:04:05 -0700 oder den Konstanten time.DateOnly, time.DateTime, time.RFC3339 [Tag 2, 7].

Slices, Maps, Strings

Slices [Tag 1]:

s := []string{"helm", "kubectl"}
s = append(s, "bao")         // kann neu allokieren: immer zuweisen
buf := make([]byte, 0, 4096) // Länge 0, Kapazität 4096
t := s[1:3]                  // Sicht auf dasselbe Array, keine Kopie
c := slices.Clone(s)         // echte Kopie
slices.Sort(s)               // aufsteigend
slices.SortFunc(s, func(a, b string) int { return cmp.Compare(len(a), len(b)) })
i := slices.Index(s, "bao") // -1, wenn nicht da
ok := slices.Contains(s, "helm")
s = slices.DeleteFunc(s, func(x string) bool { return x == "helm" })

Maps [Tag 1, 2]:

m := map[string]int{"http": 80} // Literal
m["https"] = 443
v, found := m["ssh"] // comma-ok: 0, false
delete(m, "http")
for _, k := range slices.Sorted(maps.Keys(m)) { // sortiert ausgeben
    fmt.Println(k, m[k])
}
var nilMap map[string]int           // lesen ok, schreiben: panic
clear(m)                            // alle Einträge löschen
set := map[string]struct{}{"a": {}} // Set ohne Speicher für Werte

Strings und Zahlen [Tag 1, 4]:

before, after, cut := strings.Cut("k=v=w", "=") // "k", "v=w", true
rest, hadV := strings.CutPrefix("v1.2.3", "v")
fields := strings.Fields("  a  b ")                // ["a" "b"]
for part := range strings.SplitSeq("a,b,c", ",") { // Iterator, Go 1.24
    fmt.Println(part)
}
var sb strings.Builder // effizient zusammensetzen
fmt.Fprintf(&sb, "%s=%d\n", "port", 8080)
n, err := strconv.Atoi("42")
q := strconv.Quote("a\tb")               // "\"a\\tb\""
runes := utf8.RuneCountInString("Grüße") // 5 Zeichen, len() = 7 Bytes

Fehler

Sentinel und eigener Typ [Tag 3]:

var ErrNotFound = errors.New("nicht gefunden") // Sentinel

type CheckError struct { // eigener Typ mit Daten
    Name string
    Err  error
}

func (e *CheckError) Error() string { return e.Name + ": " + e.Err.Error() }
func (e *CheckError) Unwrap() error { return e.Err } // für Is/As

Einwickeln und prüfen:

data, err := os.ReadFile(path)
if err != nil {
    return fmt.Errorf("config %s: %w", path, err) // Kontext + Ursache
}
if errors.Is(err, fs.ErrNotExist) { // Sentinel irgendwo in der Kette?
    fmt.Println("fehlt")
}
var ce *CheckError
if errors.As(err, &ce) { // Typ in der Kette? Dann ce befüllt
    fmt.Println(ce.Name)
}
if ce, ok := errors.AsType[*CheckError](err); ok { // Go 1.26
    fmt.Println(ce.Name)
}
both := fmt.Errorf("%w (%w)", ErrNotFound, err)           // zwei Ursachen
all := errors.Join(errors.New("a"), nil, errors.New("b")) // nil wird ignoriert

Panic nur an Grenzen abfangen (benannter Rückgabewert err):

defer func() { // panic in Fehler verwandeln – nur an Grenzen (Handler, Worker)
    if r := recover(); r != nil {
        err = fmt.Errorf("panic: %v", r)
    }
}()

Regeln: Fehler nie ignorieren und nie doppelt behandeln (loggen oder zurückgeben), nie Fehlertexte per strings.Contains vergleichen, keine Secrets in Fehlermeldungen.

Interfaces und Generics

Interfaces werden implizit erfüllt [Tag 2]:

type Parser interface { // klein halten: eine Methode
    Parse(line string) (Entry, error)
}

type JSONParser struct{}

func (JSONParser) Parse(line string) (Entry, error) { return Entry{}, nil }

var _ Parser = JSONParser{} // Compiler prüft: erfüllt das Interface

func describe(v any) string {
    switch x := v.(type) { // Typ-Switch
    case nil:
        return "nil"
    case string:
        return "string " + x
    case fmt.Stringer:
        return x.String()
    case io.Reader:
        return "Reader"
    default:
        return fmt.Sprintf("%T", x)
    }
}

Generics [Tag 13]:

func Map[T, U any](in []T, f func(T) U) []U {
    out := make([]U, 0, len(in))
    for _, v := range in {
        out = append(out, f(v))
    }
    return out
}

func MaxOf[T cmp.Ordered](a, b T) T { return max(a, b) } // max ist eingebaut

type Number interface{ ~int | ~int64 | ~float64 } // Type Set, ~ = auch eigene Typen

func Sum[T Number](xs ...T) (s T) {
    for _, x := range xs {
        s += x
    }
    return s
}

type Set[T comparable] map[T]struct{}

func (s Set[T]) Add(v T)          { s[v] = struct{}{} }
func (s Set[T]) Has(v T) bool     { _, ok := s[v]; return ok }
func (s Set[T]) All() iter.Seq[T] { return maps.Keys(s) }

Iteratoren (range-over-func) [Tag 4, 13]:

func Lines(text string) iter.Seq2[int, string] { // eigener Iterator
    return func(yield func(int, string) bool) {
        for i, l := range strings.Split(text, "\n") {
            if !yield(i+1, l) { // false: Aufrufer hat break gemacht
                return
            }
        }
    }
}

func useIter() {
    for n, l := range Lines("a\nb") { // range-over-func, Go 1.23
        fmt.Println(n, l)
    }
    names := slices.Collect(maps.Keys(map[string]int{"a": 1})) // Seq -> Slice
    sorted := slices.Sorted(slices.Values([]int{3, 1, 2}))
    fmt.Println(names, sorted)
}

Goroutines, Channels, select

var wg sync.WaitGroup
for _, u := range urls {
    wg.Go(func() { _ = check(u) }) // Go 1.25; jede Iteration hat eigenes u
}
wg.Wait()

ch := make(chan int, 10) // gepuffert: Senden blockiert erst bei 10
go func() {
    defer close(ch) // nur der Sender schließt
    for i := range 3 {
        ch <- i
    }
}()
for v := range ch { // endet nach close
    fmt.Println(v)
}

select { // wartet auf das erste bereite Ereignis
case v, ok := <-ch:
    fmt.Println(v, ok) // ok == false: Channel geschlossen
case <-time.After(2 * time.Second):
    fmt.Println("Timeout")
case <-ctx.Done():
    return ctx.Err()
}

Worker-Pool mit fester Größe [Tag 8, 15]:

results := make([]error, len(urls))
jobs := make(chan int)
for range 8 { // 8 Worker
    wg.Go(func() {
        for i := range jobs {
            results[i] = check(urls[i]) // eigener Index: kein Lock
        }
    })
}
for i := range urls {
    jobs <- i
}
close(jobs)
wg.Wait()

errgroup mit Limit und Abbruch (golang.org/x/sync/errgroup) [Tag 8]:

g, gctx := errgroup.WithContext(ctx) // erster Fehler bricht gctx ab
g.SetLimit(4)                        // höchstens 4 gleichzeitig
for _, u := range urls {
    g.Go(func() error {
        req, err := http.NewRequestWithContext(gctx, http.MethodHead, u, nil)
        if err != nil {
            return err
        }
        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return fmt.Errorf("%s: %w", u, err)
        }
        return resp.Body.Close()
    })
}
if err := g.Wait(); err != nil { // wartet auf alle, liefert ersten Fehler
    return err
}

Mutex, atomic, Once:

var mu sync.Mutex // schützt zusammengehörige Felder
counts := map[string]int{}
mu.Lock()
counts["a"]++
mu.Unlock()

var n atomic.Int64 // einzelner Zähler: atomic reicht
n.Add(1)

loadConfig := sync.OnceValue(func() string { return "einmal berechnet" })
fmt.Println(loadConfig(), n.Load())
Regel Warum
Jede Goroutine braucht ein Ende (ctx, close) sonst Goroutine-Leck
Nur der Sender schließt einen Channel Senden auf geschlossenen Channel: panic
nil-Channel im select blockiert für immer so schaltet man Fälle ab
Geteilter Zustand: Mutex oder Channel, nie „geht schon” go test -race findet es

context

ctx, stop := signal.NotifyContext(context.Background(),
    os.Interrupt, syscall.SIGTERM) // Strg+C, Pod-Stopp
defer stop()

ctx, cancel := context.WithTimeout(ctx, 15*time.Second) // Gesamtbudget
defer cancel()                                          // immer: gibt Timer frei

err := work(ctx) // ctx immer als ersten Parameter durchreichen
if errors.Is(err, context.DeadlineExceeded) {
    return errors.New("zu langsam")
}

ctx2, cancel2 := context.WithCancelCause(ctx)
cancel2(errors.New("config ungültig"))
log.Println(context.Cause(ctx2)) // "config ungültig" statt nur "canceled"

auditCtx := context.WithoutCancel(ctx) // Audit-Log auch nach Abbruch schreiben
writeAudit(auditCtx)

ctx ist immer der erste Parameter, nie ein Struct-Feld. Für Werte (context.WithValue) nur Request-Metadaten wie Trace-IDs, keine Konfiguration [Tag 7].

net/http: Server

ServeMux mit Methoden und Platzhaltern, Middleware, Timeouts, Graceful Shutdown [Tag 9]:

func newMux(log *slog.Logger) http.Handler {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusNoContent)
    })
    mux.HandleFunc("GET /api/links/{code}", func(w http.ResponseWriter,
        r *http.Request) {
        code := r.PathValue("code") // Platzhalter aus dem Muster, Go 1.22
        w.Header().Set("Content-Type", "application/json")
        _ = json.NewEncoder(w).Encode(map[string]string{"code": code})
    })
    return logging(log, mux)
}

func logging(log *slog.Logger, next http.Handler) http.Handler { // Middleware
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Info("request", "method", r.Method, "path", r.URL.Path,
            "dauer", time.Since(start))
    })
}

func serve(ctx context.Context, h http.Handler) error {
    srv := &http.Server{Addr: "127.0.0.1:8080", Handler: h,
        ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second,
        WriteTimeout: 10 * time.Second, IdleTimeout: 60 * time.Second}
    errc := make(chan error, 1)
    go func() { errc <- srv.ListenAndServe() }()
    select {
    case err := <-errc:
        return err
    case <-ctx.Done(): // SIGTERM: keine neuen Verbindungen, laufende fertig
    }
    sctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    if err := srv.Shutdown(sctx); err != nil {
        return err
    }
    if err := <-errc; !errors.Is(err, http.ErrServerClosed) {
        return err
    }
    return nil
}

net/http: Client

func getJSON(ctx context.Context, c *http.Client, url string, v any) error {
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        return err
    }
    req.Header.Set("Accept", "application/json")
    if tok := os.Getenv("API_TOKEN"); tok != "" { // Token nur aus der Umgebung
        req.Header.Set("Authorization", "Bearer "+tok)
    }
    resp, err := c.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close() // immer schließen, sonst leckt die Verbindung
    if resp.StatusCode != http.StatusOK {
        msg, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
        return fmt.Errorf("%s: %s: %s", url, resp.Status, msg)
    }
    return json.NewDecoder(resp.Body).Decode(v)
}

var client = &http.Client{Timeout: 5 * time.Second} // nie den Default ohne Timeout

Retries nur bei 429, 5xx und Netzfehlern, mit Backoff und Retry-After, nur für idempotente Anfragen [Tag 7].

slog

opts := &slog.HandlerOptions{Level: slog.LevelInfo} // Debug wird verworfen
var h slog.Handler = slog.NewJSONHandler(os.Stdout, opts)
if dev {
    h = slog.NewTextHandler(os.Stderr, opts) // lesbar im Terminal
}
log := slog.New(h).With("app", "shorturl", "version", "0.1.0")
slog.SetDefault(log) // auch für slog.Info(...) und das alte log-Paket
log.Info("start", "addr", ":8080")
log.Error("db", "err", os.ErrNotExist, slog.Group("req", "id", 42))
testLog := slog.New(slog.DiscardHandler) // Tests: nichts ausgeben, Go 1.24

Testing

func TestDiv(t *testing.T) {
    tests := []struct {
        name    string
        a, b    int
        want    int
        wantErr bool
    }{
        {"normal", 6, 3, 2, false},
        {"durch null", 1, 0, 0, true},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) { // Subtest: go test -run 'TestDiv/null'
            got, err := div(tt.a, tt.b)
            if (err != nil) != tt.wantErr || got != tt.want {
                t.Errorf("div(%d, %d) = %d, %v; will %d", tt.a, tt.b, got, err, tt.want)
            }
        })
    }
}

func writeFile(t *testing.T, content string) string {
    t.Helper()                               // Fehler zeigen auf den Aufrufer
    p := filepath.Join(t.TempDir(), "x.txt") // wird automatisch gelöscht
    if err := os.WriteFile(p, []byte(content), 0o600); err != nil {
        t.Fatal(err) // Fatal bricht den Test ab, Errorf nicht
    }
    return p
}

func TestHTTP(t *testing.T) {
    t.Setenv("API_TOKEN", "lab-token") // nach dem Test zurückgesetzt
    srv := httptest.NewServer(http.HandlerFunc(
        func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, `{}`) }))
    t.Cleanup(srv.Close)
    var v map[string]any
    if err := getJSON(t.Context(), srv.Client(), srv.URL, &v); err != nil { // 1.24
        t.Fatal(err)
    }
    _ = writeFile(t, "a")
}

func FuzzCut(f *testing.F) {
    f.Add("k=v") // Seeds: Grenzfälle gehören hierher
    f.Fuzz(func(t *testing.T, s string) {
        k, v, ok := strings.Cut(s, "=")
        if ok && k+"="+v != s {
            t.Errorf("Cut(%q) verliert Daten", s)
        }
    })
}

func BenchmarkDiv(b *testing.B) {
    for b.Loop() { // Go 1.24: misst nur den Rumpf
        _, _ = div(10, 3)
    }
}

func TestTimeout(t *testing.T) {
    synctest.Test(t, func(t *testing.T) { // Go 1.25: virtuelle Uhr, kein Warten
        ctx, cancel := context.WithTimeout(t.Context(), time.Hour)
        defer cancel()
        <-ctx.Done() // "dauert" eine Stunde, läuft in Mikrosekunden
    })
}
# Alles, ohne Cache, mit Race-Detector; zufällige Reihenfolge, beim 1. Fehler stoppen
go test -race -count=1 ./...
go test -shuffle=on -failfast ./...
# Einzelne Tests und Subtests (Regex pro Ebene, getrennt durch /)
go test -run 'TestDiv/null' -v ./...
# Coverage: Übersicht, pro Funktion, im Browser
go test -cover ./...
go test -coverprofile=cover.out ./... && go tool cover -func=cover.out
go tool cover -html=cover.out
# Fuzzing: genau ein Fuzz-Test, ein Paket; Funde landen in testdata/fuzz/
go test -run '^$' -fuzz '^FuzzCut$' -fuzztime 30s .
# Benchmarks mit Allokationen; zum Vergleichen mehrfach laufen lassen
go test -run '^$' -bench . -benchmem -count=10 ./... > neu.txt
go run golang.org/x/perf/cmd/benchstat@latest alt.txt neu.txt
# Golden Files neu schreiben (eigenes Flag im Test, Tag 4) – danach git diff lesen
go test ./cmd/semver -run Golden -update
# Maschinenlesbar für CI, Testcache leeren
go test -json ./... > test.json
go clean -testcache

Das go-Kommando

go version && go env GOOS GOARCH GOPATH GOMODCACHE
go run ./cmd/tool -flag wert            # bauen und starten
go build -o bin/ ./cmd/...              # alle Kommandos nach bin/
go install ./cmd/tool                   # nach $(go env GOPATH)/bin
gofmt -l . && go vet ./...              # Format und Analyse
go fix -diff ./...                      # Modernizer zeigen (Go 1.26)
go doc errors.AsType                    # Doku im Terminal, auch für eigene Pakete
go doc -all ./internal/logs
go list -f '{{.ImportPath}}: {{.Imports}}' ./...
go version -m bin/tool                  # Build-Infos aus einem Binary
go tool                                 # mitgelieferte Tools (cover, pprof, ...)
go generate ./...                       # //go:generate-Kommentare ausführen
go clean -cache                         # Build-Cache leeren
~/go-lab/bin/lint run ./...             # golangci-lint, Tag 0

Module

go mod init example.com/tool
go get go.yaml.in/yaml/[email protected]        # Version immer pinnen
go get -u ./... && go mod tidy          # Abhängigkeiten aktualisieren
go mod tidy -diff                       # nur prüfen – ideal als CI-Gate
go list -m all                          # alle Module im Build
go list -m -u all                       # welche haben Updates?
go mod why go.yaml.in/yaml/v3           # wer zieht es herein?
go mod graph | grep yaml
go mod verify                           # Cache gegen go.sum prüfen
go mod edit -replace example.com/lib=../lib   # lokale Kopie statt Version
go mod edit -dropreplace example.com/lib
go mod vendor                           # Abhängigkeiten ins Repo (Air-Gap)
go work init ./svc ./lib                # Workspace für mehrere Module
go get -tool golang.org/x/vuln/cmd/[email protected]   # Tool im go.mod (1.24)
go tool govulncheck ./...               # bekannte CVEs im genutzten Code
go mod edit -toolchain=go1.26.9         # Toolchain fürs Team festlegen

Umgebung für Firmen: GOPROXY (interner Proxy), GOPRIVATE=git.firma.de/* (privat, ohne Prüfsummen-DB), GOFLAGS=-mod=vendor. go env -w schreibt dauerhaft in die Go-Konfiguration des Users – im Zweifel lieber pro Shell exportieren.

Profiling mit pprof

# Aus Benchmarks: CPU- und Speicherprofil, dann Top-Liste oder Web-UI
go test -run '^$' -bench . -cpuprofile cpu.out -memprofile mem.out .
go tool pprof -top -nodecount=15 cpu.out
go tool pprof -http=127.0.0.1:0 cpu.out          # Flame Graph im Browser
go tool pprof -sample_index=alloc_space -top mem.out
# Im laufenden Dienst (import _ "net/http/pprof", nur auf localhost lauschen!)
curl -s -o cpu.pprof 'http://127.0.0.1:6060/debug/pprof/profile?seconds=10'
curl -s -o heap.pprof http://127.0.0.1:6060/debug/pprof/heap
curl -s 'http://127.0.0.1:6060/debug/pprof/goroutine?debug=1' | head
# Ausführungs-Trace: Scheduler, GC, blockierte Goroutines
go test -run TestX -trace trace.out . && go tool trace trace.out

In pprof interaktiv: top, list Funktionsname, web. Faustregel [Tag 13]: erst messen, dann Allokationen reduzieren, dann Algorithmus – nie umgekehrt.

Cross-Compile und Release

go tool dist list | grep -E '^(linux|darwin|windows)/'   # alle Ziele
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -trimpath \
  -ldflags "-s -w -X main.version=$(git describe --tags --always)" \
  -o dist/tool-linux-arm64 ./cmd/tool
GOOS=windows GOARCH=amd64 go build -o dist/tool.exe ./cmd/tool
file dist/tool-linux-arm64
go version -m dist/tool-linux-arm64 | grep -E 'GOOS|GOARCH'

Release-Werkzeuge aus Tag 14, jeweils per Wrapper in fester Version:

~/go-lab/bin/goreleaser check                      # .goreleaser.yaml prüfen
~/go-lab/bin/goreleaser release --snapshot --clean # alle Archive lokal, ohne Upload
docker build --check .                             # Dockerfile nur prüfen
~/go-lab/bin/actionlint                            # GitHub-Actions-Workflows prüfen
Variable/Flag Wirkung
CGO_ENABLED=0 statisches Binary, läuft in distroless/scratch
-trimpath keine lokalen Pfade im Binary (reproduzierbar)
-ldflags "-s -w" ohne Symbol- und Debug-Tabellen, kleiner
-X main.version=… String-Variable beim Linken setzen [Tag 0]
GOAMD64=v3 / GOARM64=v8.2 neuere CPU-Befehle, nur wenn alle Zielrechner sie haben