Pointers (ตัวชี้)

TypeScript ไม่มี pointer แบบ explicit

ใน TypeScript (และ JavaScript) object ถูกส่งต่อเป็น reference โดยอัตโนมัติ คุณไม่เคยต้องเขียนว่า “ขอ address ของตัวแปรนี้” เพราะ runtime จัดการ memory ให้เบื้องหลังโดยที่คุณมองไม่เห็น

Go เปิดเผย memory address อย่างชัดเจน คุณเลือกเองว่า function จะรับ copy ของค่าหรือ pointer ไปยังต้นฉบับ การเลือกนั้นมีผลจริงต่อความถูกต้องและประสิทธิภาพ

Operator & และ *

&x ให้ pointer ไปยัง x — address ใน memory ที่ x อาศัยอยู่ *p dereference pointer p — อ่านหรือเขียนค่าที่ address นั้น

// TypeScript — objects are implicitly shared
function increment(obj: { count: number }) {
  obj.count++;          // mutates the original (reference)
}

const counter = { count: 0 };
increment(counter);
console.log(counter.count); // 1

// BUT primitives are always copied:
function addOne(n: number): number {
  return n + 1;         // n is a copy — caller unchanged
}
let x = 5;
addOne(x);
console.log(x); // still 5

// Go — primitives copied by default; use * to opt in to mutation
func increment(n *int) {
    *n++            // dereference and mutate
}

func main() {
    x := 42
    increment(&x)   // pass address of x
    fmt.Println(x)  // 43 — x was mutated

    // Without pointer — value is copied, caller unchanged
    // increment(x)  would be a compile error (type mismatch)
}

Pointer types

ทุก type T มี pointer type *T ที่สอดคล้องกัน ตัวแปร pointer เก็บ address ไม่ใช่ค่า

// TypeScript has no pointer types
// The closest is a wrapper object or ref pattern:
const ref = { current: 0 };   // manual "pointer" idiom

var p *int          // p is a pointer to int, value is nil
x := 10
p = &x              // p now holds the address of x
fmt.Println(*p)     // 10 — dereference to read
*p = 20             // write through pointer
fmt.Println(x)      // 20

เมื่อไหร่ควรใช้ pointer ใน Go

มีสองเหตุผลหลักในการใช้ pointer:

Mutation — คุณต้องการให้ function แก้ไขตัวแปรของ caller (ไม่ใช่ทำงานกับ copy)
Efficiency — struct มีขนาดใหญ่และการ copy ทุกครั้งที่เรียกจะสิ้นเปลือง

สำหรับ struct ขนาดเล็ก (2–3 field) ที่อ่านอย่างเดียว มักใช้ value semantics ได้ สำหรับ struct ขนาดใหญ่หรือจุดที่ต้องการ mutation ให้ใช้ pointer

// TypeScript — structs/objects always pass by reference
// You have no choice; the runtime decides
interface Config { host: string; port: number; }
function connect(cfg: Config) { /* cfg is a reference */ }

type Config struct {
    Host string
    Port int
}

// Value receiver — method gets a copy; cannot modify original
func (c Config) String() string {
    return fmt.Sprintf("%s:%d", c.Host, c.Port)
}

// Pointer receiver — method can modify the original
func (c *Config) SetPort(p int) {
    c.Port = p
}

func main() {
    cfg := Config{Host: "localhost", Port: 8080}
    cfg.SetPort(9090)
    fmt.Println(cfg.String()) // localhost:9090
}

ลองทำ

Open in Playground

package main

import "fmt"

func increment(n *int) {
  *n++
}

func swap(a, b *int) {
  *a, *b = *b, *a
}

func main() {
  x := 42
  fmt.Println("before:", x)
  increment(&x)
  fmt.Println("after increment:", x)

  a, b := 10, 20
  fmt.Printf("before swap: a=%d b=%d\n", a, b)
  swap(&a, &b)
  fmt.Printf("after  swap: a=%d b=%d\n", a, b)

  // Pointer to struct
  type Point struct{ X, Y int }
  p := &Point{X: 1, Y: 2}
  p.X = 99 // Go auto-dereferences: (*p).X = 99
  fmt.Println("point:", *p)
}

🟦 nil Pointer — null ของ Go

ตัวแปร pointer ที่ยังไม่ได้ assign จะมีค่าเป็น nil — zero value ของ pointer type ทุกชนิดใน Go การ dereference nil pointer จะทำให้เกิด runtime panic (คล้ายกับ NullPointerException ใน Java) ควรเช็ค pointer ก่อน dereference เสมอเมื่อมีโอกาสเป็น nil

var p *int        // p == nil
fmt.Println(p)    // <nil>
// fmt.Println(*p) // PANIC: nil pointer dereference

n := 42
p = &n
fmt.Println(*p)   // 42 — safe now

ความเสี่ยงที่เทียบเท่าใน TypeScript คือการเข้าถึง property บน null หรือ undefined Go ทำให้เกิด bug ประเภทเดียวกันได้ — แต่ด้วย error message ที่ชัดเจนกว่าและไม่มีความสับสนเรื่อง undefined

🟦 new(expr) — pointer ไปยังค่าในขั้นเดียว (Go 1.26+)

new(T) ให้ pointer ไปยัง zero value ก่อน Go 1.26 ถ้าอยากได้ pointer ไปยังค่าจริง ๆ ต้องผ่านตัวแปรชั่วคราว ตอนนี้ new รับ expression ได้แล้ว:

// Before 1.26 — the classic two-liner
age := 42
u := User{Age: &age}

// Go 1.26+ — same thing, no temp variable
u := User{Age: new(42)}
u2 := User{Age: new(yearsSince(born))}

มีประโยชน์กับ field แบบ optional (*int, *string, *time.Time) ที่ไลบรารี JSON หรือ database ตีความว่า “ไม่มีค่าเมื่อเป็น nil”

🟦 Auto-Dereference บน Struct Field

Go dereference pointer ให้อัตโนมัติเมื่อเข้าถึง struct field คุณจึงเขียน p.Field แทน (*p).Field ได้ ทั้งสองมีความหมายเหมือนกัน เรื่องนี้ใช้กับการเรียก method ด้วย Go จะ dereference หรือ take address ให้อัตโนมัติเพื่อให้ตรงกับ receiver type ตราบใดที่ตัวแปรนั้น addressable

type Point struct{ X, Y int }
p := &Point{X: 1, Y: 2}

// Both are identical:
fmt.Println((*p).X) // manual dereference
fmt.Println(p.X)    // auto dereference — idiomatic Go