การประกอบแทนการสืบทอด
ปรัชญาการออกแบบของ Go
การประกอบแทนการสืบทอด เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
ปรัชญาการออกแบบของ Go
Go จงใจไม่รวมการสืบทอดจากคลาส แนวทางที่เหมาะกับ Go คือ การประกอบ โดยสร้างพฤติกรรมจากการรวมชนิดข้อมูลและอินเทอร์เฟซขนาดเล็กเข้าด้วยกัน
เหตุใดจึงไม่ใช้การสืบทอด
ลำดับชั้นการสืบทอดที่ลึกจะเปราะบาง เพราะการเปลี่ยนแปลงในคลาสพื้นฐานอาจส่งผลต่อเนื่องอย่างคาดเดาไม่ได้ การประกอบช่วยให้ความสัมพันธ์ชัดเจนและยืดหยุ่น
ใช้แบบมี แทนแบบเป็น
แทนที่จะจำลองว่า «ผู้จัดการเป็นพนักงาน» ให้จำลองว่า «ผู้จัดการมีข้อมูลและความสามารถของพนักงาน» ผ่านการฝังหรือฟิลด์
package main
import "fmt"
type Employee struct{ Name string }
func (e Employee) Work() string { return e.Name + " works" }
type Manager struct {
Employee
Reports int
}
func main() {
m := Manager{Employee{"Lin"}, 3}
fmt.Println(m.Work(), "-", m.Reports, "reports")
}เขียนโปรแกรมโดยยึดอินเทอร์เฟซ
กำหนดพฤติกรรมด้วยอินเทอร์เฟซขนาดเล็ก แล้วรับอินเทอร์เฟซเหล่านั้น การนำไปใช้งานจึงสับเปลี่ยนกันได้และเปลี่ยนหรือจำลองได้ง่าย
package main
import "fmt"
type Notifier interface{ Notify(msg string) }
type Email struct{}
func (Email) Notify(msg string) { fmt.Println("email:", msg) }
func alert(n Notifier, m string) { n.Notify(m) }
func main() {
alert(Email{}, "deploy done")
}สับเปลี่ยนการนำไปใช้งาน
เนื่องจากฟังก์ชันพึ่งพาอินเทอร์เฟซ คุณจึงส่งการนำไปใช้งานใด ๆ ก็ได้โดยไม่ต้องเปลี่ยนฟังก์ชัน
package main
import "fmt"
type Notifier interface{ Notify(msg string) }
type Email struct{}
type SMS struct{}
func (Email) Notify(m string) { fmt.Println("email:", m) }
func (SMS) Notify(m string) { fmt.Println("sms:", m) }
func alert(n Notifier, m string) { n.Notify(m) }
func main() {
alert(Email{}, "hi")
alert(SMS{}, "hi")
}รวมพฤติกรรม
ฝังส่วนประกอบขนาดเล็กหลายส่วนเพื่อประกอบชนิดที่มีความสามารถหลากหลายจากชิ้นส่วนอิสระที่ทดสอบได้
package main
import "fmt"
type Logger struct{}
func (Logger) Log(s string) { fmt.Println("log:", s) }
type Cache struct{ data map[string]string }
func (c Cache) Get(k string) string { return c.data[k] }
type Service struct {
Logger
Cache
}
func main() {
s := Service{Cache: Cache{data: map[string]string{"k": "v"}}}
s.Log("started")
fmt.Println(s.Get("k"))
}การฉีดการพึ่งพา
ส่งสิ่งที่ต้องพึ่งพา (ในรูปอินเทอร์เฟซ) เข้าไปในตัวสร้าง แทนการกำหนดสิ่งเหล่านั้นไว้ตายตัว นี่คือการประกอบที่นำมาใช้กับการเชื่อมส่วนประกอบ
package main
import "fmt"
type Store interface{ Save(s string) }
type MemStore struct{ items []string }
func (m *MemStore) Save(s string) { m.items = append(m.items, s) }
type App struct{ store Store }
func NewApp(s Store) *App { return &App{store: s} }
func main() {
app := NewApp(&MemStore{})
app.store.Save("x")
fmt.Println("saved")
}อินเทอร์เฟซขนาดเล็กได้เปรียบ
อินเทอร์เฟซยิ่งเล็ก ชนิดต่าง ๆ ก็ยิ่งมีคุณสมบัติตรงตามอินเทอร์เฟซนั้นมากขึ้น และยิ่งทดสอบได้ง่ายขึ้น อินเทอร์เฟซยิ่งใหญ่ นามธรรมก็ยิ่งอ่อนแอ
หลีกเลี่ยงคลาสฐานที่เปราะบาง
เมื่อไม่มีการสืบทอด ก็ไม่มีคลาสฐานให้พัง แต่ละส่วนที่ประกอบกันสามารถพัฒนาได้อย่างอิสระ ทำให้การยึดโยงลดลง
รับอินเทอร์เฟซ คืนสตรักต์
แนวทางทั่วไปของ Go คือ ฟังก์ชันรับอินเทอร์เฟซ (อินพุตที่ยืดหยุ่น) และคืนสตรักต์รูปธรรม (เอาต์พุตที่ชัดเจนและนำไปใช้ได้)
รายการตรวจสอบการประกอบ
- จำลองแบบมี ไม่ใช่แบบเป็น
- ฝังส่วนประกอบขนาดเล็ก
- พึ่งพาอินเทอร์เฟซขนาดเล็ก
- ฉีดสิ่งที่ต้องพึ่งพา
ตรวจสอบความเข้าใจ
ทดสอบความรู้เกี่ยวกับแนวคิดการประกอบของคุณ
สรุปทบทวน
คุณได้เรียนรู้แนวคิดการประกอบของ Go
- ไม่มีการสืบทอด ให้ประกอบด้วยการฝังและอินเทอร์เฟซ
- จำลองแบบมีแทนแบบเป็น
- เขียนโปรแกรมโดยยึดอินเทอร์เฟซขนาดเล็กและฉีดสิ่งที่ต้องพึ่งพา
- รับอินเทอร์เฟซและคืนสตรักต์
คำถามที่พบบ่อย
บทเรียน “การประกอบแทนการสืบทอด” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การประกอบแทนการสืบทอด” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การประกอบแทนการสืบทอด”
ปรัชญาการออกแบบของ Go คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “การประกอบแทนการสืบทอด” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม
ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การฝังสตรักต์
- การฝังอินเทอร์เฟซ
- การเลื่อนระดับเมธอด
- การประกอบแทนการสืบทอด