Packages na modules hupanga vipi msimbo wa Go?

Question

Accepted Answer

Go hupanga msimbo kwa **packages** (makusanyo ya faili za chanzo katika directory) na **modules** (makusanyo ya packages yenye dependencies za matoleo). Pamoja huunda muundo wa miradi na kusimamia dependencies.

## Packages — directory ya msimbo unaohusiana

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

Faili zote katika directory moja ni za package moja. **Herufi kubwa hudhibiti uonekanaji**: majina yenye herufi kubwa yameuzwa nje (yana umma kupitia packages), ya herufi ndogo ni ya faragha kwa package.

## Kuingiza na kutumia packages

```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 — usimamizi wa dependency wa matoleo

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

**Module** (lililotambulishwa katika Go 1.11) ni kipimo cha usimamizi wa dependency — `go.mod` huorodhesha matoleo kamili ya dependency, kufanya builds kuweza kurudiwa. `go.sum` huthibitisha uadilifu wa dependency.

## Function ya init na 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)
}
```

## Mikataba ya muundo wa mradi

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

Directory ya `internal/` ni maalum — packages zake zinaweza kuingizwa tu ndani ya module ile ile, ikilazimisha ufungaji katika kiwango cha module.

## Kwa nini ni muhimu

Packages na modules ndizo namna miradi ya Go inavyoundwa na jinsi dependencies zinavyosimamiwa — muhimu kwa mradi wowote halisi.

Kuelewa packages (directory ya faili, uonekanaji uliouzwa-nje/usiouzwa-nje unaotegemea herufi kubwa, package maalum ya `main`) ni msingi wa kupanga msimbo na kudhibiti API yake ya umma.

Modules (`go mod`, `go.mod`/`go.sum`) hutoa usimamizi wa dependency unaoweza kurudiwa, wa matoleo, na uliokaguliwa uadilifu — kiwango cha kisasa kilichobadilisha mbinu ya zamani ya GOPATH.

Kujua mfumo wa import, mkataba wa `internal/` kwa msimbo wa faragha wa module, na zana (`go mod init/tidy`, `go get`) ni muhimu kwa kujenga, kushiriki, na kudumisha miradi ya Go, na huonyesha ufasaha wa vitendo na mfumo wa ekolojia wa Go.