Hoe organiseren packages en modules Go-code?

Question

IT Interview Practice · Accepted Answer

Go organiseert code met **packages** (verzamelingen van bronbestanden in een directory) en **modules** (verzamelingen van packages met versioned dependencies). Samen structureren ze projecten en beheren ze dependencies.

## Packages — een directory met gerelateerde code

```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 bestanden in één directory behoren tot één package. **Capitalisatie controleert zichtbaarheid**: gekapitaliseerde namen zijn geëxporteerd (publiek over packages heen), kleine letters zijn privé voor het package.

## Packages importeren en gebruiken

```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 — versionbeheer voor dependencies

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

Een **module** (geïntroduceerd in Go 1.11) is de eenheid van dependency management — `go.mod` geeft exacte dependency-versies aan, wat reproduceerbare builds mogelijk maakt. `go.sum` verifieert de integriteit van dependencies.

## De init-functie en 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)
}
```

## Projectstructuurconventies

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

De `internal/`-directory is speciaal — de packages ervan kunnen alleen binnen dezelfde module worden geïmporteerd, wat encapsulatie op moduleniveau afdwingt.

## Waarom het belangrijk is

Packages en modules bepalen hoe Go-projecten zijn gestructureerd en hoe dependencies worden beheerd — essentieel voor elk echt project.

Het begrijpen van packages (een directory van bestanden, capitalisatie-gebaseerde exported/unexported zichtbaarheid, het speciale `main`-package) is fundamenteel voor het organiseren van code en het controleren van de publieke API.

Modules (`go mod`, `go.mod`/`go.sum`) bieden reproduceerbaar, versioned, integriteit-gecontroleerd dependency management — de moderne standaard die de oude GOPATH-benadering verving.

Het kennen van het importsysteem, de `internal/`-conventie voor modulepriveé-code, en de gereedschappen (`go mod init/tidy`, `go get`) is nodig voor het bouwen, delen en onderhouden van Go-projecten, en weerspiegelt praktische vaardigheid met het Go-ecosysteem.

Packages — een directory met gerelateerde code

Packages importeren en gebruiken

Modules — versionbeheer voor dependencies

De init-functie en main

Projectstructuurconventies

Waarom het belangrijk is

Gerelateerde vragen