ทำ go-module ไว้ใช้เองกันครับ
เวลาเขียน Go หลายโปรเจกต์ เรามักเจอฟังก์ชันหน้าคุ้น ๆ เดินกลับมาเคาะประตู เช่น แปลง Pointer, จัดรูปแบบ String หรือช่วยจัดการ Error ตอนแรก Copy ไปวางก็เร็วดี แต่พอแก้บั๊กในสำเนาที่ 7 เราจะเริ่มสงสัยว่าทำไมตัวเองเปิดโรงงานโคลนโค้ดไว้ทั่ว GitHub
Go Module ช่วยรวม Package ที่เกี่ยวข้องไว้เป็นหน่วยเดียว มีชื่อ มี Dependency และออก Version ให้โปรเจกต์อื่นเรียกใช้ได้ วันนี้เราจะสร้าง Module เล็ก ๆ ตั้งแต่ศูนย์ ใส่ Test, Tag Version และลองเรียกจากอีกโปรเจกต์ครับ
Module กับ Package ต่างกันอย่างไร
สองคำนี้ชอบเดินมาด้วยกันจนคนเริ่มต้นสับสน:
- Package คือกลุ่มไฟล์ Go ในโฟลเดอร์เดียวกัน และใช้
packageชื่อเดียวกัน - Module คือกลุ่มของ Package ที่ออก Version และแจกจ่ายร่วมกัน โดยมี
go.modอยู่ที่ราก
เปรียบง่าย ๆ Package คือห้อง ส่วน Module คือบ้านหนึ่งหลัง ในบ้านมีหลายห้องได้ แต่เลขที่บ้านหรือ Module Path มีหนึ่งค่าไว้ให้คนอื่นเดินทางมาถูกครับ
สร้างโปรเจกต์และกำหนด Module Path
เริ่มจากสร้างโฟลเดอร์:
mkdir go-module-utils
cd go-module-utils
จากนั้นใช้ go mod init ไม่ใช่ go init โดย Module Path ควรตรงกับที่ Repository จะถูกเผยแพร่:
go mod init github.com/nanpipat-dev/go-module-utils
Go จะสร้างไฟล์ go.mod เพื่อบอกชื่อ Module และ Go version ที่ต้องการ ถ้ามี Dependency ภายนอก รายการจะถูกเติมเข้ามาที่นี่ภายหลัง
วางโครงให้หนึ่ง Repository เป็นหนึ่ง Module
สำหรับ Utility ขนาดเล็ก โครงที่อ่านง่ายมีหน้าตาแบบนี้:
go-module-utils/
├── go.mod
├── pointer2value/
│ ├── pointer2value.go
│ └── pointer2value_test.go
└── README.md

โฟลเดอร์ pointer2value เป็น Package หนึ่งตัว ไม่จำเป็นต้องสร้าง go.mod แยกในทุกโฟลเดอร์ เพราะ Module เดียวมีหลาย Package ได้ การแยก Module ย่อยควรทำเมื่อแต่ละส่วนต้องออก Version และจัด Dependency แยกกันจริง ๆ
เขียน Package ที่เล็กแต่มีสัญญาชัดเจน
ตัวอย่างแปลง Pointer เป็นค่า โดยคืนค่าเริ่มต้นเมื่อ Pointer เป็น nil:
package pointer2value
func String(value *string) string {
if value == nil {
return ""
}
return *value
}
func Int(value *int) int {
if value == nil {
return 0
}
return *value
}

ชื่อที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่คือ Public API ของ Package ทุกชื่อที่ Export ออกไปกลายเป็นคำสัญญากับผู้ใช้ Module เรา จึงควรออกแบบให้น้อย ชัด และเปลี่ยนอย่างระมัดระวัง ไม่อย่างนั้น Utility เล็ก ๆ จะกลายเป็นเจ้าหนี้ที่โทรตามทุกครั้งที่เราอยาก Refactor ครับ
เขียน Test ก่อนแจกของให้คนอื่น
ไฟล์ pointer2value_test.go:
package pointer2value_test
import (
"testing"
"github.com/nanpipat-dev/go-module-utils/pointer2value"
)
func TestString(t *testing.T) {
value := "hello"
tests := []struct {
name string
input *string
want string
}{
{name: "value", input: &value, want: "hello"},
{name: "nil", input: nil, want: ""},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := pointer2value.String(tt.input)
if got != tt.want {
t.Fatalf("String() = %q, want %q", got, tt.want)
}
})
}
}
รันเครื่องมือพื้นฐานให้ครบ:
go fmt ./...
go vet ./...
go test ./...
go mod tidy
go mod tidy ช่วยเติม Dependency ที่จำเป็นและลบรายการที่ไม่ได้ใช้ ส่วน Test คือหลักฐานว่า Package ทำตามสัญญาก่อนนำขึ้น Repository
Push ขึ้น GitHub และออก Version
สร้าง Repository ให้ชื่อและ Path ตรงกับ Module ที่ประกาศไว้

จากนั้น Commit และ Push:
git init
git add .
git commit -m "feat: add pointer2value package"
git branch -M main
git remote add origin git@github.com:nanpipat-dev/go-module-utils.git
git push -u origin main

Go Module ใช้ Semantic Versioning รูปแบบ vMAJOR.MINOR.PATCH:
- PATCH แก้บั๊กโดยไม่ทำลาย API เดิม
- MINOR เพิ่มความสามารถที่ยังใช้ของเดิมได้
- MAJOR มี Breaking Change
สร้าง Tag แล้ว Push:
git tag v1.0.0
git push origin v1.0.0

อย่าแก้ Tag ที่เผยแพร่แล้วแล้ว Push ทับ เพราะ Go checksum database อาจพบว่า Source ของ Version เดิมเปลี่ยนไป วิธีที่ถูกคือออก Version ใหม่ครับ
เรียกใช้จากอีกโปรเจกต์
สร้างโปรเจกต์ทดลอง:
mkdir module-consumer
cd module-consumer
go mod init example.com/module-consumer
go get github.com/nanpipat-dev/go-module-utils@v1.0.0

ตัวอย่าง main.go:
package main
import (
"fmt"
"github.com/nanpipat-dev/go-module-utils/pointer2value"
)
func main() {
message := "hello module"
fmt.Println(pointer2value.String(&message))
fmt.Println(pointer2value.String(nil))
}
รันด้วย:
go run .

ถ้าผลลัพธ์ออกมาตามคาด แปลว่าโปรเจกต์ใหม่ดาวน์โหลด Module ตาม Version แล้ว Import Package ภายในได้เรียบร้อย
พัฒนา Module สองตัวพร้อมกันด้วย go work
จุดอัปเดตสำคัญใน Go รุ่นใหม่คือ Workspace หรือ go.work สมมติเรากำลังแก้ทั้ง Module Utility และ App พร้อมกัน แต่ยังไม่อยาก Tag Utility ทุกครั้ง ใช้คำสั่งนี้ที่โฟลเดอร์แม่ได้:
go work init ./go-module-utils ./module-consumer
Go จะใช้ Source ในเครื่องของทั้งสอง Module ร่วมกัน ทำให้ App เห็นการแก้ Utility ทันที โดยไม่ต้องใส่ replace ชั่วคราวใน go.mod
คำสั่งที่ใช้บ่อย:
go work use ./another-module
go work sync
ก่อนปล่อยจริงต้องยังทดสอบกับ Version ที่ Tag แล้ว เพราะ Workspace ในเครื่องเราไม่ใช่หลักฐานว่า Consumer นอกเครื่องจะดาวน์โหลด Release ได้ถูกต้องครับ
ถ้า Module เป็น Private ต้องทำอะไรเพิ่ม
สำหรับ Private repository ต้องให้ Git มี Credential ที่เข้าถึง Repository และบอก Go ว่า Path นี้เป็น Private เพื่อไม่ส่งคำขอไปยัง Public proxy หรือ checksum database:
go env -w GOPRIVATE=github.com/your-org/*
ใน CI ควรใช้ Token หรือ SSH key ที่สิทธิ์เท่าที่จำเป็น และเก็บใน Secret manager อย่าเขียน Credential ลง go.mod, Source Code หรือ URL ที่ Commit ขึ้น Git
Checklist ก่อนปล่อย Module
- Module Path ตรงกับ Repository
- Public API มีชื่อและ Comment ที่เข้าใจง่าย
go test ./...ผ่านgo vet ./...ผ่าน- รัน
go mod tidyแล้ว - มี README และตัวอย่างใช้งาน
- Tag เป็นรูปแบบ
v1.0.0 - ไม่แก้ Tag เก่าหลังเผยแพร่
- ถ้าขึ้น Major version 2 เป็นต้นไป Module Path ต้องมี
/v2,/v3ตามกติกา Go
สรุป
การทำ Go Module ไม่ใช่แค่เอาฟังก์ชันรวมใส่ Repository แล้ว go get มาครับ เรากำลังสร้างของที่โปรเจกต์อื่นฝากความไว้ใจไว้กับ Version และ Public API ของเรา
เริ่มจาก Module ที่ทำเรื่องเดียวให้ดี มี Test และออก Version อย่างตรงไปตรงมา เมื่อหลาย Module ต้องพัฒนาพร้อมกันค่อยใช้ go.work เป็นโต๊ะทำงานร่วม ส่วน Release จริงยังต้องผูกกับ Tag เสมอ เพียงเท่านี้เราก็หยุดโรงงาน Copy-Paste และมี Utility ที่อัปเกรดได้อย่างเป็นระบบแล้วครับ
อ่านต่อจากเอกสารทางการ:
