Kaip paketai ir moduliai organizuoja Go kodą?

Question

Accepted Answer

Go organizuoja kodą su **paketais** (išeities failų kolekcijomis kataloge) ir **moduliais** (paketų kolekcijai su versijomis valdomais priklausomybėmis). Kartu jie struktūrizuoja projektus ir tvarko priklausomybes.

## Paketai — susijusio kodo katalogas

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

Visi failai viename kataloge priklauso vienam paketui. **Didžiosios raidės kontroliuoja matomumą**: didžiosiomis raidėmis pradedami vardai yra eksportuoti (viešai prieinami visuose paketu), mažosiomis raidėmis — privati paketui.

## Paketų importavimas ir naudojimas

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

## Moduliai — versijomis valdomi priklausomybės

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

**Modulis** (pristatytas Go 1.11) yra priklausomybės valdymo vienetas — `go.mod` nurodo tikslias priklausomybių versijas, todėl kompiliavimas yra reproduktyvus. `go.sum` patvirtina priklausomybės integritetą.

## init funkcija ir 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)
}
```

## Projekto struktūros konvencijos

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

Katalogas `internal/` yra specialus — jo paketai gali būti importuoti tik tame pačiame modulyje, taikyti inkapsuliavimą modulio lygiu.

## Kodėl tai svarbu

Paketai ir moduliai — tai kaip Go projektai yra struktūrizuoti ir kaip tvarkomi priklausomybės — neatsiejama bet kurio realaus projekto dalis.

Supratimas apie paketus (katalogą su failais, didžiųjų raidžių grindžiamus eksportuotus/neeksportuotus vardus, specialų `main` paketą) yra pagrindinė kodo organizavimo ir jo viešojo API kontrolės dalis.

Moduliai (`go mod`, `go.mod`/`go.sum`) suteikia reproduktyvų, versijomis valdomą, integritetą tikrinantį priklausomybės valdymą — šiuolaikinį standartą, pakeitusį seną GOPATH metodą.

Žinios apie importavimo sistemą, `internal/` konvenciją modulio-privačiam kodui ir įrankius (`go mod init/tidy`, `go get`) yra būtinos Go projektams kurti, dalintis ir palaikyti, ir atspindi praktinį žinojimą Go ekosistemoje.