W jaki sposób pakiety i moduły organizują kod w Go?

Question

Accepted Answer

Go organizuje kod za pomocą **pakietów** (kolekcji plików źródłowych w katalogu) i **modułów** (kolekcji pakietów z wersjami zależności). Razem tworzą strukturę projektów i zarządzają zależnościami.

## Pakiety — katalog powiązanego kodu

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

Wszystkie pliki w jednym katalogu należą do jednego pakietu. **Wielkość liter kontroluje widoczność**: nazwy zaczynające się od dużej litery są eksportowane (publiczne między pakietami), małe litery są prywatne dla pakietu.

## Importowanie i używanie pakietów

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

## Moduły — zarządzanie wersjami zależności

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

**Moduł** (wprowadzony w Go 1.11) to jednostka zarządzania zależnościami — `go.mod` zawiera dokładne wersje zależności, czyniąc kompilacje powtarzalnymi. `go.sum` weryfikuje integralność zależności.

## Funkcja init i 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)
}
```

## Konwencje struktury projektu

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

Katalog `internal/` jest specjalny — jego pakiety mogą być importowane tylko w ramach tego samego modułu, wymuszając enkapsulację na poziomie modułu.

## Dlaczego to ważne

Pakiety i moduły to sposób, w jaki projekty Go są strukturyzowane i jak są zarządzane zależności — niezbędne dla każdego rzeczywistego projektu.

Zrozumienie pakietów (katalog plików, widoczność oparta na wielkości liter dla eksportowanych/nieeksportowanych, specjalny pakiet `main`) jest fundamentem organizacji kodu i kontrolowania jego publicznego API.

Moduły (`go mod`, `go.mod`/`go.sum`) zapewniają powtarzalne, wersjonowane i weryfikowane pod względem integralności zarządzanie zależnościami — nowoczesny standard, który zastąpił stary podход GOPATH.

Znajomość systemu importu, konwencji `internal/` dla kodu prywatnego modułu i narzędzi (`go mod init/tidy`, `go get`) jest niezbędna do budowania, udostępniania i utrzymywania projektów Go oraz odzwierciedla praktyczną biegłość w ekosystemie Go.