Go Patterns
Mesuré : la frontière actuelle et les petits modèles Claude écrivent déjà correctement les mécanismes de concurrence courants (worker pools, étapes de pipeline, fermeture de canaux) en un seul coup sans ce skill — une étude contrôlée n'a trouvé aucune marge d'amélioration en termes de correction, 184/184 réussissant dans les deux bras (section 2 du
evals/RESULTS.mddu dépôt). Utilisez ce skill pour les choix de conception — interfaces, câblage des dépendances, mise en forme des erreurs, organisation des packages — comme liste de contrôle de révision, ou lorsque vous pilotez des modèles plus faibles ; pas parce qu'un modèle actuel pourrait autrement se bloquer.
Portée : fichiers Go, go.mod et go.sum.
Origine : Dérivé de Everything Claude Code (MIT, (c) 2026 Affaan Mustafa).
Ce skill fournit des modèles Go complets qui étendent les principes de conception courants avec des idiomes spécifiques à Go.
Options Fonctionnelles
Utilisez le modèle d'options fonctionnelles pour une configuration flexible du constructeur :
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
}
Avantages :
- Évolution d'API rétrocompatible
- Paramètres optionnels avec valeurs par défaut
- Configuration auto-documentée
Petites Interfaces
Définissez les interfaces là où elles sont utilisées, pas là où elles sont implémentées.
Principe : Acceptez les interfaces, retournez les structures
// Bien : Interface petite et ciblée, définie au point d'utilisation
type UserStore interface {
GetUser(id string) (*User, error)
}
func ProcessUser(store UserStore, id string) error {
user, err := store.GetUser(id)
// ...
}
Avantages :
- Tests et simulation plus faciles
- Couplage lâche
- Dépendances claires
Injection de Dépendances
Utilisez les fonctions constructeur pour injecter les dépendances :
func NewUserService(repo UserRepository, logger Logger) *UserService {
return &UserService{
repo: repo,
logger: logger,
}
}
Modèle :
- Fonctions constructeur (préfixe New*)
- Dépendances explicites en paramètres
- Types concrets en retour
- Valider les dépendances dans le constructeur
Modèles de Concurrence
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)
}
}()
}
// Fermer results une fois que tous les workers ont terminé — dans une goroutine
// séparée pour que cette fonction retourne immédiatement et que l'appelant puisse
// parcourir results pendant que les workers produisent encore. Un wg.Wait() en
// ligne ici provoquerait un interblocage : les workers bloquent l'envoi sur results
// jusqu'à ce qu'un lecteur les vide, mais le lecteur ne s'exécute qu'après le retour
// de workerPool.
go func() {
wg.Wait()
close(results)
}()
}
Propagation du Contexte
Passez toujours le contexte en premier paramètre :
func FetchUser(ctx context.Context, id string) (*User, error) {
// Vérifier l'annulation du contexte
select {
case <-ctx.Done():
return nil, ctx.Err()
default:
}
// ... logique de récupération
}
Gestion des Erreurs
Emballage d'Erreurs
if err != nil {
return fmt.Errorf("échec de la récupération de l'utilisateur %s : %w", id, err)
}
Erreurs Personnalisées
type ValidationError struct {
Field string
Msg string
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("%s : %s", e.Field, e.Msg)
}
Erreurs Sentinelles
var (
ErrNotFound = errors.New("non trouvé")
ErrInvalid = errors.New("entrée invalide")
)
// Vérifier avec errors.Is
if errors.Is(err, ErrNotFound) {
// gérer l'absence de résultat
}
Organisation des Packages
Structure
project/
├── cmd/ # Applications principales
│ └── server/
│ └── main.go
├── internal/ # Code applicatif privé
│ ├── domain/ # Logique métier
│ ├── handler/ # Gestionnaires HTTP
│ └── repository/ # Accès aux données
└── pkg/ # Bibliothèques publiques
Conventions de Nommage
- Noms de package : minuscules, un seul mot
- Évitez le bégaiement :
user.Userpasuser.UserModel - Utilisez
internal/pour le code privé - Gardez le package
mainminimal
Modèles de Tests
Tests Table-Driven
func TestValidate(t *testing.T) {
tests := []struct {
name string
input string
wantErr bool
}{
{"valide", "[email protected]", false},
{"invalide", "pas-un-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("erreur obtenue %v, wantErr %v", err, tt.wantErr)
}
})
}
}
Helpers de Test
// Importez le driver pure-Go : _ "modernc.org/sqlite" (s'enregistre comme "sqlite").
// N'utilisez PAS "sqlite3" (mattn/go-sqlite3) — il nécessite CGO et casse les
// builds statiques CGO_ENABLED=0. Le bundle greenfield-go-stack impose pure-Go/CGO-free.
func testDB(t *testing.T) *sql.DB {
t.Helper()
db, err := sql.Open("sqlite", ":memory:")
if err != nil {
t.Fatalf("échec de l'ouverture de la base de test : %v", err)
}
// Une base ":memory:" est privée à une seule connexion, et database/sql
// est un pool paresseux : sans cela, chaque connexion poolée obtient sa PROPRE base
// vide, donc une table créée sur une connexion est absente de la suivante.
// Épingler le pool à une seule connexion fait partager la même base en mémoire
// à tout le test. Inconvénient : avec une seule connexion, tant qu'une transaction
// est ouverte (db.Begin), cette tx détient l'unique connexion — acheminez TOUT le
// travail via la tx jusqu'à Commit/Rollback ; une db.Query concurrente sur le pool
// bloquerait en attendant. Si un test a vraiment besoin de plusieurs connexions
// actives, utilisez plutôt une DSN à cache partagé
// ("file:testdb?mode=memory&cache=shared") et gardez au moins 1 connexion ouverte
// pour que la base en mémoire ne soit pas supprimée.
db.SetMaxOpenConns(1)
t.Cleanup(func() { db.Close() })
return db
}
Quand Utiliser Ce Skill
- Conception d'API et de packages Go
- Implémentation de systèmes concurrents
- Structuration de projets Go
- Écriture de code Go idiomatique
- Remaniement de bases de code Go