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 WerteStrings 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 BytesFehler
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/AsEinwickeln 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 ignoriertPanic 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 TimeoutRetries 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.24Testing
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 -testcacheDas 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 0Module
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 festlegenUmgebung 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.outIn 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 |