# Go (Golang) — คู่มือฉบับสมบูรณ์ ตั้งแต่พื้นฐานยันระดับมืออาชีพ บทความนี้เขียนสำหรับนักพัฒนาที่อยากเข้าใจ Go อย่างลึกซึ้ง ไม่ใช่แค่เขียนได้ แต่เข้าใจว่าทำไมต้องเขียนแบบนี้ และเอาไปใช้งานจริงในระดับ production ได้ --- ## สารบัญ 1. [ทำไมต้อง Go](#1-ทำไมต้อง-go) 2. [Setup สภาพแวดล้อม](#2-setup-สภาพแวดล้อม) 3. [Hello World และโครงสร้างโปรแกรม](#3-hello-world-และโครงสร้างโปรแกรม) 4. [Variables, Constants และ Types](#4-variables-constants-และ-types) 5. [Control Flow](#5-control-flow) 6. [Functions](#6-functions) 7. [Pointers](#7-pointers) 8. [Arrays, Slices และ Maps](#8-arrays-slices-และ-maps) 9. [Structs และ Methods](#9-structs-และ-methods) 10. [Interfaces](#10-interfaces) 11. [Error Handling](#11-error-handling) 12. [Packages และ Modules](#12-packages-และ-modules) 13. [Goroutines และ Channels (Concurrency)](#13-goroutines-และ-channels-concurrency) 14. [Context](#14-context) 15. [Generics](#15-generics) 16. [Testing](#16-testing) 17. [Performance, Profiling และ Benchmark](#17-performance-profiling-และ-benchmark) 18. [Patterns ที่ใช้ใน Production](#18-patterns-ที่ใช้ใน-production) 19. [การสร้าง REST API ด้วย Fiber](#19-การสร้าง-rest-api-ด้วย-fiber) 20. [Database, Migration, Repository Pattern](#20-database-migration-repository-pattern) 21. [Observability — Logging, Metrics, Tracing](#21-observability) 22. [Build, Deploy, Docker](#22-build-deploy-docker) 23. [สรุปและเส้นทางต่อไป](#23-สรุปและเส้นทางต่อไป) --- ## 1. ทำไมต้อง Go Go (หรือ Golang) ถูกพัฒนาโดย Google ในปี 2007 โดย Robert Griesemer, Rob Pike และ Ken Thompson เปิดตัวในปี 2009 ด้วยเป้าหมายที่ชัดเจน: แก้ปัญหาที่วิศวกรของ Google เจอกับ C++ ในการสร้างระบบขนาดใหญ่ ### จุดเด่นที่ทำให้ Go กลายเป็นภาษาหลักของ Cloud Infrastructure - **Compile เร็วมาก** — โปรเจกต์ขนาดกลาง compile เสร็จใน 2-3 วินาที - **Static binary** — build แล้วได้ไฟล์เดียว ไม่ต้องลง runtime บนเครื่อง production - **Concurrency เป็น first-class** — goroutine และ channel ทำให้เขียนโปรแกรมที่รัน concurrent ได้ง่ายกว่า thread แบบดั้งเดิม - **Garbage Collector ที่ดี** — pause time ต่ำกว่า 1ms ในเวอร์ชันใหม่ๆ - **Standard library ที่แข็งแรง** — net/http, encoding/json, database/sql ใช้งานได้จริงโดยไม่ต้องลง dependency เพิ่ม - **Tooling ที่รวมในภาษา** — `go fmt`, `go test`, `go vet`, `go mod` ลดปัญหาเรื่อง toolchain ### Go เหมาะกับงานแบบไหน - API Gateway / Microservices (เช่น Kubernetes, Docker, Traefik เขียนด้วย Go) - CLI tools (เช่น Hugo, kubectl, helm) - Networking / Proxy / Load balancer - DevOps / Infrastructure tools - Real-time backend ที่ต้องรับ traffic สูง ### Go ไม่เหมาะกับงานแบบไหน - งาน UI หรือ client-side frontend (ใช้ TypeScript ดีกว่า) - Data science / ML (Python ครองตลาด) - งานที่ต้องการ generic แบบ deep metaprogramming (Go generics จำกัดกว่า C++/Rust) --- ## 2. Setup สภาพแวดล้อม ### ติดตั้ง Go ดาวน์โหลดจาก https://go.dev/dl/ หรือใช้ package manager: ```bash # macOS brew install go # Ubuntu / Debian sudo apt install golang-go # หรือใช้ asdf เพื่อจัดการหลายเวอร์ชัน asdf plugin add golang asdf install golang latest asdf global golang latest ``` ตรวจสอบ: ```bash go version # go version go1.22.0 linux/amd64 ``` ### โครงสร้างมาตรฐานของโปรเจกต์ Go ``` my-project/ ├── cmd/ │ └── server/ │ └── main.go # entry point ├── internal/ # โค้ดภายใน ห้าม import จากภายนอกโปรเจกต์ │ ├── handler/ │ ├── service/ │ └── repository/ ├── pkg/ # โค้ดที่ออกแบบให้ใช้ร่วมกับโปรเจกต์อื่นได้ ├── api/ # OpenAPI specs, proto files ├── configs/ ├── scripts/ ├── go.mod ├── go.sum └── README.md ``` > **Tip:** การใช้ `internal/` สำคัญมาก — Go compiler จะบล็อกการ import จากภายนอกโดยอัตโนมัติ ทำให้ขอบเขตของ public API ชัดเจน ### สร้างโปรเจกต์แรก ```bash mkdir hello-go && cd hello-go go mod init github.com/yourname/hello-go ``` ไฟล์ `go.mod` จะถูกสร้างขึ้น เป็น manifest ของโมดูล: ```go module github.com/yourname/hello-go go 1.22 ``` --- ## 3. Hello World และโครงสร้างโปรแกรม ```go // File: main.go package main import "fmt" func main() { fmt.Println("สวัสดีชาวโลก") } ``` รัน: ```bash go run main.go # สวัสดีชาวโลก ``` Build เป็น binary: ```bash go build -o hello main.go ./hello ``` ### องค์ประกอบสำคัญ - **`package main`** — ทุกไฟล์ Go ต้องประกาศ package เป็นบรรทัดแรก ถ้าจะ build เป็น executable ต้องเป็น `main` - **`import`** — เรียกใช้ package อื่น - **`func main()`** — entry point ของโปรแกรม ### กฎที่หลายคนสะดุดตั้งแต่วันแรก - **Public/Private กำหนดด้วยตัวพิมพ์** — ตัวพิมพ์ใหญ่ขึ้นต้น = export ออกนอก package (เช่น `Println`), ตัวพิมพ์เล็ก = private - **import ที่ไม่ใช้ = compile error** — Go ไม่ให้ผ่อนปรน - **ตัวแปรที่ประกาศแล้วไม่ใช้ = compile error** — ป้องกัน dead code - **`{` ต้องอยู่บรรทัดเดียวกับ `func` หรือ `if`** — ห้ามขึ้นบรรทัดใหม่ --- ## 4. Variables, Constants และ Types ### การประกาศตัวแปร ```go // แบบเต็ม var name string = "Ratanon" // ละ type ได้ (compiler infer ให้) var age = 35 // แบบสั้น (short declaration) ใช้ในฟังก์ชันเท่านั้น city := "Bangkok" // ประกาศหลายตัวพร้อมกัน var ( host = "localhost" port = 8080 enabled = true ) ``` ### Zero values ตัวแปรที่ประกาศโดยไม่กำหนดค่า จะได้ค่า zero ของ type นั้นอัตโนมัติ: | Type | Zero value | |---|---| | `int`, `float64` | `0` | | `string` | `""` | | `bool` | `false` | | pointer, slice, map, channel, function, interface | `nil` | นี่ต่างจาก C/C++ ที่ค่าเป็น undefined — Go ป้องกัน bug ระดับนี้ตั้งแต่ภาษา ### Constants ```go const Pi = 3.14159 const ( StatusActive = "ACTIVE" StatusInactive = "INACTIVE" ) // iota สำหรับ enum-like const ( Sunday = iota // 0 Monday // 1 Tuesday // 2 ) ``` ### Types หลัก ```go // Integer var i8 int8 = 127 // -128 ถึง 127 var i32 int32 = 2_147_483_647 var i64 int64 = 9_223_372_036_854_775_807 var u uint = 100 // ไม่มี sign // Floating point var f32 float32 = 3.14 var f64 float64 = 3.141592653589793 // String (immutable, UTF-8) s := "สวัสดี" fmt.Println(len(s)) // 18 (จำนวน byte ไม่ใช่ rune) // Rune (= int32) ใช้แทนตัวอักษร Unicode 1 ตัว r := 'ก' fmt.Println(r) // 3585 // Boolean var ok bool = true ``` ### Type Conversion Go ไม่ implicit cast เลย ต้องเขียนชัดเจน: ```go i := 42 f := float64(i) s := strconv.Itoa(i) // ไม่ใช่ string(i) นะ — string(42) = "*" ``` --- ## 5. Control Flow ### if / else ```go if score >= 80 { fmt.Println("A") } else if score >= 70 { fmt.Println("B") } else { fmt.Println("F") } // ประกาศตัวแปรใน if (เห็นเฉพาะใน scope นั้น) if user, err := getUser(id); err == nil { fmt.Println(user.Name) } else { log.Println(err) } ``` ### for (Go มี loop เดียว) ```go // แบบ C for i := 0; i < 10; i++ { fmt.Println(i) } // แบบ while i := 0 for i < 10 { i++ } // infinite loop for { if done { break } } // range (วน slice/map/string/channel) nums := []int{10, 20, 30} for index, value := range nums { fmt.Println(index, value) } // ถ้าไม่ใช้ index for _, v := range nums { fmt.Println(v) } ``` ### switch Go switch ไม่ต้องใส่ `break` — fall through ไม่อัตโนมัติ ต่างจาก C ```go switch day { case "Mon", "Tue", "Wed", "Thu", "Fri": fmt.Println("Weekday") case "Sat", "Sun": fmt.Println("Weekend") default: fmt.Println("Invalid") } // switch แบบไม่มี expression (ใช้แทน if-else if chain) switch { case score >= 80: grade = "A" case score >= 70: grade = "B" default: grade = "F" } // type switch (จะใช้ตอนพูดเรื่อง interface) switch v := i.(type) { case int: fmt.Println("int:", v) case string: fmt.Println("string:", v) } ``` ### defer `defer` เลื่อนการรันคำสั่งไปจนกว่าฟังก์ชันรอบนอกจะ return — ใช้ปิด resource เป็นหลัก ```go func readFile(path string) error { f, err := os.Open(path) if err != nil { return err } defer f.Close() // จะถูกเรียกเมื่อ return ไม่ว่าจะ panic หรือ return ปกติ // ... ใช้ f ... return nil } ``` defer ทำงานแบบ LIFO (stack) ถ้ามีหลาย defer ```go defer fmt.Println("1") defer fmt.Println("2") defer fmt.Println("3") // output: 3, 2, 1 ``` --- ## 6. Functions ### พื้นฐาน ```go func add(a int, b int) int { return a + b } // ถ้า type เหมือนกันยุบรวมได้ func add(a, b int) int { return a + b } ``` ### Multiple return values นี่คือลายเซ็นของ Go — return error ออกมาเป็น value แยกแทนการ throw exception ```go func divide(a, b float64) (float64, error) { if b == 0 { return 0, errors.New("division by zero") } return a / b, nil } result, err := divide(10, 2) if err != nil { log.Fatal(err) } fmt.Println(result) ``` ### Named return values ```go func split(sum int) (x, y int) { x = sum * 4 / 9 y = sum - x return // naked return — return ค่าที่ตั้งชื่อไว้อัตโนมัติ } ``` > **คำแนะนำ:** ใช้ named return ในฟังก์ชันสั้นๆ เท่านั้น ในฟังก์ชันยาวจะอ่านยากและเป็นที่มาของ bug ### Variadic functions ```go func sum(nums ...int) int { total := 0 for _, n := range nums { total += n } return total } sum(1, 2, 3) sum([]int{1, 2, 3}...) // unpack slice ``` ### Functions เป็น first-class citizen ```go // ส่งฟังก์ชันเป็น argument func apply(nums []int, fn func(int) int) []int { result := make([]int, len(nums)) for i, n := range nums { result[i] = fn(n) } return result } doubled := apply([]int{1, 2, 3}, func(n int) int { return n * 2 }) ``` ### Closures ```go func counter() func() int { count := 0 return func() int { count++ return count } } c := counter() fmt.Println(c()) // 1 fmt.Println(c()) // 2 ``` --- ## 7. Pointers Go มี pointer แต่ไม่มี pointer arithmetic เหมือน C ```go x := 10 p := &x // p เป็น pointer ชี้ไปที่ x fmt.Println(*p) // dereference: 10 *p = 20 fmt.Println(x) // 20 ``` ### เมื่อไหร่ที่ต้องใช้ pointer 1. **ต้องการแก้ไขค่าใน function** — Go ส่งค่าแบบ pass-by-value เสมอ 2. **struct ขนาดใหญ่** — ส่ง pointer เพื่อหลีกเลี่ยงการ copy ทั้ง struct 3. **บอกว่าค่า "ไม่มี" (nil)** — type ปกติไม่มี nil ```go func updateAge(u *User) { u.Age++ } user := User{Name: "A", Age: 30} updateAge(&user) fmt.Println(user.Age) // 31 ``` > **คำแนะนำ:** สำหรับ struct ที่ใหญ่กว่า ~64 byte ให้ส่งเป็น pointer การ benchmark จริงควรทำเสมอเพราะ pointer ทำให้เกิด heap allocation ซึ่งกระทบ GC --- ## 8. Arrays, Slices และ Maps ### Array — ขนาดคงที่ ```go var arr [5]int arr[0] = 10 nums := [3]int{1, 2, 3} auto := [...]int{1, 2, 3, 4, 5} // compiler นับให้ ``` ในโค้ดจริงเราแทบไม่ได้ใช้ array ตรงๆ — ใช้ slice เป็นหลัก ### Slice — เป็นสิ่งที่คุณจะใช้ทุกวัน Slice คือ "view" ของ array ซ่อนรายละเอียดไว้ ประกอบด้วย 3 ส่วน: - **pointer** ชี้ไปที่ array จริง - **length** จำนวน element ปัจจุบัน - **capacity** ขนาดสูงสุดที่ขยายได้โดยไม่ต้อง allocate ใหม่ ```go // สร้าง slice s := []int{1, 2, 3} s = append(s, 4) // [1 2 3 4] // make — สร้างพร้อมกำหนด length และ capacity buf := make([]byte, 0, 1024) // length=0, capacity=1024 // slicing nums := []int{0, 1, 2, 3, 4, 5} sub := nums[1:4] // [1 2 3] fmt.Println(len(sub), cap(sub)) // 3 5 ``` ### กับดักของ slice ที่นักเขียน Go ใหม่มักโดน ```go // 1. slice ใช้ underlying array ร่วมกัน a := []int{1, 2, 3, 4, 5} b := a[1:3] b[0] = 99 fmt.Println(a) // [1 99 3 4 5] — a ก็เปลี่ยนด้วย! // แก้ด้วย copy ถ้าต้องการ slice อิสระ c := make([]int, len(b)) copy(c, b) ``` ```go // 2. append อาจ realloc หรือไม่ก็ได้ขึ้นกับ capacity s := make([]int, 0, 4) s = append(s, 1, 2, 3) // ยังใช้ array เดิม s = append(s, 4, 5) // เกิน cap แล้ว — Go alloc array ใหม่ ``` ### Map ```go // สร้าง m := map[string]int{ "apple": 10, "banana": 20, } // หรือใช้ make m := make(map[string]int) m["apple"] = 10 // อ่าน — comma-ok idiom เช็คการมีอยู่ if v, ok := m["apple"]; ok { fmt.Println(v) } // ลบ delete(m, "apple") // วน for k, v := range m { fmt.Println(k, v) } ``` > **สำคัญ:** map ใน Go ไม่ thread-safe — ถ้าจะเขียนพร้อมกันจากหลาย goroutine ต้องใช้ `sync.Mutex` หรือ `sync.Map` --- ## 9. Structs และ Methods ```go type User struct { ID int64 `json:"id"` Name string `json:"name"` Email string `json:"email"` CreatedAt time.Time `json:"created_at"` } // สร้าง u := User{ ID: 1, Name: "Ratanon", Email: "r@example.com", } // pointer u2 := &User{Name: "B"} ``` ### Struct Tags ส่วนที่อยู่ใน backtick (`` `json:"id"` ``) คือ struct tag — metadata ที่ library อย่าง `encoding/json`, `gorm`, `validator` อ่านไปใช้ ### Methods Go ไม่มี class — ใช้ method ผูกกับ struct แทน ```go // value receiver — ทำงานบน copy func (u User) FullName() string { return u.Name } // pointer receiver — แก้ไข struct จริงได้ func (u *User) Rename(newName string) { u.Name = newName } u := &User{Name: "A"} u.Rename("B") fmt.Println(u.Name) // B ``` ### กฎ pointer vs value receiver - ถ้า method ต้อง **แก้ไข** state → ใช้ pointer receiver - ถ้า struct ใหญ่ (มี field เยอะ) → ใช้ pointer receiver เพื่อหลีกเลี่ยง copy - **ใน type เดียวกันให้สอดคล้อง** — ถ้า method นึงเป็น pointer ก็ให้ทุก method เป็น pointer หมด อย่าผสม ### Embedding (Composition แทน Inheritance) Go ไม่มี inheritance ใช้ embedding แทน ```go type Animal struct { Name string } func (a Animal) Greet() string { return "Hello, I'm " + a.Name } type Dog struct { Animal // embed Breed string } d := Dog{ Animal: Animal{Name: "Rex"}, Breed: "Labrador", } fmt.Println(d.Greet()) // เรียกได้เหมือน method ของ Dog เอง fmt.Println(d.Name) // promoted field ``` --- ## 10. Interfaces Interface ใน Go ต่างจากภาษาอื่นตรง **implement แบบ implicit** — ไม่ต้องประกาศว่า "type นี้ implement interface ตัวนี้" แค่ method ครบก็ถือว่า implement แล้ว ```go type Shape interface { Area() float64 } type Circle struct { Radius float64 } // Circle implement Shape โดยอัตโนมัติเพราะมี method Area() func (c Circle) Area() float64 { return math.Pi * c.Radius * c.Radius } type Square struct { Side float64 } func (s Square) Area() float64 { return s.Side * s.Side } func describe(s Shape) { fmt.Printf("Area = %.2f\n", s.Area()) } describe(Circle{Radius: 5}) describe(Square{Side: 3}) ``` ### Empty interface (Go < 1.18) / `any` (Go ≥ 1.18) `interface{}` หรือ `any` รับค่าได้ทุกชนิด — แต่หลีกเลี่ยงเมื่อทำได้ ใช้ generics แทน ```go func print(v any) { fmt.Println(v) } ``` ### Type Assertion และ Type Switch ```go var i any = "hello" s := i.(string) // panic ถ้าไม่ใช่ string s, ok := i.(string) // safe — ok=false ถ้าไม่ใช่ switch v := i.(type) { case string: fmt.Println("string:", v) case int: fmt.Println("int:", v) default: fmt.Println("unknown") } ``` ### หลักการออกแบบ Interface ใน Go > "**The bigger the interface, the weaker the abstraction.**" — Rob Pike ใน Go ชอบ interface เล็กๆ มี method 1-3 method เป็นมาตรฐาน ```go // std library — interface ที่ดีคือเล็กและประกอบกันได้ type Reader interface { Read(p []byte) (n int, err error) } type Writer interface { Write(p []byte) (n int, err error) } type ReadWriter interface { Reader Writer } ``` ### "Accept interfaces, return structs" หลักการที่ Go community ยึดถือ: ```go // ดี — รับ interface ทำให้ test ง่าย func ProcessFile(r io.Reader) error { ... } // ดี — return struct ทำให้ caller รู้ exact type func NewClient(cfg Config) *Client { ... } ``` --- ## 11. Error Handling Go ไม่มี try/catch — error คือ value ที่ต้องตรวจสอบทุกครั้ง ```go type error interface { Error() string } ``` ### สร้าง error ```go import "errors" err := errors.New("something went wrong") err := fmt.Errorf("user %d not found", id) ``` ### Pattern พื้นฐาน ```go func loadUser(id int64) (*User, error) { user, err := db.Query(...) if err != nil { return nil, fmt.Errorf("loadUser: %w", err) // %w = wrap error } return user, nil } ``` `%w` คือ verb สำคัญที่ทำให้ error wrapping ทำงาน — เก็บ error เดิมไว้ตรวจสอบทีหลังได้ ### ตรวจสอบ error แบบมีประเภท ```go // Sentinel error var ErrNotFound = errors.New("not found") func findUser(id int) error { if id == 0 { return ErrNotFound } return nil } // caller ตรวจด้วย errors.Is if errors.Is(err, ErrNotFound) { // handle } ``` ```go // Custom error type type ValidationError struct { Field string Message string } func (e *ValidationError) Error() string { return fmt.Sprintf("%s: %s", e.Field, e.Message) } // ตรวจด้วย errors.As var vErr *ValidationError if errors.As(err, &vErr) { fmt.Println(vErr.Field) } ``` ### Panic และ Recover `panic` ใช้สำหรับสถานการณ์ที่กู้คืนไม่ได้เท่านั้น (programmer error, nil dereference) อย่าใช้แทน error ปกติ ```go func safeDivide(a, b int) (result int, err error) { defer func() { if r := recover(); r != nil { err = fmt.Errorf("recovered: %v", r) } }() return a / b, nil } ``` > **กฎทอง:** ถ้าเขียน library อย่า panic — return error ให้ caller ตัดสินใจ --- ## 12. Packages และ Modules ### Go Modules ระบบจัดการ dependency ของ Go ตั้งแต่ 1.11 ```bash go mod init github.com/yourname/project go get github.com/gofiber/fiber/v2 go get github.com/gofiber/fiber/v2@v2.52.0 # version เฉพาะ go mod tidy # ลบที่ไม่ใช้ + เพิ่มที่ขาด go mod vendor # copy dependency มาเก็บใน vendor/ ``` ### โครงสร้าง package ```go // File: internal/user/user.go package user type User struct { ID int64 Name string } func New(name string) *User { return &User{Name: name} } ``` ```go // File: cmd/server/main.go package main import ( "fmt" "github.com/yourname/project/internal/user" ) func main() { u := user.New("Ratanon") fmt.Println(u.Name) } ``` ### init() function ทุก package เรียก `init()` อัตโนมัติก่อน `main()` — ใช้ระวังเพราะทำให้ test และ debug ยาก ปัจจุบันมักใช้ explicit constructor แทน ```go func init() { log.SetFlags(log.LstdFlags | log.Lshortfile) } ``` --- ## 13. Goroutines และ Channels (Concurrency) นี่คือเหตุผลหลักที่หลายคนเลือก Go ### Goroutine Goroutine คือ lightweight thread ที่ Go runtime จัดการเอง — สร้างได้เป็นแสนตัวบนเครื่องเดียว เพราะ stack เริ่มที่ 2KB (ไม่ใช่ 1-2MB เหมือน OS thread) ```go func sayHello(name string) { time.Sleep(1 * time.Second) fmt.Println("Hello", name) } func main() { go sayHello("A") go sayHello("B") go sayHello("C") time.Sleep(2 * time.Second) // รอให้ goroutine ทำงาน } ``` > **ปัญหา:** ถ้า main return ก่อน goroutine ทำงานเสร็จ — goroutine ตายทิ้ง การใช้ `time.Sleep` ผิด ใช้ `sync.WaitGroup` แทน ### sync.WaitGroup ```go var wg sync.WaitGroup for i := 0; i < 3; i++ { wg.Add(1) go func(id int) { defer wg.Done() fmt.Println("worker", id) }(i) // ส่ง i เข้าไปทุกครั้ง — ระวัง closure capture } wg.Wait() ``` ### Channels — สื่อสารระหว่าง goroutine ```go ch := make(chan int) // unbuffered ch := make(chan int, 10) // buffered, capacity 10 // ส่ง ch <- 42 // รับ v := <-ch // รับพร้อมเช็ค channel ปิดหรือยัง v, ok := <-ch if !ok { // channel closed } // ปิด channel — ผู้ส่งเป็นคนปิด ห้ามปิดซ้ำ close(ch) ``` ### Pattern พื้นฐาน — Worker Pool ```go func worker(id int, jobs <-chan int, results chan<- int) { for j := range jobs { fmt.Printf("worker %d processing job %d\n", id, j) time.Sleep(time.Second) results <- j * 2 } } func main() { jobs := make(chan int, 100) results := make(chan int, 100) // start 3 workers for w := 1; w <= 3; w++ { go worker(w, jobs, results) } // send 9 jobs for j := 1; j <= 9; j++ { jobs <- j } close(jobs) // collect results for a := 1; a <= 9; a++ { <-results } } ``` > สังเกตว่า `<-chan int` คือ "channel ที่อ่านได้อย่างเดียว", `chan<- int` คือ "channel ที่ส่งได้อย่างเดียว" — ใช้ในพารามิเตอร์เพื่อบังคับทิศทาง ### Select ```go select { case msg := <-ch1: fmt.Println("from ch1:", msg) case msg := <-ch2: fmt.Println("from ch2:", msg) case <-time.After(2 * time.Second): fmt.Println("timeout") default: fmt.Println("no channel ready") } ``` `select` คือ `switch` สำหรับ channel — รอ channel หลายตัวพร้อมกัน ### Mutex — ป้องกัน race condition ```go type SafeCounter struct { mu sync.Mutex v map[string]int } func (c *SafeCounter) Inc(key string) { c.mu.Lock() defer c.mu.Unlock() c.v[key]++ } ``` ถ้าเป็น read-heavy ใช้ `sync.RWMutex` (อ่านพร้อมกันได้ เขียนล็อกหมด) ### ตรวจ race condition ```bash go run -race main.go go test -race ./... ``` `-race` เปิด race detector ของ Go — เครื่องมือที่จำเป็นต้องใช้ในการ test concurrent code --- ## 14. Context `context.Context` คือกลไกส่ง deadline, cancellation signal และ request-scoped values ผ่านเข้าหลาย layer ของโปรแกรม — มาตรฐานของทุก API call ใน Go production ```go import "context" func fetchData(ctx context.Context) error { select { case <-time.After(3 * time.Second): return nil case <-ctx.Done(): return ctx.Err() // context.Canceled หรือ context.DeadlineExceeded } } func main() { ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) defer cancel() if err := fetchData(ctx); err != nil { fmt.Println("error:", err) } } ``` ### Context types ```go context.Background() // root context context.TODO() // ยังไม่รู้ว่าจะใช้อะไร context.WithCancel(parent) // ยกเลิกด้วยมือ context.WithTimeout(parent, time.Second) // timeout context.WithDeadline(parent, t) // deadline เฉพาะ context.WithValue(parent, key, value) // ส่งค่า (ใช้น้อยที่สุด) ``` ### กฎการใช้ context 1. **ส่ง context เป็น argument แรกของฟังก์ชันเสมอ** ตามชื่อ `ctx` 2. **อย่าเก็บ context ใน struct** — ส่งผ่าน argument 3. **ห้ามส่ง nil** — ใช้ `context.Background()` หรือ `context.TODO()` แทน 4. **`context.WithValue` ใช้สำหรับ request-scoped data เท่านั้น** เช่น user ID, trace ID — ไม่ใช่ส่ง argument ปกติ --- ## 15. Generics Go 1.18 (มีนาคม 2022) เพิ่ม generics เข้ามาเป็นฟีเจอร์ที่รอกันมานาน ```go // generic function func Map[T, U any](s []T, f func(T) U) []U { result := make([]U, len(s)) for i, v := range s { result[i] = f(v) } return result } doubled := Map([]int{1, 2, 3}, func(n int) int { return n * 2 }) // [2 4 6] ``` ### Type Constraints ```go import "golang.org/x/exp/constraints" func Sum[T constraints.Ordered](nums []T) T { var sum T for _, n := range nums { sum += n } return sum } // custom constraint type Number interface { int | int64 | float64 } func Max[T Number](a, b T) T { if a > b { return a } return b } ``` ### Generic struct ```go type Stack[T any] struct { items []T } func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) } func (s *Stack[T]) Pop() (T, bool) { var zero T if len(s.items) == 0 { return zero, false } n := len(s.items) - 1 v := s.items[n] s.items = s.items[:n] return v, true } ``` > **คำแนะนำ:** อย่าใช้ generics ในทุกที่ — ใช้เฉพาะเมื่อจำเป็น code ที่ใช้ generics อ่านยากและ debug ยากกว่า --- ## 16. Testing Go มี testing framework ในตัว ไม่ต้องลง dependency ### Unit test ```go // File: math.go package math func Add(a, b int) int { return a + b } ``` ```go // File: math_test.go package math import "testing" func TestAdd(t *testing.T) { got := Add(2, 3) want := 5 if got != want { t.Errorf("Add(2,3) = %d, want %d", got, want) } } ``` รัน: ```bash go test ./... go test -v ./... # verbose go test -run TestAdd # รันเฉพาะที่ match go test -cover ./... # coverage go test -coverprofile=c.out go tool cover -html=c.out # ดู HTML report ``` ### Table-driven tests (Go idiom) ```go func TestAdd(t *testing.T) { tests := []struct { name string a, b int want int }{ {"positive", 2, 3, 5}, {"negative", -1, -1, -2}, {"zero", 0, 0, 0}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if got := Add(tt.a, tt.b); got != tt.want { t.Errorf("Add(%d,%d) = %d, want %d", tt.a, tt.b, got, tt.want) } }) } } ``` ### Benchmark ```go func BenchmarkAdd(b *testing.B) { for i := 0; i < b.N; i++ { Add(2, 3) } } ``` ```bash go test -bench=. -benchmem # BenchmarkAdd-8 1000000000 0.3 ns/op 0 B/op 0 allocs/op ``` ### Mocking แทนที่จะใช้ mock library หนักๆ Go community นิยม define interface แล้ว implement struct เองใน test ```go type UserRepo interface { GetByID(ctx context.Context, id int64) (*User, error) } type UserService struct { repo UserRepo } // ใน test type mockRepo struct{} func (m *mockRepo) GetByID(ctx context.Context, id int64) (*User, error) { return &User{ID: id, Name: "test"}, nil } func TestService(t *testing.T) { s := UserService{repo: &mockRepo{}} // ... } ``` ถ้าต้องการ tool สร้าง mock อัตโนมัติ ใช้ [mockery](https://github.com/vektra/mockery) หรือ [gomock](https://github.com/uber-go/mock) --- ## 17. Performance, Profiling และ Benchmark ### pprof — เครื่องมือหลักของ Go ในการหา bottleneck ```go import _ "net/http/pprof" func main() { go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }() // ... โปรแกรมหลัก ... } ``` จากนั้น: ```bash # CPU profile 30 วินาที go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30 # Memory go tool pprof http://localhost:6060/debug/pprof/heap # Goroutine go tool pprof http://localhost:6060/debug/pprof/goroutine ``` ใน pprof CLI: ``` (pprof) top10 (pprof) list FunctionName (pprof) web # เปิด graph ใน browser ``` ### หลักการเพิ่ม performance ใน Go (เรียงตามผลกระทบ) 1. **ลด allocation** — heap allocation = GC pressure - ใช้ `sync.Pool` สำหรับ object ที่ใช้ซ้ำๆ - pre-allocate slice ด้วย `make([]T, 0, expected)` เมื่อรู้ขนาด 2. **หลีกเลี่ยง interface ที่ไม่จำเป็น** — interface call แพงกว่า direct call 3. **ใช้ buffered channel** ลด context switch 4. **อ่านไฟล์เป็น chunk** ไม่ใช่ทีละ byte — ใช้ `bufio.Scanner`/`bufio.Reader` 5. **ใช้ `strings.Builder`** ในการสร้าง string ขนาดใหญ่ ไม่ใช่ `+=` ```go // ช้า — ทุก += alloc string ใหม่ s := "" for i := 0; i < 10000; i++ { s += "x" } // เร็วกว่า ~1000 เท่า var sb strings.Builder sb.Grow(10000) for i := 0; i < 10000; i++ { sb.WriteString("x") } s := sb.String() ``` ### Escape Analysis ใช้ดูว่าตัวแปรไหนถูก allocate บน heap (ช้า) vs stack (เร็ว) ```bash go build -gcflags="-m" ./... ``` --- ## 18. Patterns ที่ใช้ใน Production ### Functional Options Pattern แทน constructor ที่มี argument เป็นสิบๆ ตัว ```go type Server struct { host string port int timeout time.Duration tls bool } type Option func(*Server) func WithPort(port int) Option { return func(s *Server) { s.port = port } } func WithTimeout(t time.Duration) Option { return func(s *Server) { s.timeout = t } } func WithTLS() Option { return func(s *Server) { s.tls = true } } func NewServer(host string, opts ...Option) *Server { s := &Server{ host: host, port: 8080, timeout: 30 * time.Second, } for _, opt := range opts { opt(s) } return s } // ใช้ s := NewServer("localhost", WithPort(9090), WithTLS(), ) ``` ### Repository Pattern ```go type UserRepository interface { Create(ctx context.Context, u *User) error GetByID(ctx context.Context, id int64) (*User, error) Update(ctx context.Context, u *User) error Delete(ctx context.Context, id int64) error } type postgresUserRepo struct { db *sql.DB } func NewUserRepository(db *sql.DB) UserRepository { return &postgresUserRepo{db: db} } ``` ### Service Layer ```go type UserService struct { repo UserRepository logger Logger } func (s *UserService) Register(ctx context.Context, email, password string) (*User, error) { if !isValidEmail(email) { return nil, ErrInvalidEmail } hashed, err := hashPassword(password) if err != nil { return nil, fmt.Errorf("hash password: %w", err) } u := &User{Email: email, Password: hashed} if err := s.repo.Create(ctx, u); err != nil { return nil, fmt.Errorf("create user: %w", err) } s.logger.Info("user registered", "id", u.ID) return u, nil } ``` ### Graceful Shutdown ```go func main() { srv := &http.Server{Addr: ":8080", Handler: router} go func() { if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed { log.Fatal(err) } }() quit := make(chan os.Signal, 1) signal.Notify(quit, os.Interrupt, syscall.SIGTERM) <-quit log.Println("shutting down...") ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) defer cancel() if err := srv.Shutdown(ctx); err != nil { log.Fatal("forced shutdown:", err) } log.Println("server stopped") } ``` --- ## 19. การสร้าง REST API ด้วย Fiber [Fiber](https://gofiber.io/) เป็น web framework ที่ inspired จาก Express.js ใช้ FastHTTP ทำให้เร็วกว่า net/http มาตรฐาน ```bash go get github.com/gofiber/fiber/v2 ``` ### โครงสร้างพื้นฐาน ```go package main import ( "github.com/gofiber/fiber/v2" "github.com/gofiber/fiber/v2/middleware/logger" "github.com/gofiber/fiber/v2/middleware/recover" ) func main() { app := fiber.New(fiber.Config{ AppName: "MyAPI v1", ReadTimeout: 10 * time.Second, }) app.Use(logger.New()) app.Use(recover.New()) app.Get("/health", func(c *fiber.Ctx) error { return c.JSON(fiber.Map{"status": "ok"}) }) api := app.Group("/api/v1") api.Get("/users/:id", getUser) api.Post("/users", createUser) log.Fatal(app.Listen(":3000")) } func getUser(c *fiber.Ctx) error { id, err := c.ParamsInt("id") if err != nil { return fiber.NewError(fiber.StatusBadRequest, "invalid id") } user, err := userService.GetByID(c.Context(), int64(id)) if err != nil { if errors.Is(err, ErrNotFound) { return fiber.NewError(fiber.StatusNotFound, "user not found") } return err } return c.JSON(user) } func createUser(c *fiber.Ctx) error { var req CreateUserRequest if err := c.BodyParser(&req); err != nil { return fiber.NewError(fiber.StatusBadRequest, err.Error()) } if err := req.Validate(); err != nil { return fiber.NewError(fiber.StatusBadRequest, err.Error()) } user, err := userService.Create(c.Context(), &req) if err != nil { return err } return c.Status(fiber.StatusCreated).JSON(user) } ``` ### Validation ```go import "github.com/go-playground/validator/v10" type CreateUserRequest struct { Email string `json:"email" validate:"required,email"` Password string `json:"password" validate:"required,min=8"` Age int `json:"age" validate:"gte=18,lte=120"` } var validate = validator.New() func (r *CreateUserRequest) Validate() error { return validate.Struct(r) } ``` ### Custom Error Handler ```go app := fiber.New(fiber.Config{ ErrorHandler: func(c *fiber.Ctx, err error) error { code := fiber.StatusInternalServerError var fe *fiber.Error if errors.As(err, &fe) { code = fe.Code } return c.Status(code).JSON(fiber.Map{ "error": err.Error(), "code": code, }) }, }) ``` ### JWT Middleware ```go import jwtware "github.com/gofiber/contrib/jwt" app.Use(jwtware.New(jwtware.Config{ SigningKey: jwtware.SigningKey{Key: []byte("secret")}, })) app.Get("/me", func(c *fiber.Ctx) error { user := c.Locals("user").(*jwt.Token) claims := user.Claims.(jwt.MapClaims) return c.JSON(claims) }) ``` --- ## 20. Database, Migration, Repository Pattern ### database/sql + pgx (PostgreSQL) ```go import ( "context" "database/sql" _ "github.com/jackc/pgx/v5/stdlib" ) func NewDB(dsn string) (*sql.DB, error) { db, err := sql.Open("pgx", dsn) if err != nil { return nil, err } db.SetMaxOpenConns(25) db.SetMaxIdleConns(25) db.SetConnMaxLifetime(5 * time.Minute) ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() if err := db.PingContext(ctx); err != nil { return nil, err } return db, nil } ``` ### Repository implementation ```go type postgresUserRepo struct { db *sql.DB } func (r *postgresUserRepo) GetByID(ctx context.Context, id int64) (*User, error) { const query = ` SELECT id, email, name, created_at FROM users WHERE id = $1` var u User err := r.db.QueryRowContext(ctx, query, id).Scan( &u.ID, &u.Email, &u.Name, &u.CreatedAt, ) if err == sql.ErrNoRows { return nil, ErrNotFound } if err != nil { return nil, fmt.Errorf("query user: %w", err) } return &u, nil } func (r *postgresUserRepo) Create(ctx context.Context, u *User) error { const query = ` INSERT INTO users (email, name) VALUES ($1, $2) RETURNING id, created_at` return r.db.QueryRowContext(ctx, query, u.Email, u.Name).Scan( &u.ID, &u.CreatedAt, ) } ``` ### Transaction ```go func (s *Service) TransferMoney(ctx context.Context, from, to int64, amount int64) error { tx, err := s.db.BeginTx(ctx, nil) if err != nil { return err } defer tx.Rollback() // ถ้า commit สำเร็จ Rollback จะไม่ทำอะไร if _, err := tx.ExecContext(ctx, "UPDATE accounts SET balance = balance - $1 WHERE id = $2", amount, from); err != nil { return err } if _, err := tx.ExecContext(ctx, "UPDATE accounts SET balance = balance + $1 WHERE id = $2", amount, to); err != nil { return err } return tx.Commit() } ``` ### Migration ด้วย golang-migrate ```bash go install -tags 'postgres' github.com/golang-migrate/migrate/v4/cmd/migrate@latest migrate create -ext sql -dir migrations -seq create_users migrate -path migrations -database "postgres://..." up migrate -path migrations -database "postgres://..." down 1 ``` ### sqlc — generate type-safe code จาก SQL ถ้าไม่อยากใช้ ORM แต่ก็ไม่อยากเขียน scan code เอง — [sqlc](https://sqlc.dev) เป็นทางออก ```sql -- queries.sql -- name: GetUser :one SELECT * FROM users WHERE id = $1; -- name: ListUsers :many SELECT * FROM users ORDER BY created_at DESC LIMIT $1; ``` ```bash sqlc generate ``` จะได้ Go code ที่ type-safe พร้อมใช้ --- ## 21. Observability ### Structured Logging — slog (Go 1.21+) ```go import "log/slog" logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ Level: slog.LevelInfo, })) logger.Info("user registered", "user_id", 123, "email", "a@example.com", "ip", "1.2.3.4", ) // {"time":"2026-05-03T...","level":"INFO","msg":"user registered","user_id":123,...} ``` ### Metrics — Prometheus ```go import "github.com/prometheus/client_golang/prometheus/promhttp" var ( requestsTotal = prometheus.NewCounterVec( prometheus.CounterOpts{ Name: "http_requests_total", Help: "Total HTTP requests", }, []string{"method", "path", "status"}, ) requestDuration = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Name: "http_request_duration_seconds", Buckets: prometheus.DefBuckets, }, []string{"method", "path"}, ) ) func init() { prometheus.MustRegister(requestsTotal, requestDuration) } // expose metrics endpoint http.Handle("/metrics", promhttp.Handler()) ``` ### Distributed Tracing — OpenTelemetry ```go import ( "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp" "go.opentelemetry.io/otel/sdk/trace" ) func initTracer(ctx context.Context) (*trace.TracerProvider, error) { exporter, err := otlptracehttp.New(ctx) if err != nil { return nil, err } tp := trace.NewTracerProvider( trace.WithBatcher(exporter), trace.WithResource(resource.NewWithAttributes( semconv.SchemaURL, semconv.ServiceName("my-api"), )), ) otel.SetTracerProvider(tp) return tp, nil } // ใน handler tracer := otel.Tracer("my-api") ctx, span := tracer.Start(ctx, "GetUser") defer span.End() span.SetAttributes(attribute.Int64("user.id", id)) ``` --- ## 22. Build, Deploy, Docker ### Build flags ที่ใช้ใน production ```bash # build แบบ optimize + ไม่มี debug symbol CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \ go build -ldflags="-s -w" -o app ./cmd/server # inject version ตอน build go build -ldflags="-X main.Version=$(git describe --tags) -X main.Commit=$(git rev-parse --short HEAD)" \ -o app ./cmd/server ``` - `CGO_ENABLED=0` — static binary เต็มรูปแบบ ไม่ต้องการ libc - `-s -w` — ตัด symbol table และ DWARF ลด binary size 30-40% ### Multi-stage Dockerfile ```dockerfile # Build stage FROM golang:1.22-alpine AS builder WORKDIR /app # Cache dependencies COPY go.mod go.sum ./ RUN go mod download COPY . . RUN CGO_ENABLED=0 GOOS=linux \ go build -ldflags="-s -w" -o /app/server ./cmd/server # Runtime stage FROM alpine:3.19 RUN apk --no-cache add ca-certificates tzdata && \ adduser -D -u 1000 appuser WORKDIR /app COPY --from=builder /app/server . USER appuser EXPOSE 8080 HEALTHCHECK --interval=30s --timeout=3s \ CMD wget --quiet --tries=1 --spider http://localhost:8080/health || exit 1 ENTRYPOINT ["./server"] ``` ### Distroless image (เล็กกว่า + ปลอดภัยกว่า) ```dockerfile FROM golang:1.22 AS builder # ... build steps ... FROM gcr.io/distroless/static-debian12:nonroot COPY --from=builder /app/server / USER nonroot:nonroot ENTRYPOINT ["/server"] ``` ผลคือ image ขนาด ~10-20MB มี attack surface น้อยมาก ### Cross-compile ```bash # Linux ARM64 (Apple Silicon, AWS Graviton) GOOS=linux GOARCH=arm64 go build -o app-linux-arm64 ./cmd/server # Windows GOOS=windows GOARCH=amd64 go build -o app.exe ./cmd/server # Mac GOOS=darwin GOARCH=arm64 go build -o app-mac ./cmd/server ``` ความเจ๋งของ Go คือ build cross-platform ได้จากเครื่องไหนก็ได้ ไม่ต้องการ toolchain เพิ่ม --- ## 23. สรุปและเส้นทางต่อไป ### Checklist ของ Go developer มืออาชีพ - [ ] เข้าใจ pointer vs value receiver และเลือกใช้ได้ถูก - [ ] เขียน goroutine + channel โดยไม่มี race condition (ใช้ `-race` ทดสอบเป็นนิสัย) - [ ] รู้ว่าเมื่อไหร่ควรใช้ `context.Context` - [ ] error handling ด้วย `%w` wrapping และ `errors.Is`/`errors.As` - [ ] เขียน table-driven test ได้คล่อง - [ ] อ่าน pprof profile เป็น - [ ] รู้จัก `sync.Pool`, `sync.Once`, `sync.WaitGroup` - [ ] ออกแบบ interface เล็กๆ ตามหลัก "accept interfaces, return structs" - [ ] graceful shutdown - [ ] structured logging - [ ] zero-downtime deployment ### หนังสือและแหล่งเรียนรู้แนะนำ - **The Go Programming Language** — Donovan & Kernighan (หนังสือคลาสสิก) - **100 Go Mistakes and How to Avoid Them** — Teiva Harsanyi (เรียนจาก antipattern) - **Effective Go** — https://go.dev/doc/effective_go (อ่านฟรี เป็น must-read) - **Go Code Review Comments** — https://go.dev/wiki/CodeReviewComments - **Dave Cheney's blog** — https://dave.cheney.net/ ### Library ที่ใช้บ่อยใน production | Use case | Library | |---|---| | Web framework | Fiber, Echo, Gin, Chi | | HTTP client (มากกว่า net/http) | resty | | ORM / Query builder | sqlc, sqlx, ent, GORM (ระวัง — abstract เยอะ) | | Validation | go-playground/validator | | JWT | golang-jwt/jwt | | Logging | slog (stdlib), zap, zerolog | | Config | viper, envconfig | | Migration | golang-migrate, goose | | CLI | cobra, urfave/cli | | Mock | mockery, gomock | | Test assertion | testify (แต่ stdlib ก็พอ) | | Message queue | rabbitmq/amqp091, segmentio/kafka-go | | gRPC | google.golang.org/grpc | ### หัวข้อขั้นสูงที่ควรไปต่อ 1. **gRPC + Protobuf** — สำหรับ microservice-to-microservice 2. **Event-driven architecture** — Kafka, NATS, RabbitMQ 3. **Domain-Driven Design (DDD) ใน Go** — clean architecture, hexagonal 4. **Reflection** (`reflect` package) — ใช้สร้าง framework แต่ใช้ระวัง 5. **CGO** — interop กับ C code 6. **Plugins** (`plugin` package) — dynamic loading 7. **Assembly tuning** — สำหรับ hot path ที่ต้องการ performance สูงสุด --- ## ปิดท้าย Go ไม่ใช่ภาษาที่จะทำให้คุณเขียนโค้ดสั้นที่สุด หรือ expressive ที่สุด — แต่เป็นภาษาที่ทำให้ทีมขนาดใหญ่เขียนโค้ดที่ readable, maintainable และ deploy ได้จริงในระดับ scale ปรัชญาของ Go คือ "**less is exponentially more**" — มี keyword น้อย, ออกแบบให้มีวิธี "ทำสิ่งหนึ่งให้ดี" เพียงทางเดียว เมื่อคุณเขียน Go ไประยะหนึ่ง คุณจะรู้สึกว่าโค้ดของคุณดูคล้ายโค้ดของคนอื่น — นั่นคือเรื่องดี เพราะ team สามารถ maintain โค้ดของกันได้โดยไม่ต้องเรียนสไตล์ใหม่ทุกคน > "Don't communicate by sharing memory; share memory by communicating." — Go Proverbs Happy coding! 🐹

SECURE_ACCESS

Go (Golang) — คู่มือฉบับสมบูรณ์

CONFIRM_DELETE