Paano packages da modules suke jadada Code Go?

Question

Accepted Answer

Go yana na organize code da **packages** (tsarin fayilolin tushe a cikin directory) da **modules** (tsarin packages tare da versions ne dogara wajen). Juna suka tsara aiki da sarrafa dogara.

## Packages — directory na code da yayi daidai

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

Duk fayilolin a cikin directory daya sun gabata dafa package daya. **Capitalization yana kontrolin ganawa**: sunaye masu capital suni ne aka fitar (jama'a ta harshe packages), ƙasa ne siri ne ga package.

## Shigowa da yin abin da 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 — sarrafa dogara masu versions

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

A **module** (introdocir a Go 1.11) shine ginshiki na sarrafa dogara — `go.mod` yana jera daidai versions na dogara, ƙara sabon jiya gida. `go.sum` yana tabbatarwa ma'auni na dogara.

## The init function da 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)
}
```

## Project structure conventions

```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 `internal/` yana ban sha'anta — packages yana iya zama import kawai a cikin module guda, ƙara inkaracin dogara a module level.

## Why it matters

Packages da modules suni ne tsari na Go projects da yadda dogara suke sarrafa — dole ne ga kowane aiki na gaske.

Sanin packages (directory na fayiloli, capitalization-based exported/unexported ganawa, special `main` package) shine ginshiki don tsara code da sarrafa public API.

Modules (`go mod`, `go.mod`/`go.sum`) yana ba da jiya reproduction, versions, integrity-checked sarrafa dogara — the modern standard da canza tsohon GOPATH return.

Sanin import system, `internal/` convention don module-private code, da kayan aiki (`go mod init/tidy`, `go get`) dole ne don gina, rarraba da kula da Go projects, da yana nuna practical fluency tare da Go ecosystem.