albertsko/go-skill

1. Geltungsbereich

Diese Praktiken setzen die Sprachsemantik von Go 1.27, die Standardlaufzeiteinstellungen und die Standard-Experimentkonfiguration voraus.

2. Route zu Konzeptdateien

Routen Sie anhand des Codes und der Aufgabe im Geltungsbereich, wobei Sie sich bei einer Änderung oder einem Diff auf den geänderten Code konzentrieren. Der Index kombiniert Themen und anschauliche Code-Muster. X, T, x und v stellen beliebige Namen dar. Öffnen Sie jede übereinstimmende Referenz, einschließlich der unten aufgeführten zusätzlichen Routen.

Finden Sie eine Praxis anhand des ID-Präfixes in ihrer Überschrift und zitieren Sie ihre vollständige ID. Befolgen Sie die Praxis, verwenden Sie das Beispiel als Redewendung und ziehen Sie Warum, Ausnahmen und Zielkonflikt für Mechanismen, Anwendbarkeit und Kosten zu Rate. Signale identifizieren möglicherweise fehlende Praktiken.

Öffnen Sie auch diese Referenzen für fehlende Schutzmaßnahmen oder Symptome:

• Modul- oder Datei-Sprachversionskonflikte, Build-Einschränkungen oder Überschreibungen des Laufzeitverhaltens: MOD.
• Code, der einen error prüft oder verwirft: ERH.
• Goroutinen oder Kanäle: CTX, GOR und SHR.
• Blockierende E/A (Netzwerk, Datenbank, HTTP, Dateien) oder ein HTTP-Handler: CTX.
• Tests von nebenläufigem Code: TBA und TST.
• Speicher- oder Goroutinenanzahl, die wächst: PRO und MRT.
• Hohe GC-CPU oder ein Programm in einem Container: BRT, PRO und TRC.
• Ein Hot Path oder eine Anfrage, Code schneller zu machen: PRO, ALO und BEN.

2.1 Sprache

• CST code-structure.md: Shadowing, Paket-/Built-in-Namen (url, len, new, max), frühe Returns (else nach return), func init().
• STD struct-design.md: Getter/Setter (GetX/SetX), Embedding (sync.Mutex), promoted-field literals, funktionale Optionen (NewXWithY, Config-Argumente), new(expr) und Pointer-Helfer (ptr[T], intPtr).
• INT interfaces.md: Interface-Erstellung/-Eigentümerschaft, Single-Implementation-Interfaces, konkrete vs. Interface-Ergebnisse, any/interface{}, getypte nil-Interfaces/Errors.
• GEN generics.md: Typparameter ([T any]), Constraints (comparable, ~int, ~string, cmp.Ordered, golang.org/x/exp/constraints), Inferenz, generische Methoden, selbstreferenzielle Constraints.
• FNM functions-and-methods.md: Wert-/Pointer oder gemischte Receiver, Mutex-tragende Wert-Receiver, benannte Ergebnisse (n int, err error), naked returns.
• LOP loops.md: range-Kopien (v.field =), Ausdrucksauswertung, Variablen pro Iteration (v := v, &v, Goroutine-Closures), range n, for i := 0; i <, slices.Backward, label-breaks, break innerhalb von switch/select.
• ITR iterators.md: Iterator-Konsum/-Erstellung, iter.Seq/iter.Seq2 (inklusive Parameter), yield, iter.Pull, Next()/Value(), Methoden, die alle Elemente als Slices zurückgeben, slices.Collect.
• DEF defer-and-cleanup.md: defer in Schleifen, deferred-Argument-/Receiver-Auswertung, io.Closer-Bereinigung (defer f.Close(), resp.Body, rows.Close()), Close/Sync-Fehler, os.Create.

2.2 Daten

• NUM numbers.md: Oktalzahlen (0644), Integer-Überlauf (int32(, math.MaxInt), float ==, NaN/Inf, math.FMA.
• SLC slices.md: Länge/Kapazität, append-Aliasing, Vorabzuweisung (make([]), nil/leer ([]T{}, s == nil), len-Prüfungen, copy/slices.Clone, [low:high:max], Slice-to-Array-Konvertierung.
• COL collection-helpers.md: min/max, slices einfügen/löschen/sortieren/suchen, maps, cmp, clear. Ältere Formen: sort.Slice, math.Min/math.Max, append(s[:i], s[i+1:]...), Map-Leeren delete-Schleifen.
• MAP maps.md: Map-Größenbestimmung (make(map, map[K]V{}), sortierte Schlüssel (maps.Keys, sort.Strings), Schreibvorgänge während der Map- Iteration.
• MRT memory-retention.md: Caches/langjährige Maps (Map neben Mutex, Löschung, Größe nach Spitze), beibehaltene Substrings/Subslices, Nullsetzen fallengelassener Pointer, strings.Clone/bytes.Clone, runtime.AddCleanup/runtime.SetFinalizer, unique.*, weak.*.
• CMP comparison.md: vergleichbare Typen (== auf Interfaces/Structs, [T comparable]), slices.Equal/maps.Equal, reflect.DeepEqual, Funktionswerte (runtime.FuncForPC).
• STX strings-text.md: Bytes/Runes (len(s) als Zeichenanzahl, []rune), UTF-8-Validierung (utf8), string(int), String-Range, unicode-Tabellen.
• SPR strings-processing.md: Trim*/Cut*, SplitSeq/FieldsSeq/Lines, strings.Split/strings.Index, strings.Builder, String +=-Schleifen, bytes/bytes.Buffer, fmt.Append*/strconv.Append*, []byte(fmt.Sprintf(.

2.3 Fehler

• PAN panics.md: panic vs. error, recover, Must, panic(nil)/panicnil, debug.SetCrashOutput.
• ERC errors-creating.md: Wrapping (%w/%v, fmt.Errorf, kontextfreies return err/return nil, err), errors.New, Sentinels (var Err) vs. Fehlertypen (Error() string), errors.Join, ErrUnsupported.
• ERH errors-handling.md: errors.Is/errors.AsType, err ==, err.(type), errors.As, Nachrichtenvergleiche, Timeout-/Cancellation-Sentinels (net.Error, os.ErrDeadlineExceeded, context.DeadlineExceeded), Prüfung von err vor Ergebnissen, ignorierte Fehler (_ =, x, _ :=).
• LOG logging.md: log/slog-Einrichtung und Fehlerprotokollierung, log.Printf/log.Println, Protokollierung und Rückgabe desselben Fehlers.

2.4 Nebenläufigkeit

• CND concurrency-design.md: Nebenläufigkeit vs. Parallelität, Spawn-Schwellenwerte (Goroutine pro Element), Worker-Pool-Größenbestimmung, runtime.NumCPU(), GOMAXPROCS.
• SHR shared-state.md: Datenrennen, Happens-Before, Race Conditions, Mutex vs. Kanal, Goroutine-Schreibvorgänge, sync.Mutex/RLock, Formatieren unter Sperren (fmt.Sprintf), gemeinsam genutztes append/Maps.
• SYN sync-primitives.md: getypte Atomkraft (sync/atomic, atomic.Pointer, atomic.AddInt64/atomic.Value, Goroutine n++), sync.Map, sync.Once/sync.OnceValue, sync.Cond, kopierte sync-Werte.
• GOR goroutine-lifecycle.md: Goroutine-Leaks, Stop-Plan/Eigentümer, nach frühem Return blockierte Sender, ungepufferte Ergebniskanäle, go func(), sync.WaitGroup, wg.Add/wg.Go, Errgroup (g.Go, SetLimit).
• CHA channels.md: Benachrichtigungskanäle und Größenbestimmung (make(chan, chan bool, chan struct{}), select-Priorität, nil-Kanäle, close.
• CTX context.md: Übergeben von context.Context, defer cancel()/context.WithTimeout, ctx.Done() um blockierende Operationen, Werteschlüssel (context.WithValue, ctx.Value), context.Background() außerhalb von main.
• CXC context-cancellation.md: Abbruchsursachen (ctx.Err(), <-ctx.Done(), context.Canceled/context.DeadlineExceeded/context.Cause, WithCancelCause), context.AfterFunc, Hintergrundarbeit (WithoutCancel, Goroutine r.Context()), signal.Notify/signal.NotifyContext.

2.5 Standardbibliothek

• TIM time.md: time.Duration-Einheiten/blanke Zahlen, time.Time-Vergleich (==), Timer in Schleifen (time.After), time.NewTimer, time.Tick.
• JSN json.md: encoding/json, encoding/json/v2, JSON-Tags (omitzero, omitempty), eingebettete Marshaler, Zahlen-Dekodierung (json.Unmarshal in map[string]any).
• SQL database-sql.md: database/sql, sql.Open, PingContext, Pool-Größe, Abfrageargumente/vorbereitete Anweisungen (db.Query, .Exec, QueryRow, ExecContext, SQL via fmt.Sprintf), sql.Null[T], rows.Next/rows.Err.
• IOF io-and-files.md: io.Reader/io.Writer- und fs.FS-Parameter, filename string, os.Open, os.ReadFile, os.DirFS, os.Root, filepath.Join mit Benutzereingabe.
• HCL http-client-and-net.md: Client-Timeouts/Sharing/Pools (http.Get, http.Post, http.DefaultClient, http.Client, http.Transport), net/netip vs. net.IP/net.ParseIP, net.JoinHostPort vs. fmt.Sprintf("%s:%d".
• HSV http-server.md: Handler (http.ResponseWriter, *http.Request, http.Handler, r.Body/r.Method), ServeMux-Muster/HandleFunc, http.Error, Server-Timeouts (http.ListenAndServe, http.Server), MaxBytesHandler, ResponseController, CrossOriginProtection.
• RND randomness-and-ids.md: uuid, crypto/rand, math/rand, math/rand/v2, rand.Seed.

2.6 Testen

• TBA testing-basics.md: Testkategorien/Build-Tags (func TestX, //go:build integration), -race, t.Parallel, -shuffle, tabellengesteuerte Tests/t.Run, Helfer, externe _test-Pakete.
• TST testing-state.md: t.Cleanup, TestMain, t.Context vs. Test-context.Background(), t.Chdir/t.Setenv/t.TempDir vs. os.Chdir/os.Setenv/os.MkdirTemp, testing/synctest, Testzeit/time.Sleep, cryptotest.
• TTL testing-tools.md: httptest, testing/iotest, fstest, slogtest, Fuzzing (func FuzzX).
• BEN benchmarks.md: func BenchmarkX, b.Loop vs. b.N/b.ResetTimer, repräsentative Eingabe/Wiederverwendung, benchstat.
• COV coverage-and-test-output.md: -coverpkg, -cover, go build -cover/GOCOVERDIR, t.Output/t.Attr/t.ArtifactDir, Test fmt.Println, go test -json.

2.7 Leistung

Wenden Sie die Praktiken zu Layout, Allokation und Inlining nur auf einen Hot Path an, der durch einen Benchmark, ein Profil oder einen Trace identifiziert wurde.

• PRO profiling.md: pprof (net/http/pprof, /debug/pprof, runtime/pprof, pprof.Lookup), Heap-Diffs, Goroutine-Dumps, goroutineleak/Blocking-/Mutex-Profile (SetBlockProfileRate, SetMutexProfileFraction), Labels (pprof.Do), Goroutine-Anzahlen (runtime/metrics).
• TRC tracing.md: Ausführungs-Tracing (runtime/trace, trace.Start), Flight Recorder (FlightRecorder), Latenzspitzen/seltene langsame Anfragen, Scheduling/GC-Pausen.
• MLY memory-layout.md: Cache-Lokalität/Strides (heiße []*T-Schleifen), False Sharing (Pro-Goroutine-Zähler in einem Slice), Instruktionsebenen-Parallelität, Feldausrichtung, structs.HostLayout.
• ALO allocations.md: Escape-Analyse (-gcflags, Rückgabe lokaler Pointer), Caller-eigene Puffer, Compiler-eleminierte Konvertierungen (heißes string(b)), allocs/op, sync.Pool.
• BRT build-and-runtime-tuning.md: Inlining, PGO (default.pgo), GOGC/GOMEMLIMIT/debug.SetGCPercent, Container-bewusstes GOMAXPROCS (automaxprocs, runtime.GOMAXPROCS).
• CGO cgo.md: Batching von cgo-Aufrufen (import "C", C.), #cgo-Direktiven (noescape, nocallback).

2.8 Projekt und Werkzeuge

• PKG packages-and-docs.md: Projektlayout, Paket-Kohäsion/Namen (util, common), Aliase (type X = Y, //go:fix inline), Doc-Kommentare, fehlende exportierte Doc-Kommentare, Deprecated:, Beispiele (func ExampleX).
• TOL tooling.md: gofmt, go vet, Linter (golangci-lint), tool-Direktiven/tools.go, go fix-Modernisierer, Test-Vet-Prüfungen (-vet=), CI-Skripte, @latest.
• MOD modules-and-builds.md: go.mod-Hygiene/replace, godebug///go:debug, Workspaces (go.work), Build-Einschränkungen (//go:build, // +build).

3. Auf die Aufgabe anwenden

• Code schreiben: Erfüllen Sie jede anwendbare Praxis in den gerouteten Dateien.
• Code überprüfen: Wenn Befehle verfügbar sind, führen Sie zuerst go vet ./..., go test -race ./... und go fix -diff ./... aus, verwenden Sie eine Kopie, wenn der Code unberührt bleiben muss. Überprüfen Sie jeden Signale-Aufzählungspunkt in jeder gerouteten Datei. Schließen Sie Treffer aus, die von Ausnahmen abgedeckt werden. Melden Sie den Rest als ID | datei:zeile | was falsch ist | fix. Überschneiden sich Praktiken, zitieren Sie zuerst die spezifischste ID, dann die anderen. Verwenden Sie - für Probleme, die von keiner Praxis abgedeckt werden. Sortieren Sie nach Auswirkung: falsche Ergebnisse, Races, Panics, Leaks, Hänger, dann Ressourcen-/Leistungsprobleme, dann veraltete Redewendungen/Stil.
• Debuggen: Ordnen Sie Symptome den Signalen und Warum zu, bestätigen Sie den Mechanismus im Code und wenden Sie dann die Praxis an.
• Code modernisieren: Führen Sie go fix ./... aus, bis der Diff leer ist, um die Modernisierer anzuwenden, und überprüfen Sie dann den Diff. Modernisierer überspringen Code-Formen, deren Sicherheit sie nicht beweisen können. Überprüfen Sie daher die Signale der gerouteten Dateien auf die verbleibenden veralteten Redewendungen und schreiben Sie diese von Hand um. Abgeschlossen, wenn kein Signale-Aufzählungspunkt der gerouteten Dateien mehr zutrifft und go vet ./... sowie die Tests bestanden werden.

Bevor Sie eine Leistungssteigerung behaupten, messen Sie diese mit einem Benchmark oder einem Profil.