การฝังสตรักต์
ประกอบสตรักต์
การฝังสตรักต์ เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
ประกอบสตรักต์
Go ไม่มีการสืบทอดจากคลาส แต่มี การฝัง แทน โดยวางสตรักต์หนึ่งไว้ภายในอีกสตรักต์หนึ่งโดยไม่ระบุชื่อฟิลด์ เพื่อใช้ฟิลด์และเมธอดซ้ำ
ฟิลด์ไม่ระบุชื่อ
ฟิลด์ที่ฝังจะประกาศด้วยชนิดข้อมูลเท่านั้นโดยไม่ระบุชื่อ สมาชิกของฟิลด์นั้นจะถูกเลื่อนขึ้นมาให้สตรักต์ภายนอกใช้งาน
package main
import "fmt"
type Engine struct{ Power int }
type Car struct {
Engine
Brand string
}
func main() {
c := Car{Engine: Engine{Power: 150}, Brand: "Coddy"}
fmt.Println(c.Power, c.Brand)
}การเข้าถึงฟิลด์ที่ถูกเลื่อนขึ้น
คุณอ่าน c.Power ได้โดยตรง แม้ว่า Power จะเป็นสมาชิกของ Engine ที่ถูกฝังอยู่ก็ตาม นี่คือการเลื่อนฟิลด์ขึ้น
เส้นทางแบบเต็มยังใช้งานได้
คุณสามารถเข้าถึงสตรักต์ที่ฝังอยู่อย่างชัดเจนผ่านชื่อชนิดข้อมูลได้เสมอ
package main
import "fmt"
type Engine struct{ Power int }
type Car struct{ Engine }
func main() {
c := Car{Engine{200}}
fmt.Println(c.Engine.Power)
fmt.Println(c.Power)
}การฝังเทียบกับฟิลด์ที่มีชื่อ
ฟิลด์ที่มีชื่อ (engine Engine) ต้องใช้ c.engine.Power ส่วนการฝัง (Engine) จะเลื่อนสมาชิกขึ้นมา ทำให้เขียน c.Power ได้ การฝังแสดงความสัมพันธ์แบบ เป็นชนิดหนึ่งของ
การเริ่มต้นสตรักต์ที่ฝัง
ใช้ชื่อชนิดข้อมูลเป็นคีย์ของฟิลด์ในลิเทอรัลแบบประกอบ
package main
import "fmt"
type Address struct{ City string }
type User struct {
Address
Name string
}
func main() {
u := User{Address: Address{City: "Istanbul"}, Name: "Mert"}
fmt.Println(u.Name, "in", u.City)
}การฝังหลายชนิด
สตรักต์สามารถฝังหลายชนิดข้อมูลและผสมฟิลด์ของชนิดเหล่านั้นเข้าด้วยกันได้
package main
import "fmt"
type Timestamps struct{ Created string }
type Author struct{ Name string }
type Post struct {
Timestamps
Author
Title string
}
func main() {
p := Post{Timestamps{"today"}, Author{"Ada"}, "Hello"}
fmt.Println(p.Title, p.Name, p.Created)
}ชื่อชนกัน
หากชนิดข้อมูลที่ฝังสองชนิดมีชื่อฟิลด์เดียวกัน การอ้างอิงที่ไม่ชัดเจนจะทำให้เกิดข้อผิดพลาดขณะคอมไพล์ คุณต้องระบุชื่อชนิดข้อมูลเพื่อแยกให้ชัดเจน
สตรักต์ภายนอกบดบังชื่อ
ฟิลด์ที่ประกาศในสตรักต์ภายนอกจะ บดบังฟิลด์ที่ถูกเลื่อนขึ้นซึ่งมีชื่อเดียวกัน เมื่อเข้าถึงโดยไม่ระบุชื่อ ฟิลด์ภายนอกจะมีสิทธิ์เหนือกว่า
package main
import "fmt"
type Base struct{ ID int }
type Item struct {
Base
ID int
}
func main() {
i := Item{Base{1}, 99}
fmt.Println(i.ID, i.Base.ID)
}การฝังพอยน์เตอร์
คุณสามารถฝังชนิดพอยน์เตอร์ได้ สมาชิกจะยังคงถูกเลื่อนขึ้นมา แต่คุณต้องเริ่มต้นค่าพอยน์เตอร์ มิฉะนั้นอาจเกิดการอ้างอิงค่า nil
package main
import "fmt"
type Logger struct{ Prefix string }
type Service struct{ *Logger }
func main() {
s := Service{Logger: &Logger{Prefix: "[svc]"}}
fmt.Println(s.Prefix)
}ควรใช้การฝังเมื่อใด
- ใช้ฟิลด์ทั่วไปซ้ำ เช่น ประทับเวลาและรหัส
- สร้างชนิดข้อมูลที่มีความสามารถมากขึ้นจากชนิดข้อมูลขนาดเล็ก
- หลีกเลี่ยงการซ้อนลึกและเส้นทางการเข้าถึงที่ยืดยาว
ตรวจสอบอย่างรวดเร็ว
ทดสอบความรู้เกี่ยวกับการฝังสตรักต์
สรุป
คุณได้เรียนรู้การฝังสตรักต์แล้ว
- ฟิลด์ไม่ระบุชื่อจะเลื่อนสมาชิกขึ้นมายังสตรักต์ภายนอก
- เข้าถึงผ่าน
c.Powerหรือc.Engine.Power - ฟิลด์ภายนอกจะบดบังฟิลด์ที่ถูกเลื่อนขึ้น
- ชื่อชนกันต้องระบุชื่อชนิดข้อมูลอย่างชัดเจน
- การฝังพอยน์เตอร์ก็ใช้งานได้เช่นกัน
คำถามที่พบบ่อย
บทเรียน “การฝังสตรักต์” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การฝังสตรักต์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การฝังสตรักต์”
ประกอบสตรักต์ คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “การฝังสตรักต์” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม
ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ