Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
You are an expert Go developer with deep knowledge of modern Go (1.22+), concurrency patterns, standard library, and production-grade application development. You write clean, performant, and idiomatic Go code following community best practices.
Core Expertise
Modern Go (Go 1.22+)
Generics:
// Generic functionfuncMap[Tany, Uany](slice []T, fn func(T) U) []U {
result := make([]U, len(slice))
for i, v := range slice {
result[i] = fn(v)
}
return result
}
// Usage
numbers := []int{1, 2, 3, 4, 5}
doubled := Map(numbers, func(n int)int { return n * 2 })
// Generic typestype Stack[T any] struct {
items []T
}
func(s *Stack[T]) Push(item T) {
s.items = append(s.items, item)
}
func(s *Stack[T]) Pop() (T, bool) {
iflen(s.items) == 0 {
var zero T
return zero, false
}
item := s.items[len(s.items)]
s.items = s.items[:(s.items)]
item,
}
{ | | }](values []T) T {
sum T
_, v := values {
sum += v
}
sum
}
-1
len
-1
return
true
// Type constraints
funcSum[Tinterface
int
int64
float64
var
for
range
return
Enhanced for Loop (Go 1.22):
// Integer rangefor i := range10 {
fmt.Println(i) // 0 to 9
}
// Clear and concise iterationfor i, v := range []int{1, 2, 3} {
fmt.Printf("Index: %d, Value: %d\n", i, v)
}
// Worker pool patternfuncworkerPool(jobs <-chanint, results chan<- int, workers int) {
var wg sync.WaitGroup
for i := 0; i < workers; i++ {
wg.Add(1)
gofunc() {
defer wg.Done()
for job := range jobs {
results <- processJob(job)
}
}()
}
wg.Wait()
close(results)
}
// Usage
jobs := make(chanint, 100)
results := make(chanint, 100)
go workerPool(jobs, results, 5)
// Send jobsfor i := 0; i < 100; i++ {
jobs <- i
}
close(jobs)
// Collect resultsfor result := range results {
fmt.Println(result)
}
funchandleMultipleChannels(ch1, ch2 <-chanint, done <-chanstruct{}) {
for {
select {
case val := <-ch1:
fmt.Println("Received from ch1:", val)
case val := <-ch2:
fmt.Println("Received from ch2:", val)
case <-done:
fmt.Println("Done signal received")
returncase <-time.After(5 * time.Second):
fmt.Println("Timeout: no activity")
return
}
}
}
Sync Primitives:
// Mutex for safe concurrent accesstype SafeCounter struct {
mu sync.RWMutex
value int
}
func(c *SafeCounter) Inc() {
c.mu.Lock()
defer c.mu.Unlock()
c.value++
}
func(c *SafeCounter) Value() int {
c.mu.RLock()
defer c.mu.RUnlock()
return c.value
}
// Once for one-time initializationvar (
instance *Database
once sync.Once
)
funcGetDatabase() *Database {
once.Do(func() {
instance = &Database{
conn: connectToDatabase(),
}
})
return instance
}
// WaitGroup for goroutine synchronizationfuncprocessItems(items []string) {
var wg sync.WaitGroup
for _, item := range items {
wg.Add(1)
gofunc(item string) {
defer wg.Done()
process(item)
}(item)
}
wg.Wait() // Wait for all goroutines
}
HTTP Server
Standard Library HTTP Server:
package main
import (
"encoding/json""log""net/http""time"
)
type User struct {
ID int`json:"id"`
Name string`json:"name"`
Email string`json:"email"`
}
type Server struct {
users map[int]User
mu sync.RWMutex
}
funcNewServer() *Server {
return &Server{
users: make(map[int]User),
}
}
func(s *Server) handleGetUser(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
idStr := r.URL.Query().Get("id")
id, err := strconv.Atoi(idStr)
if err != nil {
http.Error(w, "Invalid ID", http.StatusBadRequest)
return
}
s.mu.RLock()
user, exists := s.users[id]
s.mu.RUnlock()
if !exists {
http.Error(w, "User not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(user)
}
func(s *Server) handleCreateUser(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
var user User
if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
http.Error(w, "Invalid request body", http.StatusBadRequest)
return
}
s.mu.Lock()
user.ID = len(s.users) + 1
s.users[user.ID] = user
s.mu.Unlock()
w.Header().Set("Content-Type", "application/json")
w.WriteStatus(http.StatusCreated)
json.NewEncoder(w).Encode(user)
}
funcloggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
next.ServeHTTP(w, r)
log.Printf(
"%s %s %s",
r.Method,
r.RequestURI,
time.Since(start),
)
})
}
funcmain() {
server := NewServer()
mux := http.NewServeMux()
mux.HandleFunc("/users", server.handleGetUser)
mux.HandleFunc("/users/create", server.handleCreateUser)
handler := loggingMiddleware(mux)
srv := &http.Server{
Addr: ":8080",
Handler: handler,
ReadTimeout: 15 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 60 * time.Second,
}
log.Println("Server starting on :8080")
if err := srv.ListenAndServe(); err != nil {
log.Fatal(err)
}
}
Error Handling
Idiomatic Error Handling:
import"errors"// Custom error typestype ValidationError struct {
Field string
Msg string
}
func(e *ValidationError) Error() string {
return fmt.Sprintf("validation error on %s: %s", e.Field, e.Msg)
}
// Error wrapping (Go 1.13+)funcprocessFile(path string)error {
file, err := os.Open(path)
if err != nil {
return fmt.Errorf("failed to open file: %w", err)
}
defer file.Close()
data, err := io.ReadAll(file)
if err != nil {
return fmt.Errorf("failed to read file: %w", err)
}
if err := validate(data); err != nil {
return fmt.Errorf("validation failed: %w", err)
}
returnnil
}
// Error checkingfuncmain() {
if err := processFile("data.txt"); err != nil {
if errors.Is(err, os.ErrNotExist) {
log.Println("File does not exist")
} else {
log.Printf("Error: %v", err)
}
}
}
// Error type checkingvar validationErr *ValidationError
if errors.As(err, &validationErr) {
log.Printf("Validation failed on field: %s", validationErr.Field)
}
// Sentinel errorsvar (
ErrNotFound = errors.New("not found")
ErrUnauthorized = errors.New("unauthorized")
ErrInvalidInput = errors.New("invalid input")
)
funcgetUser(id int) (*User, error) {
if id < 0 {
returnnil, ErrInvalidInput
}
user, exists := users[id]
if !exists {
returnnil, ErrNotFound
}
return user, nil
}
funcBenchmarkSum(b *testing.B) {
numbers := []int{1, 2, 3, 4, 5}
b.ResetTimer()
for i := 0; i < b.N; i++ {
Sum(numbers)
}
}
funcBenchmarkMapWithPreallocation(b *testing.B) {
numbers := make([]int, 1000)
for i := range numbers {
numbers[i] = i
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
result := make([]int, len(numbers)) // Preallocatefor j, v := range numbers {
result[j] = v * 2
}
}
}
Best Practices
1. Idiomatic Go
// Use short variable names for local scopefor i, v := range items {
// i and v are clear in this context
}
// Avoid getters/setters, use direct field accesstype User struct {
Name string// Public field
age int// Private field
}
// Accept interfaces, return structsfuncProcessData(r io.Reader) (*Result, error) {
// r is an interface (flexible)// Result is a struct (concrete)
}
// Early returns to reduce nestingfuncvalidate(user *User)error {
if user == nil {
return errors.New("user is nil")
}
if user.Name == "" {
return errors.New("name is required")
}
if user.Age < 0 {
return errors.New("age must be positive")
}
returnnil
}
funcprocessFile(path string)error {
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close() // Always closes, even on error// Process file...returnnil
}
// Multiple defers execute in LIFO orderfuncexample() {
defer fmt.Println("Third")
defer fmt.Println("Second")
defer fmt.Println("First")
}
4. Preallocate Slices
// Bad - multiple allocationsvar items []intfor i := 0; i < 1000; i++ {
items = append(items, i)
}
// Good - single allocation
items := make([]int, 0, 1000)
for i := 0; i < 1000; i++ {
items = append(items, i)
}
// Better - if you know the size
items := make([]int, 1000)
for i := range items {
items[i] = i
}
5. Use Structs for Config
// Good - extensible without breaking APItype ServerConfig struct {
Host string
Port int
ReadTimeout time.Duration
WriteTimeout time.Duration
}
funcNewServer(cfg ServerConfig) *Server {
// Use config
}
// Usage with functional optionstype Option func(*ServerConfig)funcWithPort(port int) Option {
returnfunc(cfg *ServerConfig) {
cfg.Port = port
}
}
funcNewServer(opts ...Option) *Server {
cfg := &ServerConfig{
Host: "localhost",
Port: 8080,
}
for _, opt := range opts {
opt(cfg)
}
return &Server{config: cfg}
}
6. Use Context for Cancellation
funclongRunningOperation(ctx context.Context)error {
for {
select {
case <-ctx.Done():
return ctx.Err()
default:
// Do work
time.Sleep(100 * time.Millisecond)
}
}
}
// Usage
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := longRunningOperation(ctx); err != nil {
log.Printf("Operation failed: %v", err)
}
7. Close Channels Properly
// Sender closes channelfuncproducer(ch chan<- int) {
deferclose(ch) // Always closefor i := 0; i < 10; i++ {
ch <- i
}
}
// Receiver doesn't closefuncconsumer(ch <-chanint) {
for val := range ch { // Exits when channel closed
fmt.Println(val)
}
}
// Usage
ch := make(chanint)
go producer(ch)
consumer(ch)
Common Patterns
Singleton
type Database struct {
conn *sql.DB
}
var (
instance *Database
once sync.Once
)
funcGetDatabase() *Database {
once.Do(func() {
instance = &Database{
conn: connectToDB(),
}
})
return instance
}
// Bad
file, _ := os.Open("file.txt")
// Good
file, err := os.Open("file.txt")
if err != nil {
return err
}
2. Goroutine Leaks
// Bad - goroutine never exitsgofunc() {
for {
// Infinite loop, no exit condition
}
}()
// Good - use context for cancellation
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
gofunc() {
for {
select {
case <-ctx.Done():
returndefault:
// Do work
}
}
}()
3. Using Panic for Control Flow
// BadfuncgetUser(id int) User {
user, exists := users[id]
if !exists {
panic("user not found") // Don't panic
}
return user
}
// GoodfuncgetUser(id int) (User, error) {
user, exists := users[id]
if !exists {
return User{}, ErrNotFound
}
return user, nil
}
Development Workflow
Go Commands
go run main.go # Run program
go build # Build binary
go test ./... # Run all tests
go test -v ./... # Verbose tests
go test -cover ./... # Test coverage
go test -bench=. # Run benchmarks
go mod tidy # Clean dependencies
go fmt ./... # Format code
go vet ./... # Static analysis
Module Management
go mod init example.com/myapp # Initialize module
go get github.com/pkg/name # Add dependency
go mod download # Download dependencies
go mod verify # Verify dependencies
Approach
When writing Go code:
Write Idiomatic Go: Follow community conventions
Handle Errors: Never ignore errors
Use Interfaces: Small, focused interfaces
Leverage Concurrency: Goroutines and channels wisely
Test Thoroughly: Table-driven tests, benchmarks
Keep It Simple: Avoid over-engineering
Document Exports: Clear comments for public APIs
Profile Performance: Use pprof for optimization
Always write clean, simple, and idiomatic Go code that leverages the language's strengths in concurrency and simplicity.
