Cours 23 : Annexes Go

300+ lignes de glossaire, cheat sheets, idioms, et erreurs fréquentes.

---

Partie 1 : Glossaire (200+ termes)

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X-Z

---

Partie 2 : Cheat Sheets

2.1 Commandes Go essentielles

# Développement
go mod init <module>      # Initialiser un module
go mod tidy               # Nettoyer les dépendances
go mod vendor             # Créer le dossier vendor
go build ./...            # Compiler tout le projet
go run .                  # Exécuter le package courant
go install                # Compiler et installer

# Tests
go test ./...             # Exécuter tous les tests
go test -v ./...          # Mode verbose
go test -run TestXxx      # Filtrer par nom
go test -bench .          # Exécuter les benchmarks
go test -cover            # Couverture de code
go test -race ./...       # Race detector
go test -fuzz .           # Fuzzing

# Qualité
go fmt ./...              # Formater tout le code
go vet ./...              # Analyse statique
go mod verify             # Vérifier les dépendances

# Profilage
go test -cpuprofile cpu.out
go test -memprofile mem.out
go test -trace trace.out
go tool pprof cpu.out
go tool trace trace.out

# Cross-compilation
GOOS=linux GOARCH=amd64 go build
GOOS=windows GOARCH=amd64 go build
GOOS=darwin GOARCH=arm64 go build

2.2 Slice Operations

// Création
s := make([]int, 0, 10)           // len=0, cap=10
s := []int{1, 2, 3}               // literal
var s []int                        // nil slice

// Ajout
s = append(s, 4)                  // ajoute un élément
s = append(s, 5, 6)               // ajoute plusieurs
s = append(s, others...)          // concatène une slice

// Suppression
s = append(s[:i], s[i+1:]...)     // supprime l'élément i
s = s[:len(s)-1]                  // supprime le dernier
s = s[:0]                         // vide la slice (sans réallouer)

// Copie
n := copy(dst, src)               // copie min(len(dst), len(src)) éléments

// Tri
sort.Slice(s, func(i, j int) bool { return s[i] < s[j] })
sort.Ints(s)
sort.Strings(s)

// Recherche
idx := sort.Search(len(s), func(i int) bool { return s[i] >= x })

2.3 Map Operations

// Création
m := make(map[string]int)
m := map[string]int{"a": 1}
var m map[string]int // nil map

// CRUD
m["key"] = 42            // Set
v := m["key"]            // Get (0 si absent)
v, ok := m["key"]        // Get avec vérification
delete(m, "key")         // Delete
clear(m)                 // Vide la map (Go 1.21+)

// Iteration
for k, v := range m { /* ordre aléatoire */ }
for k := range m { /* keys only */ }

// Longueur
n := len(m)

2.4 Channel Operations

// Création
ch := make(chan int)           // unbuffered
ch := make(chan int, 10)       // buffered
ch := make(<-chan int)         // receive-only
ch := make(chan<- int)         // send-only

// Send/Receive
ch <- 42                       // send (bloque si full/unbuffered without receiver)
v := <-ch                      // receive (bloque si vide)
v, ok := <-ch                  // receive avec check fermeture

// Close
close(ch)                      // seul le sender ferme
for v := range ch { /*...*/ }  // range jusqu'à fermeture

// Select
select {
case v := <-ch1:
    // ...
case ch2 <- v:
    // ...
case <-time.After(timeout):
    // timeout
default:
    // aucun cas prêt
}

2.5 JSON Operations

// Marshal
data, err := json.Marshal(v)
data, err := json.MarshalIndent(v, "", "  ")

// Unmarshal
err := json.Unmarshal(data, &v)

// Stream
decoder := json.NewDecoder(r)
err := decoder.Decode(&v)

encoder := json.NewEncoder(w)
err := encoder.Encode(v)

// Tags
type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name,omitempty"`
    Email string `json:"-"`
}

2.6 HTTP Server

// Handler basique
http.HandleFunc("/api", handler)
http.ListenAndServe(":8080", nil)

// Avec timeout
srv := &http.Server{
    Addr:         ":8080",
    ReadTimeout:  10 * time.Second,
    WriteTimeout: 10 * time.Second,
    IdleTimeout:  60 * time.Second,
}
srv.ListenAndServe()

// Graceful shutdown
srv.Shutdown(ctx)

// Client HTTP
client := &http.Client{
    Timeout: 30 * time.Second,
    Transport: &http.Transport{
        MaxIdleConns:    100,
        IdleConnTimeout: 90 * time.Second,
    },
}
resp, err := client.Get(url)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)

2.7 Error Handling

// Création
errors.New("message")               // simple
fmt.Errorf("context: %w", err)      // wrapping (Go 1.13+)

// Vérification
if err != nil { /* handle */ }

// Unwrap
errors.Is(err, ErrNotFound)         // vérifie la chaîne d'erreurs
errors.As(err, &target)             // cast dans la chaîne

// Sentinel errors
var ErrNotFound = errors.New("not found")

// Custom error type
type ValidationError struct {
    Field string
    Err   error
}
func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation error on %s: %v", e.Field, e.Err)
}
func (e *ValidationError) Unwrap() error { return e.Err }

2.8 go.mod File Example

module github.com/user/project

go 1.23

require (
    github.com/go-chi/chi/v5 v5.1.0
    github.com/jackc/pgx/v5 v5.7.1
    github.com/redis/go-redis/v9 v9.6.1
    go.uber.org/zap v1.27.0
)

require (
    github.com/cespare/xxhash/v2 v2.3.0 // indirect
)

---

Partie 3 : 30 Idiomes Go Essentiels

3.1 Idiomes de base

1. Zero value initialization

var s []string       // nil slice, pas besoin de make
var m map[string]int // nil map, mais ne pas écrire dedans

2. Short variable declarations

s := "hello"         // vs var s string = "hello"

3. Multiple returns

func div(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

4. Blank identifier

for _, v := range slice { /* only value */ }

5. Named result parameters

func minMax(a, b int) (min, max int) { ... }

3.2 Idiomes de structure

6. Functional options pattern

type Option func(*Server)
func WithPort(port int) Option { ... }
func NewServer(opts ...Option) *Server { ... }

7. Interface satisfaction implicite

type Writer interface { Write([]byte) (int, error) }
// myType implemente Writer si MyType a Write()

8. Accept interfaces, return structs

9. Prefer composition over inheritance (embedding)

10. Small interfaces (1-3 methods)

3.3 Idiomes de concurrence

11. "Share memory by communicating"

12. Done channel pattern

done := make(chan struct{})
go func() { work(); close(done) }()
<-done

13. Or-done channel

14. Fan-out, Fan-in

15. Context propagation

3.4 Idiomes de gestion d'erreurs

16. Check errors immediately

if err != nil { return err }

17. Always close/cleanup (defer)

f, _ := os.Open("file")
defer f.Close()

18. Error wrapping (Go 1.13+)

fmt.Errorf("opening file %s: %w", name, err)

19. Sentinel errors for expected errors

20. Type assertion with ok

if v, ok := i.(string); ok { ... }

3.5 Idiomes de testing

21. Table-driven tests

22. External test package

package mypkg_test

23. Test helpers

func setup(t *testing.T) *DB { t.Helper(); ... }

24. Subtests with t.Run

25. golden files for complex output

3.6 Idiomes avancés

26. sync.Once for lazy initialization

27. sync.Pool for temporary objects

28. Embedding for decoration

29. New vs Make distinction

30. init() functions avec parcimonie

---

Partie 4 : Common Mistakes - Top 20

---

Annexes consultables rapidement pendant le développement. Imprimez les cheat sheets pour les garder à portée de main.