การสร้าง API ที่ยืดหยุ่น
ประยุกต์ใช้รูปแบบ
การสร้าง API ที่ยืดหยุ่น เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
นำรูปแบบไปใช้
ตอนนี้มาประกอบรูปแบบทั้งหมดเข้าด้วยกัน โดยสร้างตัวสร้างที่รับอาร์กิวเมนต์ที่จำเป็นและรายการตัวเลือกที่มีจำนวนแปรผัน
ตัวสร้างแบบจำนวนแปรผัน
พารามิเตอร์ที่จำเป็นจะมาก่อน ส่วนตัวเลือกจะตามมาในรูป ...Option
package main
import "fmt"
type Server struct {
Host string
Port int
}
type Option func(*Server)
func WithPort(p int) Option { return func(s *Server) { s.Port = p } }
func NewServer(host string, opts ...Option) *Server {
s := &Server{Host: host}
for _, opt := range opts {
opt(s)
}
return s
}
func main() {
s := NewServer("localhost", WithPort(8080))
fmt.Printf("%+v\n", *s)
}เรียกใช้โดยไม่มีตัวเลือก
เนื่องจากตัวเลือกมีจำนวนแปรผัน ผู้เรียกจึงละเว้นตัวเลือกทั้งหมดได้ และใช้การตั้งค่าที่ตัวสร้างเตรียมไว้
package main
import "fmt"
type Server struct{ Host string; Port int }
type Option func(*Server)
func NewServer(host string, opts ...Option) *Server {
s := &Server{Host: host}
for _, o := range opts { o(s) }
return s
}
func main() {
s := NewServer("localhost")
fmt.Printf("%+v\n", *s)
}เรียกใช้ด้วยตัวเลือกหลายรายการ
วางตัวเลือกต่อกันได้มากเท่าที่ต้องการ โดยแต่ละรายการยังอ่านได้ชัดเจนตรงจุดเรียกใช้
package main
import "fmt"
type Server struct {
Host string
Port int
Timeout int
TLS bool
}
type Option func(*Server)
func WithPort(p int) Option { return func(s *Server) { s.Port = p } }
func WithTimeout(t int) Option { return func(s *Server) { s.Timeout = t } }
func WithTLS() Option { return func(s *Server) { s.TLS = true } }
func NewServer(host string, opts ...Option) *Server {
s := &Server{Host: host}
for _, o := range opts { o(s) }
return s
}
func main() {
s := NewServer("localhost", WithPort(9000), WithTimeout(60), WithTLS())
fmt.Printf("%+v\n", *s)
}การเรียกใช้ที่อธิบายตัวเองได้
ลองเปรียบเทียบ NewServer("localhost", WithPort(9000), WithTLS()) กับการเรียกใช้ที่ส่งค่าตามตำแหน่ง เจตนานั้นชัดเจนโดยไม่ต้องตรวจสอบลายเซ็น
เพิ่มตัวเลือกภายหลัง
ต้องการการตั้งค่าใหม่หรือไม่ ให้เพิ่มฟังก์ชัน WithX ทุกจุดเรียกใช้เดิมยังคงคอมไพล์ได้โดยไม่ต้องแก้ไข ซึ่งเป็นความเข้ากันได้ย้อนหลังอย่างแท้จริง
package main
import "fmt"
type Server struct{ Host string; Retries int }
type Option func(*Server)
func WithRetries(n int) Option { return func(s *Server) { s.Retries = n } }
func NewServer(host string, opts ...Option) *Server {
s := &Server{Host: host}
for _, o := range opts { o(s) }
return s
}
func main() {
fmt.Printf("%+v\n", *NewServer("h", WithRetries(5)))
}ส่งตัวเลือกต่อไป
เนื่องจากตัวเลือกเป็นค่า คุณจึงสร้างสไลซ์ไว้ที่อื่นแล้วส่งต่อเข้าไปในตัวสร้างได้
package main
import "fmt"
type Server struct{ Host string; Port int }
type Option func(*Server)
func WithPort(p int) Option { return func(s *Server) { s.Port = p } }
func NewServer(host string, opts ...Option) *Server {
s := &Server{Host: host}
for _, o := range opts { o(s) }
return s
}
func main() {
common := []Option{WithPort(443)}
s := NewServer("api", common...)
fmt.Printf("%+v\n", *s)
}ตัวเลือกในฐานะส่วนติดต่อสาธารณะ
ส่งออกชนิด Option และฟังก์ชัน WithX เพื่อให้ผู้ใช้ไลบรารีกำหนดค่าชนิดของคุณได้โดยไม่ต้องแตะต้องส่วนภายใน
เก็บฟิลด์เป็นส่วนตัว
ฟิลด์การกำหนดค่าสามารถเก็บไว้ไม่ให้ส่งออกได้ โดยตัวเลือกเป็นวิธีที่ได้รับอนุญาตเพียงทางเดียวในการกำหนดค่า จึงช่วยปกป้องเงื่อนไขคงที่
จุดเด่นของรูปแบบนี้
- ตัวสร้างไลบรารีที่มีตัวเลือกเสริมจำนวนมาก
- ส่วนติดต่อที่ต้องคงเสถียรภาพเมื่อขยายตัว
- ไคลเอนต์ เซิร์ฟเวอร์ ตัวบันทึก และตัวสร้าง
รูปแบบที่พบในไลบรารีมาตรฐาน
คุณจะพบรูปแบบนี้ทั่วทั้งระบบนิเวศของ Go (เช่น gRPC และไดรเวอร์จำนวนมาก) การจำรูปแบบนี้ได้จะช่วยให้ส่วนติดต่อเหล่านั้นคุ้นเคย
ตรวจสอบความเข้าใจ
ทดสอบความรู้เกี่ยวกับส่วนติดต่อที่ยืดหยุ่นของคุณ
สรุปทบทวน
คุณได้สร้างส่วนติดต่อที่ยืดหยุ่นด้วยตัวเลือกแบบฟังก์ชัน
- อาร์กิวเมนต์ที่จำเป็นมาก่อน ตามด้วย
...Option - วนซ้ำผ่านตัวเลือกและนำแต่ละรายการไปใช้
- ผู้เรียกส่งตัวเลือกเป็นศูนย์รายการหรือหลายรายการได้ และอ่านได้ชัดเจน
- เพิ่มตัวเลือกภายหลังโดยไม่ทำให้ผู้เรียกใช้ไม่ได้
คำถามที่พบบ่อย
บทเรียน “การสร้าง API ที่ยืดหยุ่น” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การสร้าง API ที่ยืดหยุ่น” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การสร้าง API ที่ยืดหยุ่น”
ประยุกต์ใช้รูปแบบ คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “การสร้าง API ที่ยืดหยุ่น” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม
ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ปัญหาของพารามิเตอร์จำนวนมาก
- ฟังก์ชันตัวเลือก
- การสร้าง API ที่ยืดหยุ่น
- ค่าเริ่มต้นและการตรวจสอบ