Kif il-pakkaġġi u l-moduli jorganizzaw il-kodiċi Go?

Question

Accepted Answer

Go jorganizza l-kodiċi b'**pakkaġġi** (ġbir ta' fajls sors f'direttorju) u **moduli** (ġbir ta' pakkaġġi b'dipendenzi vversjonati). Flimkien huma jistrutturaw il-proġetti u jimmaniġġjaw id-dipendenzi.

## Pakkaġġi — direttorju ta' kodiċi relatat

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

Il-fajls kollha f'direttorju wieħed jappartjenu għal pakkaġġ wieħed. **Il-kapitalizzazzjoni tikontolla l-viżibilità**: ismijiet kapitalizzati huma esportati (pubbliċi bejn il-pakkaġġi), minuskuli huma privati għall-pakkaġġ.

## L-importazzjoni u l-użu tal-pakkaġġi

```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 — immaniġġjar ta' dipendenzi vversjonati

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

A **modulu** (introdott f'Go 1.11) hu l-unità tal-immaniġġjar ta' dipendenzi — `go.mod` elenka l-verżjonijiet eżatti ta' dipendenzi, li jagħmlu l-builds riproduttibbli. `go.sum` jivverifica l-integrità tal-dipendenzi.

## Il-funzjoni init u 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)
}
```

## Konvenzjonijiet tal-istruttura tal-proġett

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

Id-direttorju `internal/` hu speċjali — il-pakkaġġi tiegħu jistgħu jiġu importati biss fi ħdan l-istess modulu, u jikkontrollaw l-kapsula għad-daqq tal-modulu.

## Għaliex importa

Il-pakkaġġi u l-moduli huma kif il-proġetti Go huma strutturati u kif id-dipendenzi huma immaniġġjati — essenzjali għal kwalunkwe proġett reali.

L-għarfien tal-pakkaġġi (direttorju ta' fajls, viżibilità esportata/mhux esportata bbażata fuq il-kapitalizzazzjoni, il-pakkaġġ speċjali `main`) hu fundamentali għall-organizzazzjoni tal-kodiċi u l-kontroll tal-API pubbliku tiegħu.

Il-moduli (`go mod`, `go.mod`/`go.sum`) jipprovdu immaniġġjar ta' dipendenzi riproduttibbli, vversjonati, u jivverifikaw l-integrità — l-istandard modern li biddel l-approċċ antik tal-GOPATH.

L-għarfien tas-sistema tal-importazzjoni, il-konvenzjoni tal-`internal/` għall-kodiċi privat tal-modulu, u l-għodod (`go mod init/tidy`, `go get`) hu meħtieġ għall-bini, il-qassam, u l-manutenzjoni tal-proġetti Go, u jirrifletti l-abbilitajiet prattiċi bl-ekosistema Go.