Go Patterns
Gemessen: Aktuelle Frontier- und kleine Claude-Modelle schreiben die gängigen Nebenläufigkeitsmechaniken hier (Worker-Pools, Pipeline-Stufen, Channel-Schließen) bereits im ersten Versuch korrekt ohne diese Fähigkeit — eine kontrollierte Studie ergab null Korrektheits-Spielraum, 184/184 bestanden in beiden Armen (die
evals/RESULTS.md§2 des Repos). Greifen Sie zu dieser Fähigkeit für die Entwurfsentscheidungen — Schnittstellen, Abhängigkeitsverdrahtung, Fehlergestaltung, Paketlayout — als Überprüfungs-Checkliste oder beim Steuern schwächerer Modelle; nicht weil ein aktuelles Modell sonst in einen Deadlock geraten würde.
Umfang: Go-Dateien, go.mod und go.sum.
Ursprung: Abgeleitet von Everything Claude Code (MIT, (c) 2026 Affaan Mustafa).
Diese Fähigkeit bietet umfassende Go-Patterns, die allgemeine Entwurfsprinzipien mit Go-spezifischen Redewendungen erweitern.
Funktionale Optionen
Verwenden Sie das Muster der funktionalen Optionen für eine flexible Konstruktorkonfiguration:
type Option func(*Server)
func WithPort(port int) Option {
return func(s *Server) { s.port = port }
}
func NewServer(opts ...Option) *Server {
s := &Server{port: 8080}
for _, opt := range opts {
opt(s)
}
return s
}
Vorteile:
- Rückwärtskompatible API-Entwicklung
- Optionale Parameter mit Standardwerten
- Selbstdokumentierende Konfiguration
Kleine Schnittstellen
Definieren Sie Schnittstellen dort, wo sie verwendet werden, nicht dort, wo sie implementiert werden.
Prinzip: Akzeptiere Schnittstellen, gib Strukturen zurück
// Gut: Kleine, fokussierte Schnittstelle am Verwendungspunkt definiert
type UserStore interface {
GetUser(id string) (*User, error)
}
func ProcessUser(store UserStore, id string) error {
user, err := store.GetUser(id)
// ...
}
Vorteile:
- Einfachere Tests und Mocks
- Lose Kopplung
- Klare Abhängigkeiten
Abhängigkeitsinjektion
Verwenden Sie Konstruktorfunktionen zum Injizieren von Abhängigkeiten:
func NewUserService(repo UserRepository, logger Logger) *UserService {
return &UserService{
repo: repo,
logger: logger,
}
}
Muster:
- Konstruktorfunktionen (New*-Präfix)
- Explizite Abhängigkeiten als Parameter
- Konkrete Typen zurückgeben
- Abhängigkeiten im Konstruktor validieren
Nebenläufigkeitsmuster
Worker-Pool
func workerPool(jobs <-chan Job, results chan<- Result, workers int) {
var wg sync.WaitGroup
for i := 0; i < workers; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for job := range jobs {
results <- processJob(job)
}
}()
}
// Ergebnisse schließen, sobald alle Arbeiter fertig sind — in einer separaten
// Goroutine, damit diese Funktion sofort zurückkehrt und der Aufrufer über
// Ergebnisse iterieren kann, während die Arbeiter noch produzieren. Ein
// Inline-wg.Wait() hier führt zu einem Deadlock: die Arbeiter blockieren beim
// Senden an results, bis ein Leser sie abnimmt, aber der Leser läuft erst,
// nachdem workerPool zurückgekehrt ist.
go func() {
wg.Wait()
close(results)
}()
}
Kontextweitergabe
Übergeben Sie den Kontext immer als ersten Parameter:
func FetchUser(ctx context.Context, id string) (*User, error) {
// Auf Kontextabbruch prüfen
select {
case <-ctx.Done():
return nil, ctx.Err()
default:
}
// ... Abrufflogik
}
Fehlerbehandlung
Fehlerumwicklung
if err != nil {
return fmt.Errorf("Fehler beim Abrufen von Benutzer %s: %w", id, err)
}
Benutzerdefinierte Fehler
type ValidationError struct {
Field string
Msg string
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("%s: %s", e.Field, e.Msg)
}
Sentinel-Fehler
var (
ErrNotFound = errors.New("nicht gefunden")
ErrInvalid = errors.New("ungültige Eingabe")
)
// Prüfung mit errors.Is
if errors.Is(err, ErrNotFound) {
// Nicht gefunden behandeln
}
Paketorganisation
Struktur
project/
├── cmd/ # Hauptanwendungen
│ └── server/
│ └── main.go
├── internal/ # Privater Anwendungscode
│ ├── domain/ # Geschäftslogik
│ ├── handler/ # HTTP-Handler
│ └── repository/ # Datenzugriff
└── pkg/ # Öffentliche Bibliotheken
Namenskonventionen
- Paketnamen: Kleinbuchstaben, einzelnes Wort
- Stottern vermeiden:
user.Usernichtuser.UserModel internal/für privaten Code verwendenmain-Paket minimal halten
Testmuster
Tabellengetriebene Tests
func TestValidate(t *testing.T) {
tests := []struct {
name string
input string
wantErr bool
}{
{"gültig", "[email protected]", false},
{"ungültig", "keine-email", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := Validate(tt.input)
if (err != nil) != tt.wantErr {
t.Errorf("Fehler %v erhalten, wantErr %v", err, tt.wantErr)
}
})
}
}
Test-Helfer
// Importieren Sie den reinen Go-Treiber: _ "modernc.org/sqlite" (registriert als "sqlite").
// Verwenden Sie NICHT "sqlite3" (mattn/go-sqlite3) — es benötigt CGO und bricht
// CGO_ENABLED=0 static builds. Das greenfield-go-stack-Bündel verlangt pure-Go/CGO-frei.
func testDB(t *testing.T) *sql.DB {
t.Helper()
db, err := sql.Open("sqlite", ":memory:")
if err != nil {
t.Fatalf("Fehler beim Öffnen der Testdatenbank: %v", err)
}
// Eine ":memory:"-Datenbank ist privat für eine einzelne Verbindung, und database/sql
// ist ein fauler Pool: ohne dies erhält jede gepoolte Verbindung ihre EIGENE leere
// Datenbank, sodass eine in einer Verbindung erstellte Tabelle in der nächsten fehlt.
// Das Anheften des Pools an eine Verbindung sorgt dafür, dass der gesamte Test eine
// In-Memory-DB gemeinsam nutzt. Einschränkung: Bei einer einzelnen Verbindung hält
// diese Verbindung, während eine Transaktion offen ist (db.Begin), die einzige
// Verbindung — leiten Sie ALLE Arbeiten durch die Transaktion, bis Commit/Rollback;
// eine gleichzeitige db.Query auf dem Pool würde darauf warten blockieren. Wenn ein
// Test wirklich mehrere Live-Verbindungen benötigt, verwenden Sie stattdessen ein
// Shared-Cache-DSN ("file:testdb?mode=memory&cache=shared") und halten Sie mindestens
// 1 Verbindung offen, damit die In-Memory-DB nicht gelöscht wird.
db.SetMaxOpenConns(1)
t.Cleanup(func() { db.Close() })
return db
}
Wann diese Fähigkeit verwendet werden sollte
- Entwerfen von Go-APIs und -Paketen
- Implementieren von nebenläufigen Systemen
- Strukturieren von Go-Projekten
- Schreiben von idiomatischem Go-Code
- Refactoring von Go-Codebasen