interface ใน Go ทำงานอย่างไร?

Question

Accepted Answer

**interface** ของ Go กำหนดชุดของ method signature — เป็นสัญญาของพฤติกรรม ที่สำคัญคือ interface ถูกทำให้สอดคล้องแบบ **โดยปริยาย (implicitly)**: ชนิดใด ๆ ที่มี method เหล่านั้นจะสอดคล้องกับ interface โดยอัตโนมัติ โดย **ไม่ต้องประกาศ "implements" อย่างชัดเจน** แนวทางแบบ structural duck-typing นี้เป็นเอกลักษณ์และทรงพลัง

## การนิยามและการ implement interface แบบโดยปริยาย

```go
// define an interface — a set of method signatures
type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }   // Dog has Speak() → it IS a Speaker

type Cat struct{}
func (c Cat) Speak() string { return "Meow" }   // Cat too — implicitly

// NO "implements Speaker" anywhere — satisfaction is automatic
var s Speaker = Dog{}    // works because Dog has the Speak() method
s.Speak()                // "Woof"
```

ไม่มีคีย์เวิร์ด `implements` — หากชนิดหนึ่งมี method ครบทั้งหมดของ interface มันจะสอดคล้องกับ interface นั้นโดยอัตโนมัติ สิ่งนี้แยก interface ออกจากการ implement ของมัน (ผู้ implement ไม่จำเป็นต้องรู้ด้วยซ้ำว่า interface นั้นมีอยู่)

## polymorphism ผ่าน interface

```go
func announce(s Speaker) {        // accepts ANY type that has Speak()
    fmt.Println(s.Speak())
}
announce(Dog{})    // "Woof"
announce(Cat{})    // "Meow"

speakers := []Speaker{Dog{}, Cat{}}   // a slice of different types via the interface
for _, sp := range speakers { sp.Speak() }
```

interface เปิดทาง polymorphism — เขียนโค้ดที่อ้างอิงพฤติกรรม แล้วชนิดใด ๆ ที่สอดคล้องก็ใช้งานได้

## empty interface และ `any`

```go
var x interface{}     // the empty interface — satisfied by EVERY type (no methods required)
x = 42
x = "hello"
// Go 1.18+: `any` is an alias for interface{}
func print(v any) { fmt.Println(v) }   // accepts anything
```

empty interface (`interface{}` / `any`) เก็บค่าใด ๆ ก็ได้ — ใช้เมื่อยังไม่ทราบชนิดล่วงหน้า (แม้ว่าตอนนี้ generics มักจะมาแทนที่)

## interface ในไลบรารีมาตรฐานที่คุณจะใช้ตลอด

```go
type Stringer interface { String() string }   // controls fmt printing
type error interface { Error() string }        // the error type itself!
type io.Reader interface { Read(p []byte) (n int, err error) }
type io.Writer interface { Write(p []byte) (n int, err error) }
```

ส่วนใหญ่ของไลบรารีมาตรฐานถูกสร้างขึ้นบน interface เล็ก ๆ (`io.Reader`/`io.Writer`, `error`, `Stringer`) — การ implement พวกมันทำให้ชนิดของคุณทำงานร่วมกับ ecosystem ทั้งหมดได้

## สำนวน: accept interfaces, return structs

```text
Go favors SMALL interfaces (often one method) defined where they're USED (the consumer),
not where types are defined. "The bigger the interface, the weaker the abstraction."
```

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

interface เป็นหัวใจของการออกแบบ Go และแนวทางในการทำ abstraction และ polymorphism — และ **การสอดคล้องแบบโดยปริยาย** (ไม่มีคีย์เวิร์ด `implements`; structural typing) เป็นหนึ่งในคุณสมบัติที่เป็นเอกลักษณ์และทรงพลังที่สุดในภาษานี้

การแยกตัวนี้หมายความว่าชนิดและ interface พัฒนาแยกกันได้อย่างอิสระ คุณนิยาม interface *หลังจาก* ชนิดที่สอดคล้องกับมันได้ และชนิดที่สอดคล้องใด ๆ ก็เสียบเข้ากับโค้ดที่อิง interface ได้โดยอัตโนมัติ — เปิดทางการออกแบบที่ยืดหยุ่น เชื่อมโยงกันอย่างหลวม ๆ (loosely-coupled) และการทดสอบที่ง่าย (สลับ mock implementation เข้ามาได้)

การเข้าใจการ implement แบบโดยปริยาย, polymorphism ผ่าน interface, empty interface/`any`, สำนวน interface เล็ก ("accept interfaces, return structs") และ interface ในไลบรารีมาตรฐานที่พบทั่วไป (`error`, `io.Reader`/`Writer`, `Stringer`) เป็นสิ่งจำเป็นสำหรับ Go ที่เป็นสำนวน

มันเป็นหัวข้อสัมภาษณ์ที่พบบ่อย เพราะโมเดลแบบ implicit และ structural นี้แตกต่างจาก interface แบบ explicit ของ Java/C# อย่างพื้นฐาน

การนิยามและการ implement interface แบบโดยปริยาย

polymorphism ผ่าน interface

empty interface และ any

interface ในไลบรารีมาตรฐานที่คุณจะใช้ตลอด

สำนวน: accept interfaces, return structs

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

empty interface และ `any`