Kako paketi in moduli organizirajo Go kodo?

Question

Accepted Answer

Go organizira kodo s **paketi** (zbirkami izvorne kode v direktoriju) in **moduli** (zbirkami paketov z verzioniranimi odvisnostmi). Skupaj strukturirajo projekte in upravljajo odvisnosti.

## Paketi — direktorij s povezano kodo

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

Vse datoteke v enem direktoriju pripadajo enemu paketu. **Velikost črk nadzira vidnost**: velika črka na začetku imena pomeni izvoženi (javni v celotnem paketu), malih črk pa so zasebni paketu.

## Uvažanje in uporaba paketov

```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 — upravljanje verzioniranih odvisnosti

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

**Modul** (introduciran v Go 1.11) je enota upravljanja odvisnosti — `go.mod` navaja natančne verzije odvisnosti, kar omogoča ponovljive gradnje. `go.sum` preveri integriteto odvisnosti.

## Inicializacijska funkcija in 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)
}
```

## Konvencije strukture projekta

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

Direktorij `internal/` je poseben — njegove pakete je mogoče uvažati samo znotraj istega modula, kar uveljavi enkapsulacijo na ravni modula.

## Zakaj je to pomembno

Paketi in moduli so kako se Go projekti strukturirajo in kako se upravljajo odvisnosti — nujno za vsak pravi projekt.

Razumevanje paketov (direktorij datotek, vidnost na osnovi velikosti črk za izvožene in neivvožene elemente, posebni paket `main`) je temeljno za organizacijo kode in nadzor njenega javnega vmesnika.

Moduli (`go mod`, `go.mod`/`go.sum`) zagotavljajo ponovljivo, verzioniran, preverjeno upravljanje odvisnosti — sodoben standard, ki je zamenjal stari pristop GOPATH.

Znanje sistema uvažanja, konvencije `internal/` za kodo zasebno za modul in orodja (`go mod init/tidy`, `go get`) je potrebno za gradnjo, deljenje in vzdrževanje Go projektov ter odraža praktično tekoče znanje Go ekosistema.