Comment les packages et les modules organisent-ils le code Go ?

Question

Accepted Answer

Go organise le code avec les **packages** (collections de fichiers source dans un répertoire) et les **modules** (collections de packages avec des dépendances versionnées). Ensemble, ils structurent les projets et gèrent les dépendances.

## Packages — un répertoire de code connexe

```go
// every .go file starts by declaring its package
package main         // "main" is special — produces an executable

// or a library package (named after its directory, conventionally)
package mathutil

func Add(a, b int) int { return a + b }   // Exported (capitalized) — usable outside
func helper() {}                           // unexported (lowercase) — package-private
```

Tous les fichiers d'un répertoire appartiennent à un package. **La capitalisation contrôle la visibilité** : les noms capitalisés sont exportés (publics entre packages), les minuscules sont privés au package.

## Importer et utiliser les packages

```go
import (
    "fmt"                          // standard library
    "strings"
    "github.com/user/repo/mathutil" // a third-party or local module package
)

fmt.Println(strings.ToUpper("hi"))
mathutil.Add(2, 3)                  // use Exported names via package.Name
```

## Modules — gestion des dépendances versionnées

```bash
go mod init github.com/user/myapp   # create a module → makes go.mod
go get github.com/gin-gonic/gin     # add a dependency (records it in go.mod)
go mod tidy                          # add missing & remove unused dependencies
go build                             # build using the module's dependencies
```

```text
go.mod  — declares the module path, Go version, and direct dependencies (+ versions)
go.sum  — cryptographic checksums of dependencies (integrity/security)
```

Un **module** (introduit en Go 1.11) est l'unité de gestion des dépendances — `go.mod` répertorie les versions exactes des dépendances, rendant les builds reproductibles. `go.sum` vérifie l'intégrité des dépendances.

## La fonction init et main

```go
package main

func init() {    // runs automatically when the package loads (before main)
    // setup
}
func main() {    // entry point of an executable (package main only)
}
```

## Conventions de structure de projet

```text
myapp/
  go.mod
  main.go              package main
  internal/            packages here are PRIVATE to this module (can't be imported externally)
  pkg/ or other dirs/  reusable packages
```

Le répertoire `internal/` est spécial — ses packages ne peuvent être importés que dans le même module, appliquant l'encapsulation au niveau du module.

## Pourquoi c'est important

Les packages et les modules sont la façon dont les projets Go sont structurés et comment les dépendances sont gérées — essentiels pour tout projet réel.

Comprendre les packages (un répertoire de fichiers, visibilité exportée/non exportée basée sur la capitalisation, le package spécial `main`) est fondamental pour organiser le code et contrôler son API publique.

Les modules (`go mod`, `go.mod`/`go.sum`) fournissent une gestion des dépendances reproductible, versionnée et vérifiée en intégrité — le standard moderne qui a remplacé l'ancienne approche GOPATH.

Connaître le système d'importation, la convention `internal/` pour le code privé au module, et les outils (`go mod init/tidy`, `go get`) est nécessaire pour construire, partager et maintenir des projets Go, et reflète une maîtrise pratique de l'écosystème Go.