Value vs Reference Semantics

JavaScript: ทุก object เป็น reference

ใน JavaScript และ TypeScript ค่าทุกอย่างที่ไม่ใช่ primitive (object, array, function) ถูกส่งเป็น reference การ assign object ให้ตัวแปรใหม่ไม่ได้ copy ข้อมูล — ตัวแปรทั้งสองชี้ไปที่ก้อนเดิม

// TypeScript — objects always share
const a = { x: 1 };
const b = a;        // b points to the SAME object
b.x = 99;
console.log(a.x);   // 99 — a was also mutated

ใน Go กฎมีความละเอียดกว่า: บาง type copy บาง type แชร์ การรู้ว่าอะไรเป็นอะไรป้องกัน bug ที่มองไม่เห็น

Struct และ Array เป็น value type

การ assign struct หรือ fixed-size array ให้ตัวแปรใหม่จะสร้าง copy เต็มรูปแบบ การแก้ไข copy ไม่กระทบต้นฉบับ

// TypeScript — objects always share (reference)
interface Point { x: number; y: number; }
const a: Point = { x: 1, y: 2 };
const b = a;      // b is the SAME object
b.x = 99;
console.log(a.x); // 99 — mutated!

// Arrays also share:
const arr1 = [1, 2, 3];
const arr2 = arr1;
arr2[0] = 99;
console.log(arr1[0]); // 99

// Go — structs copy on assign
type Point struct{ X, Y int }

a := Point{X: 1, Y: 2}
b := a          // b is a full COPY
b.X = 99
fmt.Println(a.X) // 1 — a is unchanged

// Fixed-size arrays also copy
arr1 := [3]int{1, 2, 3}
arr2 := arr1    // copy
arr2[0] = 99
fmt.Println(arr1[0]) // 1 — unchanged

Slice และ Map เป็น reference type

Slice และ map เก็บ pointer ภายในไปยังข้อมูลเบื้องล่าง การ assign ให้ตัวแปรใหม่จะ แชร์ pointer นั้น ทั้งสองตัวแปรจึงอ้างถึง array หรือ hash table เดิม

// TypeScript — arrays (like all objects) are references
const s1 = [1, 2, 3];
const s2 = s1;    // same array
s2[0] = 99;
console.log(s1[0]); // 99

// Maps too:
const m1 = new Map([["a", 1]]);
const m2 = m1;
m2.set("a", 99);
console.log(m1.get("a")); // 99

// Go — slices share the underlying array
s1 := []int{1, 2, 3}
s2 := s1        // s2 shares s1's underlying array
s2[0] = 99
fmt.Println(s1[0]) // 99 — shared!

// Maps always share
m1 := map[string]int{"a": 1}
m2 := m1
m2["a"] = 99
fmt.Println(m1["a"]) // 99 — shared!

// To get a true copy, use copy() for slices:
s3 := make([]int, len(s1))
copy(s3, s1)
s3[0] = 0
fmt.Println(s1[0]) // 99 — s1 unchanged

ส่งให้ function

กฎเดียวกันนี้ใช้ได้ตอนส่งค่าเข้า function โดย argument ที่เป็น struct จะมาเป็น copy ส่วน argument ที่เป็น slice/map จะแชร์ header

// TypeScript — objects always pass by reference
function mutate(obj: { x: number }) {
  obj.x = 99;    // mutates caller's object
}
const p = { x: 1 };
mutate(p);
console.log(p.x); // 99

// Go — struct passes as copy; mutation doesn't affect caller
func mutateStruct(p Point) {
    p.X = 99    // modifies the LOCAL copy only
}

// Slice passes its header (pointer + len + cap) — shares data
func mutateSlice(s []int) {
    s[0] = 99   // modifies the shared underlying array
}

func main() {
    pt := Point{X: 1}
    mutateStruct(pt)
    fmt.Println(pt.X) // 1 — unchanged

    sl := []int{1, 2, 3}
    mutateSlice(sl)
    fmt.Println(sl[0]) // 99 — shared data modified
}

ลองทำ

Open in Playground

package main

import "fmt"

type Point struct{ X, Y int }

func tryMutateStruct(p Point) {
  p.X = 999
}

func tryMutateSlice(s []int) {
  s[0] = 999
}

func main() {
  // Struct: value copy
  pt := Point{X: 1, Y: 2}
  tryMutateStruct(pt)
  fmt.Println("struct after func:", pt.X) // 1 — unchanged

  // Slice: reference semantics
  sl := []int{1, 2, 3}
  tryMutateSlice(sl)
  fmt.Println("slice after func:", sl[0]) // 999 — mutated

  // Array (fixed size): value copy
  arr := [3]int{10, 20, 30}
  arr2 := arr
  arr2[0] = 999
  fmt.Println("array original:", arr[0]) // 10 — unchanged

  // Explicit deep copy of slice
  original := []int{1, 2, 3}
  clone := make([]int, len(original))
  copy(clone, original)
  clone[0] = 999
  fmt.Println("original after clone mutation:", original[0]) // 1
}

🟦 Slice Header — สาม field ภายใน

Slice ไม่ใช่แค่ pointer ธรรมดา แต่ข้างในเป็น struct เล็ก ๆ ที่มีสาม field:

type sliceHeader struct {
    Data *[N]T  // pointer to the underlying array
    Len  int    // number of elements
    Cap  int    // capacity of the underlying array
}

เมื่อคุณ assign slice ให้ตัวแปรอื่น Go จะ copy header นี้ ทั้งสองตัวแปรจึงแชร์ Data pointer เดิม นั่นคือเหตุผลที่การ mutate element มองเห็นได้ผ่านทั้งสองตัว แต่ append อาจ allocate underlying array ใหม่เมื่อ capacity เต็ม ทำให้ header สองตัวแยกจากกัน และการแก้ไขก็ไม่แชร์กันอีก นี่คือความแตกต่างที่เล็กแต่สำคัญ

a := []int{1, 2, 3}
b := a
b = append(b, 4, 5, 6, 7) // likely causes a new allocation
b[0] = 99
fmt.Println(a[0]) // may still be 1 — b may have a new backing array

🟦 nil Slice vs Empty Slice

nil slice (var s []int) และ empty slice (s := []int{}) ทำงานเหมือนกันสำหรับ operation ส่วนใหญ่ — len(s) เป็น 0 ทั้งคู่, range s วนซ้ำศูนย์ครั้ง — แต่ไม่เท่ากัน nil slice มี nil Data pointer ส่วน empty slice มี non-nil Data pointer ที่ชี้ไปยัง zero-length array และเมื่อ marshal เป็น JSON json.Marshal จะ encode nil slice เป็น null แต่ encode empty slice เป็น [] ความแตกต่างนี้สำคัญมากใน API response

var nilSlice []int
emptySlice := []int{}
fmt.Println(nilSlice == nil)   // true
fmt.Println(emptySlice == nil) // false