Wie organisieren Pakete und Module Go-Code?

Question

Accepted Answer

Go organisiert Code mit **Paketen** (Sammlungen von Quelldateien in einem Verzeichnis) und **Modulen** (Sammlungen von Paketen mit versionierten Abhängigkeiten). Zusammen strukturieren sie Projekte und verwalten Abhängigkeiten.

## Pakete — ein Verzeichnis zusammenhängenden Codes

```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 Dateien in einem Verzeichnis gehören zu einem Paket. **Großbuchstaben steuern die Sichtbarkeit**: Mit Großbuchstaben geschriebene Namen sind exportiert (öffentlich über Pakete hinweg), Kleinbuchstaben sind private des Pakets.

## Pakete importieren und verwenden

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

## Module — versionierte Abhängigkeitsverwaltung

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

Ein **Modul** (in Go 1.11 eingeführt) ist die Einheit der Abhängigkeitsverwaltung — `go.mod` listet exakte Abhängigkeitsversionen auf, was Builds reproduzierbar macht. `go.sum` verifiziert die Integrität der Abhängigkeiten.

## Die init-Funktion und 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)
}
```

## Projektstrukturkonventionen

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

Das Verzeichnis `internal/` ist speziell — seine Pakete können nur innerhalb desselben Moduls importiert werden, was Kapselung auf Modulebene erzwingt.

## Warum es wichtig ist

Pakete und Module sind die Art und Weise, wie Go-Projekte strukturiert werden und wie Abhängigkeiten verwaltet werden — unerlässlich für jedes reale Projekt.

Das Verständnis von Paketen (ein Verzeichnis von Dateien, großbuchstabennbasierte exportierte/nicht exportierte Sichtbarkeit, das spezielle `main`-Paket) ist grundlegend für die Code-Organisation und die Kontrolle der öffentlichen API.

Module (`go mod`, `go.mod`/`go.sum`) bieten reproduzierbare, versionierte, integritätsgeprüfte Abhängigkeitsverwaltung — der moderne Standard, der den alten GOPATH-Ansatz ersetzte.

Die Kenntnis des Importsystems, der `internal/`-Konvention für modulprivaten Code und der Tools (`go mod init/tidy`, `go get`) ist notwendig zum Erstellen, Teilen und Verwalten von Go-Projekten und spiegelt praktische Flüssigkeit mit dem Go-Ökosystem wider.