Écosystème et outils¶

L'écosystème Go est minimaliste mais complet. Le compilateur, le formateur, le testeur et le linter de base sont tous inclus dans la distribution officielle. Des outils tiers comme golangci-lint, staticcheck et Delve completent le tableau pour la qualité du code et le débogage.

IDEs et éditeurs¶

VS Code avec gopls¶

VS Code est l'éditeur le plus utilisé pour Go grâce à l'extension officielle qui intégré gopls, le language server officiel du projet Go.

# Installation de l'extension Go pour VS Code
code --install-extension golang.Go

# gopls est installe automatiquement par l'extension
# ou manuellement :
go install golang.org/x/tools/gopls@latest

Configuration recommandee (.vscode/settings.json) :

{
    "go.useLanguageServer": true,
    "go.lintTool": "golangci-lint",
    "go.lintFlags": ["--fast"],
    "go.formatTool": "goimports",
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
        "source.organizeImports": "explicit"
    },
    "[go]": {
        "editor.defaultFormatter": "golang.go",
        "editor.tabSize": 4,
        "editor.insertSpaces": false
    }
}

Fonctionnalités de gopls :

Fonctionnalité	Description
Completion	Auto-completion contextuelle avec types
Hover	Documentation inline au survol
Go to définition	Navigation vers la définition (F12)
Find références	Toutes les utilisations d'un symbole
Rename	Renommage sur tout le projet
Code lens	Run / Debug / Benchmark directement dans le fichier
Inlay hints	Affichage des types déduits

GoLand¶

GoLand (JetBrains) est l'IDE commercial de référence. Il intégré natvement le debogueur Delve, le profiler, la navigation de code avancee et les refactorings.

Raccourcis GoLand essentiels :
  Ctrl+Space      — Completion
  Ctrl+B          — Go to definition
  Ctrl+Shift+F10  — Run le fichier courant
  Shift+F9        — Debug le fichier courant
  Ctrl+Alt+L      — Reformater (gofmt)
  Ctrl+T          — Run les tests
  Alt+Enter       — Quick fix / intentions

Formatage et imports¶

gofmt¶

# Formater tous les fichiers Go recursivement
gofmt -w .

# Afficher les differences sans modifier
gofmt -d .

# Verifier qu'aucun fichier n'a besoin de formatage (CI)
test -z "$(gofmt -l .)"

goimports¶

goimports etend gofmt en ajoutant la gestion automatique des imports.

go install golang.org/x/tools/cmd/goimports@latest

# Formater et corriger les imports
goimports -w .

# Utiliser avec un proxy d'imports pour les gros monorepos
goimports -local example.com/myorg -w .

Linters — golangci-lint¶

golangci-lint est le meta-linter Go de référence. Il exécuté plusieurs linters en parallèle et est le standard pour les projets open source et en entreprise.

# Installation
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

# Lancement
golangci-lint run ./...

# Avec timeout et corrections automatiques
golangci-lint run --timeout=5m --fix ./...

Configuration recommandee¶

# .golangci.yml
run:
  timeout: 5m

linters:
  enable:
    - errcheck      # Verifie que les erreurs ne sont pas ignorees
    - gosimple      # Suggestions de simplification du code
    - govet         # Analyse statique officielle (go vet)
    - ineffassign   # Assignations inefficaces (valeur jamais utilisee)
    - staticcheck   # Suite de checks avances
    - unused        # Symboles declares mais jamais utilises
    - gofmt         # Verification du formatage
    - goimports     # Verification des imports
    - gocritic      # Suite de checks stylistiques et idiomatiques
    - gosec         # Detection de vulnerabilites de securite
    - misspell      # Fautes d'orthographe dans les commentaires
    - nilerr        # return nil, nil quand une erreur est attendue
    - bodyclose     # Verifier que resp.Body est ferme

linters-settings:
  errcheck:
    check-type-assertions: true
    check-blank: true
  govet:
    enable-all: true
  staticcheck:
    checks: ["all"]

issues:
  exclude-rules:
    # Ignorer errcheck dans les fichiers de test
    - path: _test\.go
      linters:
        - errcheck

Analyse statique¶

staticcheck¶

staticcheck est le linter statique le plus avance pour Go. Il détecté des bugs subtils, des patterns obsolètes et des inefficacites.

go install honnef.co/go/tools/cmd/staticcheck@latest

# Analyse complete
staticcheck ./...

# Checks specifiques
staticcheck -checks "SA*" ./...  # Tous les checks staticcheck
staticcheck -checks "S1*" ./...  # Simplifications de code

Catégories de checks :

Prefix	Description
SA	Bugs, code mort, mauvaises utilisations d'API
S	Simplifications de code possibles
ST	Conventions de style
QF	Quick fixes disponibles

govulncheck¶

go install golang.org/x/vuln/cmd/govulncheck@latest

# Scanner les vulnerabilites connues dans les dependances
govulncheck ./...

# Sortie typique
# Vulnerability #1: GO-2024-2611
# A malicious HTTP server can cause a client to panic in net/http
# Found in: net/http@go1.21.0
# Fixed in: net/http@go1.21.8

go vet¶

go vet est intégré dans la chaîne d'outils Go et détecté les erreurs courantes.

# Analyse statique de base
go vet ./...

# Activites detaillees
go vet -composites=false -httpresponse=false ./...

Débogage — Delve¶

Delve est le debogueur officiel Go. Il supporte les goroutines, les breakpoints conditionnels et l'inspection de l'état complet du programme.

go install github.com/go-delve/delve/cmd/dlv@latest

# Demarrer un programme en mode debug
dlv debug .

# Attacher a un processus en cours
dlv attach <pid>

# Debug d'un test specifique
dlv test -- -run TestNomDuTest

Commandes Delve essentielles :

(dlv) break main.main          -- Breakpoint sur une fonction
(dlv) break handler.go:42      -- Breakpoint sur une ligne
(dlv) condition 1 i > 10       -- Breakpoint conditionnel
(dlv) continue                 -- Continuer l'execution (c)
(dlv) next                     -- Ligne suivante sans entrer dans les fonctions (n)
(dlv) step                     -- Entrer dans la fonction (s)
(dlv) stepout                  -- Sortir de la fonction courante
(dlv) print nomVariable        -- Afficher la valeur d'une variable (p)
(dlv) locals                   -- Toutes les variables locales
(dlv) goroutines               -- Lister toutes les goroutines actives
(dlv) goroutine 3              -- Basculer vers la goroutine 3
(dlv) stack                    -- Afficher la pile d'appels

Le debogueur VS Code utilise Delve en arriere-plan. La configuration de lancement :

// .vscode/launch.json
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Debug programme",
            "type": "go",
            "request": "launch",
            "mode": "auto",
            "program": "${workspaceFolder}",
            "args": ["--port", "8080"]
        },
        {
            "name": "Debug test courant",
            "type": "go",
            "request": "launch",
            "mode": "test",
            "program": "${fileDirname}"
        }
    ]
}

Profiling — pprof et fgprof¶

pprof intégré¶

# Profil CPU — 30 secondes d'echantillonnage
go tool pprof -http=:8088 http://localhost:6060/debug/pprof/profile?seconds=30

# Profil memoire (allocations courantes)
go tool pprof -http=:8088 http://localhost:6060/debug/pprof/heap

# Trace d'execution (goroutines, GC, syscalls)
curl -o trace.out http://localhost:6060/debug/pprof/trace?seconds=5
go tool trace trace.out

# Profil depuis les benchmarks
go test -bench=BenchmarkMaFonction -cpuprofile=cpu.out -memprofile=mem.out
go tool pprof -http=:8088 cpu.out

fgprof — profiler wall-clock¶

# fgprof mesure le temps mur (inclut les blocages I/O, contrairement a pprof CPU)
go install github.com/felixge/fgprof/cmd/fgprof@latest

Gestion des versions Go¶

Contrairement a Python (pyenv) ou Node (nvm), Go n'a pas de gestionnaire de versions dédié — go.mod spécifié la version minimale requise et le compilateur installe géré la compatibilité.

# Verifier la version installee
go version

# Installer une version specifique de Go (toolchain Go 1.21+)
go install golang.org/dl/go1.22.3@latest
go1.22.3 download
go1.22.3 version

# Avec mise (alternative moderne a asdf)
mise use go@1.22.3
mise use go@latest

Directive toolchain dans go.mod

Depuis Go 1.21, go.mod peut inclure une directive toolchain go1.22.3 pour specifier la version exacte du compilateur a utiliser, en plus de la version minimale du langage. Le compilateur Go 1.21+ telechargera automatiquement la bonne toolchain si nécessaire.