Kuinka paketit ja moduulit järjestävät Go-koodin?

Question

Accepted Answer

Go järjestää koodin **pakettien** (hakemiston lähdekoodien kokoelmien) ja **moduulien** (pakettien kokoelmien versionoiduilla riippuvuuksilla) avulla. Yhdessä ne jäsentävät projekteja ja hallitsevat riippuvuuksia.

## Paketit — asiaan liittyvän koodin hakemisto

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

Kaikki yhden hakemiston tiedostot kuuluvat yhteen pakettiin. **Isot kirjaimet hallitsevat näkyvyyttä**: isoin kirjaimin kirjoitetut nimet viedään (julkinen pakettien välillä), pienet kirjaimet ovat paketin sisäisiä.

## Pakettien tuominen ja käyttö

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

## Moduulit — versionoitu riippuvuuksien hallinta

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

**Moduuli** (käyttöön otettu Go 1.11:ssä) on riippuvuuksien hallinnan yksikkö — `go.mod` luettelee tarkat riippuvuuksien versiot, jolloin rakentaminen on toistettavaa. `go.sum` vahvistaa riippuvuuksien eheyden.

## init-funktio ja 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)
}
```

## Projektin rakenteen käytännöt

```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/`-hakemisto on erityinen — sen paketteja voidaan tuoda vain saman moduulin sisällä, mikä pakottaa kapseloinnin moduulitasolla.

## Miksi tämä on tärkeää

Paketit ja moduulit ovat, kuinka Go-projektit jäsennellään ja miten riippuvuuksia hallitaan — välttämätöntä mille tahansa todelliselle projektille.

Pakettien ymmärtäminen (tiedostojen hakemisto, isoilla kirjaimilla hallittu viety/vientivapaa näkyvyys, erityinen `main`-paketti) on perusedellytys koodin järjestämiselle ja sen julkisen API:n hallinnalle.

Moduulit (`go mod`, `go.mod`/`go.sum`) tarjoavat toistettavaa, versionoitua, eheyden tarkistettua riippuvuuksien hallintaa — modernin standardin, joka korvasi vanhan GOPATH-lähestymistavan.

Tuontijärjestelmän, `internal/`-käytännön moduulin sisäiselle koodille ja työkalujen (`go mod init/tidy`, `go get`) tunteminen on välttämätöntä Go-projektien rakentamiselle, jakamiselle ja ylläpidolle, ja se heijastaa käytännön sujuvuutta Go-ekosysteemin kanssa.