go version

cat go.mod

module hello

go 1.25

go get go@1.27

go get github.com/fatih/color

import "github.com/fatih/color"
color.Red("แดง!")

go mod tidy  # เก็บกวาด: ของใหม่ 1.27 จะรวม require ให้เหลือแค่ 2 กลุ่ม direct/indirect สวยๆ

myapp/
  go.mod
  main.go          # ทางเข้า
  handler/         # รับ request
    user.go
  store/           # คุยกับข้อมูล
    user.go

go fmt ./...  # แม่บ้าน: จัดหน้าให้สวย
go vet ./...  # หมอ: ตรวจว่าสั่งอะไรแปลกๆ ไหม
go fix ./...  # ครู: (ของใหม่ Go 1.26 เก่งมาก) แก้โค้ดเก่าเป็นแบบใหม่ให้เอง
go test ./... # ครูสอบ: รันเทสต์

go fix ./...

go doc fmt.Println
go doc strings.Builder

go doc example.com/pkg@v1.2.3

s := make([]int, 2, 5) // len=2 cap=5
fmt.Println(len(s), cap(s)) // 2 5

a := []int{1, 2, 3}
b := a // b ชี้บ้านหลังเดียวกัน!
b[0] = 99
fmt.Println(a) // [99 2 3] a โดนด้วย!

c := append([]int{}, a...) // บ้านใหม่
// หรือ
d := make([]int, len(a))
copy(d, a)

s = append(s, 4) // ต้องมี s = ข้างหน้า เพราะอาจย้ายบ้าน

// ผิด! อย่าเขียน map จากหลาย goroutine ตรงๆ
// m[key] = v  // พร้อมกันหลายตัว = race

// แบบ 1: ใส่กุญแจ (ง่ายสุด)
var mu sync.Mutex
mu.Lock()
m[key] = v
mu.Unlock()

// แบบ 2: ใช้ sync.Map (เหมาะกับอ่านเยอะเขียนน้อย)
var sm sync.Map
sm.Store(key, value)
v, ok := sm.Load(key)

v, ok := m[key]
if !ok {
    // ไม่มี
}

type Logger struct{}
func (Logger) Log(s string) { fmt.Println("log:", s) }

type Job struct {
    Command string
    Logger // ฝังไว้ ไม่ต้องตั้งชื่อ field
}

j := Job{Command: "run"}
j.Log("start") // เรียกของ Logger ได้เลยเหมือนเป็นของตัวเอง

type Habitat struct{ Burrow string }
type Gopher struct {
    Name string
    Habitat
}
g := Gopher{
    Name:   "Gopher",
    Burrow: "Burrow #42", // เมื่อก่อนต้องเขียน Habitat: Habitat{Burrow: ...} ยาวกว่า
}

// เก่า: 2 บรรทัด
x := int64(300)
p1 := &x

// ใหม่: บรรทัดเดียว ความหมายเดียวกัน
p2 := new(int64(300))

func counter() func() int {
    n := 0
    return func() int { // ฟังก์ชันข้างในจำ n ได้แม้ข้างนอกจบไปแล้ว
        n++
        return n
    }
}

c := counter()
fmt.Println(c()) // 1
fmt.Println(c()) // 2

func Sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
Sum(1, 2)      // 3
Sum(1, 2, 3, 4) // 10
s := []int{1, 2, 3}
Sum(s...) // มี ... ท้าย = แกะกล่องโปรยเข้าไป

func work() {
    mu.Lock()
    defer mu.Unlock() // ปลดล็อกแน่ ไม่ว่าจะ return ทางไหน

    f, err := os.Open("a.txt")
    if err != nil { return }
    defer f.Close() // ปิดไฟล์แน่
}

for i := 0; i < 3; i++ {
    defer fmt.Println(i) // เก็บค่า i ตอนนั้นเลย
}
// พิมพ์ 2 1 0 (เข้าหลังออกก่อน)

type Stringer interface {
    String() string
}

func Print(s fmt.Stringer) {
    fmt.Println(s.String())
}

func Min[T int | float64](a, b T) T {
    if a < b { return a }
    return b
}
Min(1, 2)       // int
Min(1.5, 2.5)   // float64

// ตัวอย่างจาก math/rand/v2
func (r *Rand) N[Int intType](n Int) Int
// เมธอดเดียวใช้ได้ทุกชนิด int ไม่ต้องเขียน Int32N Int64N แยกกันแล้ว

func GenericFormatter[T any](v T) string {
    return fmt.Sprintf("value: %v", v)
}
type IntFormatter func(int) string

formatters := []IntFormatter{GenericFormatter} // ไม่ต้อง [int] แล้ว เดาให้
ch := make(chan IntFormatter, 1)
ch <- GenericFormatter // ส่งเข้า channel ได้เลย เดาให้เหมือนกัน

data, err := os.ReadFile("config.json")
if err != nil {
    return fmt.Errorf("อ่าน config: %w", err) // %w = ห่ออันเก่าไว้ข้างใน แกะดูได้
}

if errors.Is(err, os.ErrNotExist) {
    // ไฟล์ไม่มีจริงๆ ไม่ใช่พังแบบอื่น
}
var pathErr *os.PathError
if errors.As(err, &pathErr) {
    fmt.Println("พังที่ path:", pathErr.Path)
}

type AgeError struct{ Age int }
func (e *AgeError) Error() string {
    return fmt.Sprintf("อายุ %d ใช้ไม่ได้", e.Age)
}

unbuf := make(chan int)    // ส่งแล้วต้องมีคนรับทันที (ซิงค์ 100%)
buf := make(chan int, 10)  // วางค้างได้ 10 ชิ้น (กันพ่อครัวรอ)

select {
case v := <-ch:
    fmt.Println(v)
case <-time.After(2 * time.Second):
    fmt.Println("รอ 2 วิแล้ว ไม่มา เลิก!")
}

select {
case v := <-ch:
    fmt.Println(v)
default:
    fmt.Println("ยังไม่มีของ ไปทำอย่างอื่นก่อน")
}

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums { out <- n }
        close(out)
    }()
    return out
}
func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in { out <- n * n }
        close(out)
    }()
    return out
}
// ใช้: for n := range sq(gen(1,2,3,4)) { ... } // 1 4 9 16

go run -race .
go test -race ./...

func work(ctx context.Context) {
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("เสร็จ")
    case <-ctx.Done():
        fmt.Println("โดนยกเลิก:", ctx.Err())
    }
}

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
go work(ctx)

var mu sync.Mutex
mu.Lock()
// แตะของที่ใช้ร่วมกันตรงนี้
mu.Unlock()

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    // ทำงาน
}()
wg.Wait() // รอให้หมด

var once sync.Once
once.Do(func() { /* ทำแค่ครั้งเดียว เช่น init */ })

func TestAdd(t *testing.T) {
    tests := []struct{ a, b, want int }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, tt := range tests {
        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)
        }
    }
}

go test ./...
go test -race ./...  # แถมตรวจแย่งกันด้วย
go test -run TestAdd -v

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}
b, _ := json.Marshal(User{"Ann", 20})
fmt.Println(string(b)) // {"name":"Ann","age":20}

package main

import (
    "context"
    "fmt"
    "math/rand"
    "sync"
    "time"
)

func fetchPrice(ctx context.Context, s string) (int, error) {
    select {
    case <-time.After(time.Duration(rand.Intn(800)) * time.Millisecond):
        return rand.Intn(1000), nil
    case <-ctx.Done():
        return 0, ctx.Err()
    }
}

func main() {
    symbols := []string{"AAPL", "GOOG", "TSLA", "AMZN", "MSFT"}
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()

    var wg sync.WaitGroup
    ch := make(chan string, len(symbols))

    for _, s := range symbols {
        wg.Add(1)
        go func(sym string) {
            defer wg.Done()
            price, err := fetchPrice(ctx, sym)
            if err != nil {
                ch <- fmt.Sprintf("%s: ตก (%v)", sym, err)
                return
            }
            ch <- fmt.Sprintf("%s = %d", sym, price)
        }(s)
    }
    go func() { wg.Wait(); close(ch) }()
    for r := range ch {
        fmt.Println(r)
    }
}