0Pricing
Go Academy · บทเรียน

การสร้าง 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. ปัญหาของพารามิเตอร์จำนวนมาก
  2. ฟังก์ชันตัวเลือก
  3. การสร้าง API ที่ยืดหยุ่น
  4. ค่าเริ่มต้นและการตรวจสอบ
← กลับไปที่ Go Academy