Bagaimanakah package dan module menyusun kod Go?

Question

Accepted Answer

Go menyusun kod menggunakan **package** (koleksi fail sumber dalam satu direktori) dan **module** (koleksi package dengan kebergantungan berversi). Bersama-sama, ia menstrukturkan projek dan menguruskan kebergantungan.

## Package — direktori kod yang berkaitan

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

Semua fail dalam satu direktori tergolong dalam satu package. **Penggunaan huruf besar mengawal keterlihatan**: nama bermula huruf besar dieksport (awam merentas package), huruf kecil pula peribadi kepada package itu.

## Mengimport dan menggunakan package

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

## Module — pengurusan kebergantungan berversi

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

Sebuah **module** (diperkenalkan dalam Go 1.11) ialah unit pengurusan kebergantungan — `go.mod` menyenaraikan versi kebergantungan yang tepat, menjadikan binaan boleh dihasilkan semula. `go.sum` mengesahkan integriti kebergantungan.

## Fungsi init dan 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)
}
```

## Konvensi struktur projek

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

Direktori `internal/` adalah istimewa — package di dalamnya hanya boleh diimport dalam module yang sama, menguatkuasakan enkapsulasi pada peringkat module.

## Mengapa ia penting

Package dan module ialah cara projek Go distrukturkan dan cara kebergantungan diuruskan — penting untuk mana-mana projek sebenar.

Memahami package (direktori fail, keterlihatan dieksport/tidak dieksport berdasarkan huruf besar, package `main` yang istimewa) adalah asas untuk menyusun kod dan mengawal API awamnya.

Module (`go mod`, `go.mod`/`go.sum`) menyediakan pengurusan kebergantungan yang boleh dihasilkan semula, berversi, dan disemak integriti — piawaian moden yang menggantikan pendekatan GOPATH lama.

Mengetahui sistem import, konvensi `internal/` untuk kod peribadi module, dan perkakasan (`go mod init/tidy`, `go get`) adalah perlu untuk membina, berkongsi, dan menyelenggara projek Go, serta mencerminkan kefasihan praktikal dengan ekosistem Go.