การฝังอินเทอร์เฟซ
ประกอบอินเทอร์เฟซ
การฝังอินเทอร์เฟซ เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
ประกอบอินเทอร์เฟซ
อินเทอร์เฟซสามารถฝังอินเทอร์เฟซอื่น เพื่อรวมชุดเมธอดให้เป็นข้อกำหนดที่ใหญ่ขึ้น ไลบรารีมาตรฐานใช้แนวทางนี้อยู่ทั่วทั้งระบบ
ไวยากรณ์การฝัง
ระบุชนิดอินเทอร์เฟซไว้ภายในอินเทอร์เฟซอีกตัวหนึ่ง เพื่อรวมเมธอดทั้งหมดของอินเทอร์เฟซนั้น
package main
import "fmt"
type Reader interface{ Read() string }
type Writer interface{ Write(s string) }
type ReadWriter interface {
Reader
Writer
}
func main() {
var rw ReadWriter
fmt.Println(rw == nil)
}io.ReadWriter ในการใช้งานจริง
ตัวอย่างคลาสสิกคือ io.ReadWriter ซึ่งนิยามโดยการฝัง io.Reader และ io.Writer ชนิดข้อมูลใดก็ตามที่มีเมธอดทั้งสองจะสอดคล้องกับอินเทอร์เฟซนี้
การทำให้อินเทอร์เฟซที่ประกอบใช้งานได้
ชนิดข้อมูลรูปธรรมจะใช้อินเทอร์เฟซที่รวมกันนี้ได้ เพียงมีเมธอดที่จำเป็นทั้งหมด
package main
import "fmt"
type Reader interface{ Read() string }
type Writer interface{ Write(s string) }
type ReadWriter interface {
Reader
Writer
}
type File struct{ data string }
func (f *File) Read() string { return f.data }
func (f *File) Write(s string) { f.data = s }
func main() {
var rw ReadWriter = &File{}
rw.Write("hi")
fmt.Println(rw.Read())
}เหตุผลที่ประกอบอินเทอร์เฟซ
อินเทอร์เฟซขนาดเล็กนำไปใช้งานและทดสอบได้ง่าย การประกอบอินเทอร์เฟซจะสร้างข้อกำหนดที่ใหญ่ขึ้นเฉพาะจุดที่จำเป็น ทำให้แต่ละส่วนยังคงกระชับ
สร้างจากส่วนประกอบขนาดเล็ก
กำหนดอินเทอร์เฟซที่มุ่งเน้นหน้าที่และมีเมธอดเดียว จากนั้นจึงนำมาประกอบกัน
package main
import "fmt"
type Opener interface{ Open() }
type Closer interface{ Close() }
type OpenCloser interface {
Opener
Closer
}
type Door struct{}
func (Door) Open() { fmt.Println("opened") }
func (Door) Close() { fmt.Println("closed") }
func main() {
var oc OpenCloser = Door{}
oc.Open()
oc.Close()
}ไม่มีเมธอดซ้ำกัน
อินเทอร์เฟซที่ฝังต้องไม่เพิ่มเมธอดที่ซ้ำกันแต่มีลายเซ็นขัดแย้งกัน ส่วนชุดเมธอดที่เหมือนกันทุกประการสามารถใช้ร่วมกันได้ใน Go รุ่นปัจจุบัน
รับอินเทอร์เฟซที่แคบ
ฟังก์ชันควรขออินเทอร์เฟซที่เล็กที่สุดเท่าที่จำเป็น หากอ่านเพียงอย่างเดียว ให้รับ io.Reader แทน io.ReadWriteCloser
package main
import "fmt"
type Reader interface{ Read() string }
func dump(r Reader) { fmt.Println(r.Read()) }
type Buf struct{}
func (Buf) Read() string { return "data" }
func main() {
dump(Buf{})
}ตระกูล io
ไลบรารีมาตรฐานประกอบ Reader, Writer และ Closer เป็น ReadCloser, WriteCloser และ ReadWriteCloser ซึ่งเป็นโครงสร้างข้อกำหนดที่เป็นระเบียบ
อินเทอร์เฟซที่ประกอบในเอพีไอ
ส่งกลับอินเทอร์เฟซที่กว้างที่สุดซึ่งค่ารองรับ แต่รับอินเทอร์เฟซที่แคบที่สุดที่ฟังก์ชันใช้งาน วิธีนี้เพิ่มทั้งความยืดหยุ่นและความชัดเจนให้สูงสุด
การฝังอินเทอร์เฟซเทียบกับการฝังสตรักต์
- การฝังสตรักต์จะเลื่อน ฟิลด์และเมธอด ขึ้นมาเพื่อใช้พฤติกรรมซ้ำ
- การฝังอินเทอร์เฟซจะรวม ข้อกำหนดของเมธอด ให้เป็นข้อกำหนดที่ใหญ่ขึ้น
ตรวจสอบอย่างรวดเร็ว
ทดสอบความรู้เกี่ยวกับการฝังอินเทอร์เฟซ
สรุป
คุณได้เรียนรู้การฝังอินเทอร์เฟซแล้ว
- ระบุอินเทอร์เฟซไว้ภายในอีกอินเทอร์เฟซหนึ่งเพื่อรวมชุดเมธอด
- แพ็กเกจ io ประกอบ Reader/Writer/Closer เข้าด้วยกัน
- ทำให้อินเทอร์เฟซพื้นฐานมีขนาดเล็ก และประกอบกันเมื่อจำเป็น
- รับอินเทอร์เฟซที่แคบที่สุดตามที่ฟังก์ชันต้องการ
คำถามที่พบบ่อย
บทเรียน “การฝังอินเทอร์เฟซ” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การฝังอินเทอร์เฟซ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การฝังอินเทอร์เฟซ”
ประกอบอินเทอร์เฟซ คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน
บทเรียน “การฝังอินเทอร์เฟซ” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม
ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การฝังสตรักต์
- การฝังอินเทอร์เฟซ
- การเลื่อนระดับเมธอด
- การประกอบแทนการสืบทอด