Cum organizează pachetele și modulele codul Go?

Question

Accepted Answer

Go organizează codul cu **pachete** (colecții de fișiere sursă într-un director) și **module** (colecții de pachete cu dependențe versionare). Împreună, acestea structurează proiectele și gestionează dependențele.

## Pachete — un director cu cod asociat

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

Toți fișierul dintr-un director aparțin unui singur pachet. **Capitalizarea controlează vizibilitatea**: numele cu majuscule sunt exportate (publice între pachete), cele cu minuscule sunt private pentru pachet.

## Importarea și utilizarea pachetelor

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

## Module — gestionarea dependențelor versionare

```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 **modul** (introdus în Go 1.11) este unitatea de gestionare a dependențelor — `go.mod` listează versiunile exacte ale dependențelor, făcând compilările reproductibile. `go.sum` verifică integritatea dependențelor.

## Funcția init și 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)
}
```

## Convenții de structură a proiectului

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

Directorul `internal/` este special — pachetele sale pot fi importate doar în cadrul aceluiași modul, enforțând encapsularea la nivel de modul.

## De ce contează

Pachetele și modulele sunt modul în care sunt structurate proiectele Go și cum sunt gestionate dependențele — esențial pentru orice proiect real.

Înțelegerea pachetelor (un director de fișiere, vizibilitate exportată/neexportată bazată pe capitalizare, pachetul special `main`) este fundamentală pentru organizarea codului și controlul API-ului public.

Modulele (`go mod`, `go.mod`/`go.sum`) oferă gestionarea dependențelor reproductibilă, versionată și cu verificare de integritate — standardul modern care a înlocuit abordarea veche GOPATH.

Cunoașterea sistemului de import, convenția `internal/` pentru cod privat la nivel de modul și instrumentele (`go mod init/tidy`, `go get`) este necesară pentru construirea, partajarea și întreținerea proiectelor Go și reflectă o fluiditate practică cu ecosistemul Go.