Si organizojnë paketat dhe modulet kodin në Go?

Question

Accepted Answer

Go organizon kodin me **paketa** (koleksione të skedarëve burimi në një drejtori) dhe **module** (koleksione të paketave me varësi të versjonuara). Së bashku ato strukturojnë projektet dhe menaxhojnë varësitë.

## Paketat — një drejtori kodi të ndërlidhur

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

Të gjithë skedarët në një drejtori i përkasin një pakete. **Kapitalizimi kontrollon dukshmërinë**: emrat me shkronja të mëdha janë të eksportuar (publik në të gjitha paketat), të mirat janë private në paketë.

## Importimi dhe përdorimi i paketave

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

## Modulet — menaxhimi i varësive të versjonuara

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

Një **modul** (i prezantuar në Go 1.11) është njësia e menaxhimit të varësive — `go.mod` liston versionet e sakte të varësive, duke e bërë ndërtimet të pershëndetshmë. `go.sum` verifikojnë integritetin e varësive.

## Funksioni init dhe 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)
}
```

## Konventat e strukturës së projektit

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

Direktoria `internal/` është e veçantë — paketat e saj mund të importohen vetëm brenda të njëjtës modul, duke forcuar enkapsulim në nivelin e modulit.

## Pse ka rëndësi

Paketat dhe modulet janë se si strukturohen projektet Go dhe se si menaxhohen varësitë — thelbësor për çdo projekt të vërtetë.

Kuptimi i paketave (një drejtori skedarësh, dukshmëria e eksportuar/të pamesuara bazuar në kapitalizim, paketa e veçantë `main`) është themelor për organizimin e kodit dhe kontrollimin e API-t të tij publik.

Modulet (`go mod`, `go.mod`/`go.sum`) ofrojnë menaxhimin e varësive të pershëndetshmë, të versjonuar dhe të verifikuar integritet — standardi modern që zëvendësoi qasjen e vjetër GOPATH.

Dija e sistemit të importimit, konventa `internal/` për kodin privat të modulit, dhe mjetet (`go mod init/tidy`, `go get`) është e nevojshme për ndërtimin, ndarjen dhe mirëmbajtjen e projekteve Go, dhe reflekton aftësi praktike me ekosisteminin Go.