package และ module จัดระเบียบโค้ด Go อย่างไร?

Question

Accepted Answer

Go จัดระเบียบโค้ดด้วย **package** (กลุ่มของไฟล์ source ในไดเรกทอรีหนึ่ง) และ **module** (กลุ่มของ package พร้อมการจัดการ dependency แบบมีเวอร์ชัน) เมื่อรวมกันแล้วมันช่วยจัดโครงสร้างโปรเจกต์และจัดการ dependency

## Package — ไดเรกทอรีของโค้ดที่เกี่ยวข้องกัน

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

ไฟล์ทั้งหมดในไดเรกทอรีเดียวกันจัดอยู่ใน package เดียวกัน **การใช้ตัวพิมพ์ใหญ่ควบคุมการมองเห็น (visibility)**: ชื่อที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่จะถูก export (เป็น public ข้าม package) ส่วนตัวพิมพ์เล็กจะเป็น private ภายใน package

## การ import และใช้งาน 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 — การจัดการ dependency แบบมีเวอร์ชัน

```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** (เริ่มมีใน Go 1.11) เป็นหน่วยของการจัดการ dependency — `go.mod` ระบุเวอร์ชันของ dependency อย่างแม่นยำ ทำให้การ build ทำซ้ำได้ (reproducible) ส่วน `go.sum` ใช้ตรวจสอบความถูกต้องของ dependency

## ฟังก์ชัน init และ 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)
}
```

## ข้อตกลงเรื่องโครงสร้างโปรเจกต์

```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/` เป็นกรณีพิเศษ — package ในนั้นจะ import ได้เฉพาะภายใน module เดียวกันเท่านั้น เป็นการบังคับ encapsulation ในระดับ module

## ทำไมจึงสำคัญ

package และ module คือวิธีที่โปรเจกต์ Go ถูกจัดโครงสร้างและจัดการ dependency — เป็นสิ่งจำเป็นสำหรับโปรเจกต์จริงใด ๆ

การเข้าใจ package (ไดเรกทอรีของไฟล์, visibility แบบ exported/unexported ตามการใช้ตัวพิมพ์ใหญ่, package `main` พิเศษ) เป็นพื้นฐานในการจัดระเบียบโค้ดและควบคุม public API ของมัน

module (`go mod`, `go.mod`/`go.sum`) ให้การจัดการ dependency ที่ทำซ้ำได้ มีเวอร์ชัน และตรวจสอบความถูกต้องได้ — เป็นมาตรฐานสมัยใหม่ที่มาแทนแนวทาง GOPATH แบบเก่า

การรู้จักระบบ import, ข้อตกลง `internal/` สำหรับโค้ดที่เป็น private ของ module และเครื่องมือต่าง ๆ (`go mod init/tidy`, `go get`) เป็นสิ่งจำเป็นสำหรับการ build, แบ่งปัน และดูแลโปรเจกต์ Go และสะท้อนความคล่องเชิงปฏิบัติกับ ecosystem ของ Go