var a [3]int // array: ตู้ปูน 3 ช่อง เปลี่ยนจำนวนไม่ได้ [3]int กับ [5]int คนละชนิด
a[0] = 10

s := []int{1, 2, 3} // slice: กระเป๋าผ้ายืดได้ (ใช้ตัวนี้ 95%)

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[0] = 99
fmt.Println(a) // [99 2 3] โดนด้วย!

s := []int{1, 2, 3}
s = append(s, 4, 5) // ต้องมี s = ข้างหน้า! เพราะอาจย้ายบ้าน
y := []int{6, 7}
s = append(s, y...) // ... = แกะกล่องโปรยเข้าไป

// อยากได้บ้านใหม่จริงๆ
d := make([]int, len(s))
copy(d, s)
// หรือสั้นๆ
c := append([]int{}, s...)

// หั่น
buf := []int{1, 2, 3, 4, 5}
fmt.Println(buf[0:2])  // [1 2]
fmt.Println(buf[2:])   // [3 4 5]
fmt.Println(buf[:3])   // [1 2 3]

import "slices"
c2 := slices.Clone(s)
slices.Sort(c2)
slices.Compact(c2) // ตัดตัวซ้ำติดกัน

// วิธี 1: แยกบ้านทีละแถว (แถวโตได้อิสระ)
pic := make([][]uint8, 3)
for i := range pic { pic[i] = make([]uint8, 4) }

// วิธี 2: บ้านเดียวแล้วหั่น (ประหยัด ถ้าขนาดคงที่)
pic2 := make([][]uint8, 3)
pix := make([]uint8, 3*4)
for i := range pic2 { pic2[i], pix = pix[:4], pix[4:] }

m := map[string]int{"UTC": 0, "EST": -18000}
m["CST"] = -21600
delete(m, "EST") // ลบตัวไม่มีก็ไม่พัง

v := m["xxx"] // ไม่มีได้ 0 (zero value) ต้องแยกด้วย comma-ok
v, ok := m["xxx"]
if !ok { fmt.Println("ไม่มี key นี้") }

var mu sync.Mutex
mu.Lock()
m[k] = v
mu.Unlock()

// อ่านเยอะเขียนน้อยใช้ RWMutex
mu.RLock()
v := m[k]
mu.RUnlock()

// หรือใช้ sync.Map
var sm sync.Map
sm.Store(k, v)
v, ok := sm.Load(k)

type Person struct {
    Name string
    Age  int
}
p := Person{Name: "Ann", Age: 20}

type Logger struct{}
func (Logger) Log(s string) { fmt.Println(s) }
type Job struct {
    Command string
    Logger
}
j := Job{Command: "run"}
j.Log("start")

type Habitat struct{ Burrow string }
type Gopher struct {
    Name string
    Habitat
}
g := Gopher{Name: "Gopher", Burrow: "Burrow #42"} // ไม่ต้องห่อ Habitat{...} แล้ว

a := []int{1, 2, 3}
b := append(a[:2], 9) // b แชร์ array เดียวกับ a!
fmt.Println(a)        // [1 2 9] <- a โดนเปลี่ยนด้วย ไม่รู้ตัว
c := append([]int(nil), a[:2]...) // แบบนี้ปลอดภัย (clone ก่อน)
_ = c

buf := make([]byte, 0, 1024)
chunk := buf[:0:0] // cap=0: append ทีหลังไม่กระทบ buf แน่นอน
_ = chunk

type SafeMap struct {
    mu sync.RWMutex
    m  map[string]int
}

func (s *SafeMap) Get(k string) (int, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    v, ok := s.m[k]
    return v, ok
}