Hvordan organiserer pakker og moduler Go-koden?

Question

Accepted Answer

Go organiserer koden med **pakker** (samlinger av kildefiler i en katalog) og **moduler** (samlinger av pakker med versjonerte avhengigheter). Sammen strukturerer de prosjekter og styrer avhengigheter.

## Pakker — en katalog med relatert kode

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

Alle filer i én katalog tilhører én pakke. **Kapitalisering kontrollerer synlighet**: kapitaliserte navn er eksportert (offentlig på tvers av pakker), små bokstaver er private for pakken.

## Importering og bruk av pakker

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

## Moduler — versjonert avhengighetsstyring

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

En **modul** (introdusert i Go 1.11) er enheten for avhengighetsstyring — `go.mod` viser eksakte avhengighetsversjoner, noe som gjør bygg reproduserbare. `go.sum` verifiserer integriteten til avhengigheter.

## Init-funksjonen og 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)
}
```

## Konvensjoner for prosjektstruktur

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

`internal/`-katalogen er spesiell — dens pakker kan bare importeres innenfor samme modul, noe som håndhever innkapsling på modulnivå.

## Hvorfor det betyr noe

Pakker og moduler er hvordan Go-prosjekter struktureres og hvordan avhengigheter styres — essensielt for ethvert reelt prosjekt.

Å forstå pakker (en katalog med filer, kapitalisering-basert eksportert/ueksportert synlighet, den spesielle `main`-pakken) er grunnleggende for å organisere kode og kontrollere dens offentlige API.

Moduler (`go mod`, `go.mod`/`go.sum`) gir reproduserbar, versjonert, integritetskontrollert avhengighetsstyring — den moderne standarden som erstattet den gamle GOPATH-tilnærmingen.

Å kjenne importsystemet, `internal/`-konvensjonen for modulinternt kode, og verktøyene (`go mod init/tidy`, `go get`) er nødvendig for å bygge, dele og vedlikeholde Go-prosjekter, og gjenspeiler praktisk flyt i Go-økosystemet.