Conas a eagraíonn packages agus modules cód Go?

Question

Accepted Answer

Eagraíonn Go cód le **packages** (bailiúchán de chomhaid fhoinse i eolaire) agus **modules** (bailiúchán de packages le spleáchais dhínn-leagtha). Ar an iomlán, eagraíonn siad tionscadail agus bhainistríonn siad spleáchais.

## Packages — eolaire de chód a bhaineann le chéile

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

Baineann gach comhad in eolaire amháin do phacáiste amháin. **Rialaíonn capitalization infheictheachta**: is iad ainmneacha capitalized iad atá easpórtáilte (poiblí ar fud packages), is príobháideacha do phacáiste iad na ceann lowercase.

## A thabhairt isteach agus packages a úsáid

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

## Modules — bainistríochtaint spleáchais dhínn-leagtha

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

Is é **module** (tugtha isteach in Go 1.11) an t-aonad bhainistríochta spleáchais — listaíonn `go.mod` leaganna cruinn na spleáchais, rud a fhágann go bhfuil builds inathchóireach. Fíoraíonn `go.sum` slándáil an spleáchais.

## An fheidhm init agus 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)
}
```

## Coinbhinsiúin struchtúir thionscadail

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

Tá an eolaire `internal/` speisialta — ní féidir a phacáistí a iomairteoir ach laistigh den mhodúl céanna, ag forfheidhmiú fhlapúcháin ar an leibhéal modúil.

## Cén fáth a bhí sé tábhachtach

Is iad packages agus modules an chaoi a bhfuil tionscadail Go struchtúraithe agus an chaoi a bhfuil spleáchais bhainistríochta — riachtanach do thionscadal fíor ar bith.

Tá tuiscint ar packages (eolaire de chomhaid, infheictheachta easpórtáilte/neamh-easpórtáilte bunaithe ar capitalization, an pacáiste speisialta `main`) bhunúsach chun cód a eagrú agus a API poiblí a rialú.

Soláthraíonn modules (`go mod`, `go.mod`/`go.sum`) bainistríochtaint spleáchais inathchóireach, dínn-leagtha, agus shandúilte ar slándáil — an caighdeán nua-aimseartha a chuir ionad an tseanathbhealach GOPATH.

Tá gá atá ann don chóras iomportála, an choinbhinsiún `internal/` do chód príobháideach modúil, agus na huirlisí (`go mod init/tidy`, `go get`) atá riachtanach chun tionscadail Go a thógáil, a roinnt agus a chothabháil, agus léiríonn sé soithí glic phraiticiúla leis an spásúchán Go.