Hogyan szervezik a Go csomagok és modulok a kódot?

Question

Accepted Answer

A Go a **csomagok** (forrásfájlok egy könyvtárban gyűjtött gyűjteménye) és a **modulok** (csomagok gyűjteménye verzióval ellátott függőségekkel) segítségével szervezi a kódot. Együttesen strukturálják a projekteket és kezelik a függőségeket.

## Csomagok — a kapcsolódó kód könyvtára

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

Egy könyvtárban lévő összes fájl egy csomaghoz tartozik. **A nagybetűs írás szabályozza a láthatóságot**: a nagybetűvel kezdődő nevek exportáltak (csomagok közötti nyilvánosak), a kisbetűs nevek a csomaghoz privátok.

## Csomagok importálása és használata

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

## Modulok — verzióval ellátott függőségkezelé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)
```

A **modul** (bevezetett a Go 1.11-ben) a függőségkezelés egysége — a `go.mod` felsorolja a függőségek pontos verzióit, így az összeállítások megismételhetőek. A `go.sum` ellenőrzi a függőség integritását.

## Az init függvény és a 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)
}
```

## Projekt struktúra konvenciók

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

Az `internal/` könyvtár különleges — csomagjai csak ugyanazon a modulon belül importálhatók, érvényesítve a kapszulázást a modul szintjén.

## Miért fontos

A csomagok és modulok az a módja, ahogy a Go projektek strukturáltak és a függőségek kezeltek — nélkülözhetetlen bármilyen valós projekthez.

A csomagok megértése (fájlok könyvtára, nagybetűs alapú exportált/nem exportált láthatóság, a speciális `main` csomag) alapvető a kód szervezéséhez és nyilvános API-jának vezérléséhez.

A modulok (`go mod`, `go.mod`/`go.sum`) megismételhetőséget, verziózást, integritásellenőrzést biztosító függőségkezelést nyújtanak — a modern szabvány, amely a régi GOPATH megközelítést váltotta fel.

Az import rendszer, az `internal/` konvenció a modul-privát kódhoz, valamint az eszközök (`go mod init/tidy`, `go get`) ismerete szükséges a Go projektek létrehozásához, megosztásához és karbantartásához, és a Go ökoszisztémával való gyakorlati gyakorlottsággal is jár.