อะไรคือความแตกต่างระหว่าง value receiver กับ pointer receiver?

Question

Accepted Answer

**receiver** ของ method คือค่าที่มันดำเนินการกับมัน ซึ่งถูกประกาศไว้ก่อนชื่อ method มันสามารถเป็น **value receiver** (ดำเนินการกับสำเนา) หรือ **pointer receiver** (ดำเนินการกับตัวจริง สามารถแก้ไขได้) การเลือกให้ถูกต้องมีความสำคัญทั้งต่อความถูกต้อง (การแก้ไขข้อมูล) และประสิทธิภาพ

## value receiver — ดำเนินการกับสำเนา

```go
type Counter struct { count int }

func (c Counter) Increment() {     // VALUE receiver — c is a COPY
    c.count++                       // modifies the copy, NOT the original
}

c := Counter{}
c.Increment()
fmt.Println(c.count)   // 0 — the original is UNCHANGED (the copy was modified)
```

value receiver ได้รับสำเนาของ struct ดังนั้นการแก้ไขจึงไม่ส่งผลต่อตัวจริง — มีประโยชน์สำหรับ method ที่อ่านอย่างเดียว แต่จะเป็นบั๊กหากคุณตั้งใจจะแก้ไขข้อมูล

## pointer receiver — ดำเนินการกับตัวจริง

```go
func (c *Counter) Increment() {    // POINTER receiver — c points to the original
    c.count++                       // modifies the ACTUAL struct
}

c := Counter{}
c.Increment()          // Go automatically takes &c
fmt.Println(c.count)   // 1 — the original WAS modified
```

pointer receiver ดำเนินการกับ struct ตัวจริง จึงสามารถ **แก้ไข** มันได้ Go จะรับที่อยู่ให้อัตโนมัติ (`c.Increment()` ทำงานได้แม้กับ value)

## เมื่อใดควรใช้ตัวไหน

```text
Use a POINTER receiver when:
  ✓ The method needs to MODIFY the receiver (mutation)
  ✓ The struct is LARGE (avoid copying it on every call — performance)
  ✓ For CONSISTENCY (see below)

Use a VALUE receiver when:
  ✓ The method only READS, the type is small, and you want copy semantics
  ✓ The type is naturally a value (small structs, basic types)
```

## กฎความสอดคล้อง (consistency)

```go
// ✅ be consistent — if ANY method needs a pointer receiver, use pointer for ALL
func (c *Counter) Increment() { c.count++ }
func (c *Counter) Value() int { return c.count }   // pointer too, for consistency
```

การผสม value และ pointer receiver บนชนิดเดียวกันทำให้เกิดปัญหาที่ละเอียดอ่อน — ตามธรรมเนียมคือเลือกแบบหนึ่ง (มักเป็น pointer หาก method ใดมีการแก้ไขข้อมูล) แล้วใช้กับทุก method

## ความละเอียดอ่อนของการสอดคล้องกับ interface

```go
type Incrementer interface { Increment() }

// if Increment has a POINTER receiver, only *Counter satisfies the interface, not Counter
var i Incrementer = &Counter{}   // ✅ works
var j Incrementer = Counter{}    // ❌ Counter (value) does NOT satisfy it
```

นี่เป็นจุดที่ต้องระวังที่พบบ่อย: เมื่อ method มี pointer receiver มีเพียงชนิด pointer เท่านั้นที่สอดคล้องกับ interface

## ทำไมจึงสำคัญ

การเลือกระหว่าง value กับ pointer receiver เป็นการตัดสินใจพื้นฐานของ Go ที่มักถูกเข้าใจผิดบ่อย ซึ่งส่งผลต่อความถูกต้อง ประสิทธิภาพ และการสอดคล้องกับ interface

บั๊กที่พบบ่อยที่สุดคือการใช้ **value receiver ทั้งที่ตั้งใจจะแก้ไขข้อมูล** — การแก้ไขจะส่งผลต่อสำเนาเท่านั้นอย่างเงียบ ๆ ดังนั้นการเปลี่ยนแปลงจึง "ไม่ติด" pointer receiver จำเป็นสำหรับการแก้ไขข้อมูลและแนะนำสำหรับ struct ขนาดใหญ่ (เพื่อหลีกเลี่ยงการคัดลอกที่แพงในทุกการเรียก)

**กฎความสอดคล้อง** (ใช้ชนิด receiver เดียวกันตลอด method ของชนิดหนึ่ง) ช่วยหลีกเลี่ยงความสับสน และ **ความละเอียดอ่อนของการสอดคล้องกับ interface** (method ที่มี pointer receiver หมายความว่ามีเพียงชนิด pointer เท่านั้นที่สอดคล้องกับ interface) เป็นจุดที่ต้องระวังคลาสสิกที่ทำให้เกิด error "does not implement interface"

การเข้าใจสิ่งเหล่านี้เป็นสิ่งจำเป็นสำหรับการเขียน Go ที่ถูกต้องและมีประสิทธิภาพ และเป็นหนึ่งในหัวข้อเชิงปฏิบัติและการสัมภาษณ์ที่พบบ่อยที่สุด เพราะการเลือกนั้นมีผลที่ตามมาที่ไม่ชัดเจนในทันที