Come i pacchetti e i moduli organizzano il codice Go?

Question

Accepted Answer

Go organizza il codice con **pacchetti** (collezioni di file sorgenti in una directory) e **moduli** (collezioni di pacchetti con dipendenze versionati). Insieme strutturano i progetti e gestiscono le dipendenze.

## Pacchetti — una directory di codice correlato

```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
```

Tutti i file in una directory appartengono a un pacchetto. **La capitalizzazione controlla la visibilità**: i nomi capitalizzati sono esportati (pubblici attraverso i pacchetti), quelli minuscoli sono privati al pacchetto.

## Importazione e utilizzo di pacchetti

```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
```

## Moduli — gestione delle dipendenze versionata

```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 **modulo** (introdotto in Go 1.11) è l'unità di gestione delle dipendenze — `go.mod` elenca le versioni esatte delle dipendenze, rendendo le build riproducibili. `go.sum` verifica l'integrità delle dipendenze.

## La funzione init e 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)
}
```

## Convenzioni di struttura del progetto

```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
```

La directory `internal/` è speciale — i suoi pacchetti possono essere importati solo all'interno dello stesso modulo, applicando l'incapsulamento a livello di modulo.

## Perché è importante

I pacchetti e i moduli sono il modo in cui i progetti Go sono strutturati e come le dipendenze sono gestite — essenziali per qualsiasi progetto reale.

Comprendere i pacchetti (una directory di file, visibilità basata sulla capitalizzazione di esportato/non esportato, il pacchetto speciale `main`) è fondamentale per organizzare il codice e controllare la sua API pubblica.

I moduli (`go mod`, `go.mod`/`go.sum`) forniscono gestione delle dipendenze riproducibile, versionata e verificata per integrità — lo standard moderno che ha sostituito il vecchio approccio GOPATH.

Conoscere il sistema di importazione, la convenzione `internal/` per il codice privato del modulo, e gli strumenti (`go mod init/tidy`, `go get`) è necessario per costruire, condividere e mantenere progetti Go, e riflette una fluidità pratica con l'ecosistema Go.