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

หลักการออกแบบโดยยึดโพรโทคอล

เลือกใช้การประกอบโพรโทคอลแทนการสืบทอดคลาสเพื่อการออกแบบที่ยืดหยุ่น

หลักการออกแบบโดยยึดโพรโทคอล เป็นบทเรียน Swift Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Swift Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

ยินดีต้อนรับ

การเขียนโปรแกรมเชิงโปรโตคอล (POP) ให้ความสำคัญกับการประกอบโปรโตคอลมากกว่าการสืบทอดคลาส เพื่อสร้างโค้ด Swift ที่ยืดหยุ่น ทดสอบได้ และนำกลับมาใช้ใหม่ได้

ปัญหาของการสืบทอด

ลำดับชั้นของคลาสที่ซับซ้อนก่อให้เกิดปัญหาดังนี้: • คลาสย่อยสืบทอดสถานะและพฤติกรรมทั้งหมดของคลาสหลัก • การเปลี่ยนแปลงคลาสหลักอาจทำให้คลาสย่อยทำงานผิดพลาด • ไม่สามารถสืบทอดจากสองคลาสได้ โปรโตคอลแก้ปัญหาทั้งสามข้อนี้ได้

เริ่มต้นด้วยโปรโตคอล

```swift protocol Greetable { var greeting: String { get } func greet() } extension Greetable { func greet() { print(greeting) } // default implementation } ``` ส่วนขยายของโปรโตคอลจะจัดเตรียมการทำงานเริ่มต้นที่ผู้สอดคล้องทุกชนิดได้รับโดยไม่ต้องเขียนเพิ่ม

การประกอบพฤติกรรม

```swift protocol Persistable { func save() } protocol Networked { func fetch() async throws -> Data } protocol Loggable { func log(_ msg: String) } struct DataService: Persistable, Networked, Loggable { ... } ``` นำพฤติกรรมต่าง ๆ มาประกอบกันเหมือนบล็อก LEGO — ไม่จำเป็นต้องมีลำดับชั้นของคลาส

ส่วนขยายโปรโตคอลสำหรับตรรกะที่ใช้ร่วมกัน

```swift extension Loggable { func log(_ msg: String) { print("[\(type(of: self))] \(msg)") } } // Every Loggable type gets this for free ```

การสร้างแบบจำลองย้อนหลัง

คุณสามารถนำโปรโตคอลไปใช้กับชนิดข้อมูลที่คุณไม่ได้เป็นเจ้าของได้: ```swift protocol JSONConvertible { func toJSON() -> String } extension Int: JSONConvertible { func toJSON() -> String { "\(self)" } } ``` เพิ่มการสอดคล้องให้ชนิดข้อมูลในไลบรารีมาตรฐานได้โดยไม่ต้องสืบทอดคลาส

ชนิดค่าและโปรโตคอล

โครงสร้างที่สอดคล้องกับโปรโตคอลจะมอบทั้งความหมายแบบค่า *และ* ความสามารถในการรองรับพหุรูปแบบ: ```swift protocol Shape { var area: Double { get } } struct Circle: Shape { var radius: Double; var area: Double { .pi * radius * radius } } struct Square: Shape { var side: Double; var area: Double { side * side } } let shapes: [any Shape] = [Circle(radius:3), Square(side:4)] shapes.map { $0.area } // [28.27, 16] ```

การฉีดการพึ่งพาผ่านโปรโตคอล

```swift protocol DataStore { func save(_ data: Data) } struct FileStore: DataStore { func save(_ d: Data) { /* disk */ } } struct MockStore: DataStore { func save(_ d: Data) { /* test log */ } } class Service { let store: DataStore init(store: DataStore) { self.store = store } } ```

ควรใช้คลาสเมื่อใด

ควรเลือกใช้คลาสเมื่อ: • ต้องการสถานะที่เปลี่ยนแปลงร่วมกัน (ความหมายแบบการอ้างอิง) • ต้องทำงานร่วมกับ API ของ ObjC/UIKit • การสืบทอดเป็นแบบจำลองที่เหมาะสม (พบไม่บ่อย) สำหรับกรณีอื่น ๆ ให้ใช้โปรโตคอลและโครงสร้างเป็นค่าเริ่มต้น

หลักการตั้งชื่อโปรโตคอล

• โปรโตคอลด้านความสามารถ: ลงท้ายด้วย `-able`, `-ible`, `-ing` (Equatable, Hashable, Coding) • โปรโตคอลผู้รับมอบหมาย: ลงท้ายด้วย `Delegate` หรือ `DataSource` • บทบาทนามธรรม: ใช้คำนาม (`Store`, `Parser`, `Renderer`) ชื่อที่ดีทำให้โค้ดเชิงโปรโตคอลอธิบายตัวเองได้

ตรวจสอบอย่างรวดเร็ว

ส่วนขยายของโปรโตคอลจัดเตรียมอะไรให้ชนิดข้อมูลที่สอดคล้องกับโปรโตคอล

สรุป

ประเด็นสำคัญ: • เลือกใช้โปรโตคอลและโครงสร้างแทนลำดับชั้นของคลาส • ส่วนขยายของโปรโตคอลจัดเตรียมการทำงานเริ่มต้นที่ใช้ร่วมกัน • ประกอบพฤติกรรมจากโปรโตคอลขนาดเล็กที่มีจุดประสงค์เดียว • โปรโตคอลช่วยให้ฉีดการพึ่งพาเพื่อให้ทดสอบได้ • สงวนคลาสไว้สำหรับความหมายแบบการอ้างอิงและการทำงานร่วมกับ ObjC จบหลักสูตรแล้ว! ถัดไป: ชนิดค่าเทียบกับชนิดอ้างอิงในเชิงลึก

คำถามที่พบบ่อย

บทเรียน “หลักการออกแบบโดยยึดโพรโทคอล” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “หลักการออกแบบโดยยึดโพรโทคอล” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Swift Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “หลักการออกแบบโดยยึดโพรโทคอล”

เลือกใช้การประกอบโพรโทคอลแทนการสืบทอดคลาสเพื่อการออกแบบที่ยืดหยุ่น คุณปฏิบัติ Swift Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Swift Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Swift Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “หลักการออกแบบโดยยึดโพรโทคอล” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Swift Academy นี้ได้ไหม

ได้ บทเรียน Swift Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

  1. การประกอบโพรโทคอลด้วย &
  2. การสอดคล้องตามเงื่อนไข
  3. ข้อกำหนด Self และการออกแบบ Equatable
  4. หลักการออกแบบโดยยึดโพรโทคอล
← กลับไปที่ Swift Academy