Protocol Extension ใน Swift: คืออะไรและวิธีใช้งาน

Protocol Extension คืออะไร?

Protocol Extension เป็นวิธีเพิ่มการใช้งานเมธอดและคุณสมบัติที่คำนวณได้ให้กับโปรโตคอลที่มีอยู่ หากไม่มี extension โปรโตคอลจะกำหนดเฉพาะข้อกำหนด และแต่ละประเภทจะใช้งานด้วยตนเอง

Protocol Extension แก้ปัญหา การทำโค้ดซ้ำ: หาก struct ห้าตัวใช้โปรโตคอลเดียวกันและใช้งานเมธอดเดียวกัน extension จะจัดเตรียมการใช้งานเริ่มต้นเพียงครั้งเดียว

ตาม Swift Evolution proposal SE-0186 protocol extensions เป็นหนึ่งในฟีเจอร์สำคัญที่กำหนดความสำเร็จของ POP พวกมันอนุญาตให้เพิ่มพฤติกรรมร่วมกันโดยไม่ต้องสร้างคลาสฐานและไม่ละเมิดหลักการความรับผิดชอบเดียว

ไวยากรณ์ของ protocol extension

Protocol Extension ถูกประกาศเหมือน extension ทั่วไป แต่ใช้ชื่อโปรโตคอลแทนประเภท

protocol Greetable {
    var name: String { get }
    func greet() -> String
}

extension Greetable {
    func greet() -> String {
        return "Hello, \(name)!"
    }
}

ตอนนี้ทุกประเภทที่ใช้ Greetable จะได้รับการใช้งาน greet โดยอัตโนมัติ:

struct Person: Greetable {
    let name: String
}
// Person มี greet() โดยอัตโนมัติ

let user = Person(name: "Alice")
print(user.greet()) // "สวัสดี Alice!"

Protocol Extension สามารถมี คุณสมบัติที่คำนวณได้ แต่ไม่ใช่คุณสมบัติที่เก็บไว้ (โปรโตคอลไม่สามารถกำหนดพื้นที่จัดเก็บได้) คุณยังสามารถเพิ่ม subscript และประเภทที่ซ้อนกันผ่าน extension

การใช้งานเมธอดเริ่มต้น

การใช้งานเริ่มต้น เป็นการใช้งานหลักของ protocol extension ประเภทสามารถแทนที่เมธอดโดยจัดเตรียมเวอร์ชันของตัวเอง

protocol Loggable {
    func log(message: String)
}

extension Loggable {
    func log(message: String) {
        print("[Default] \(message)")
    }
}

struct ConsoleLogger: Loggable {}
// ใช้การใช้งานเริ่มต้น

struct FileLogger: Loggable {
    func log(message: String) {
        // การใช้งานที่กำหนดเองแทนที่ค่าเริ่มต้น
        writeToFile(message)
    }
}

ความแตกต่างที่สำคัญจาก การสืบทอดคลาส: หากประเภทใช้งานเมธอดของโปรโตคอลด้วยตัวเอง จะเรียกใช้การใช้งานของมัน หากไม่ จะใช้ค่าเริ่มต้นจาก extension นี่คือการจัดส่งแบบสแตติก — การตัดสินใจเกิดขึ้นในเวลาคอมไพล์

ข้อจำกัด where ใน protocol extension

ประโยค where อนุญาตให้จำกัด protocol extension ให้เฉพาะประเภทที่ตรงตามเงื่อนไขเพิ่มเติม นี่เป็นกลไกที่มีประสิทธิภาพสำหรับการเพิ่มพฤติกรรมเฉพาะทาง

protocol Printable {
    var content: String { get }
}

extension Printable where Self: CustomStringConvertible {
    func debugPrint() -> String {
        return "[Printable] \(content)"
    }
}

ที่นี่ debugPrint ใช้ได้เฉพาะกับประเภทที่ใช้งานทั้ง Printable และ CustomStringConvertible พร้อมกัน ไลบรารีมาตรฐานของ Swift ใช้รูปแบบนี้อย่างกว้างขวาง — ตัวอย่างเช่น extension สำหรับ Collection where Element

ประโยค where ที่มีข้อจำกัด ความเท่าเทียมของประเภท มีประโยชน์เป็นพิเศษ:

extension Collection where Element == String {
    func commaJoined() -> String {
        return self.joined(separator: ", ")
    }
}

let words = ["Swift", "Kotlin", "Java"]
print(words.commaJoined()) // "Swift, Kotlin, Java"

กลไกนี้ทำให้ protocol extension เลือกได้: เมธอด commaJoined ใช้ได้เฉพาะกับคอลเลกชันสตริง ไม่ใช่คอลเลกชันตัวเลข คอมไพเลอร์ตรวจสอบข้อจำกัดแบบสแตติก

ข้อจำกัด where สามารถตรวจสอบ:

• การสอดคล้อง กับโปรโตคอล: where Self: Equatable
• ข้อจำกัดประเภท: where Element == String
• การรวม: where Element: Numeric, Element: Comparable

สิ่งนี้ทำให้ protocol extension เป็นกลไกที่มีประสิทธิภาพสำหรับการเพิ่มพฤติกรรมเฉพาะทางโดยไม่ทำให้การใช้งานโปรโตคอลทั่วไปปนเปื้อน

Protocol Extensions vs การสืบทอด

นักพัฒนาหลายคนสงสัย: เมื่อใดควรใช้ protocol extensions และเมื่อใดควรใช้การสืบทอดคลาส? คำตอบขึ้นอยู่กับกระบวนทัศน์ทางสถาปัตยกรรม

Apple แนะนำให้เริ่มต้นด้วย protocol + extension และเปลี่ยนไปใช้คลาสเมื่อจำเป็นต้องใช้สถานะร่วมกันหรือเอกลักษณ์ (semantics การอ้างอิง) เท่านั้น Protocol Extensions ให้การรวมแทนการสืบทอด — วิธีการที่ยืดหยุ่นและทดสอบได้มากกว่า

ในทางปฏิบัติ protocol extensions มักใช้เพื่อเพิ่มเมธอด wrapper ที่สะดวกเหนือข้อกำหนดของโปรโตคอล ตัวอย่างเช่น หากโปรโตคอลต้องการเมธอด validate พร้อมรายงานโดยละเอียด extension สามารถเพิ่มเมธอด isValid ที่ส่งคืนค่าบูลีนตามเวอร์ชันเต็ม สิ่งนี้ทำให้โค้ดไคลเอนต์ง่ายขึ้นโดยไม่เปลี่ยนสัญญาของโปรโตคอล รูปแบบนี้เรียกว่า “การใช้งานเริ่มต้นกับ API ที่ได้รับ” และใช้กันอย่างแพร่หลายในไลบรารีมาตรฐานของ Swift และเฟรมเวิร์กของบุคคลที่สามที่เป็นที่นิยม มันเป็นหนึ่งในเทคนิคสำคัญของการเขียนโปรแกรมเชิงโปรโตคอลในทางปฏิบัติและเป็นรากฐานของสถาปัตยกรรมที่ยืดหยุ่น