Extension ใน Swift: มันคืออะไร ไวยากรณ์และวิธีเพิ่มเมธอด

Extension ใน Swift คืออะไร?

Extension ใน Swift เป็นโครงสร้างภาษาที่ช่วยให้ขยายชนิดที่มีอยู่ (คลาส struct enum โปรโตคอล) ด้วยความสามารถใหม่ ๆ คล้ายกับ category ใน Objective-C แต่มีพลังมากกว่า

Extension สามารถเพิ่ม:

• คุณสมบัติแบบคำนวณ — อินสแตนซ์และชนิด
• เมธอด — อินสแตนซ์และชนิด
• ตัวเริ่มต้น (convenience init)
• Subscript
• ชนิดซ้อนกัน
• การปฏิบัติตามโปรโตคอล

ตาม เอกสารของ Apple extension ไม่สามารถเพิ่มเมธอดที่มีอยู่แล้ว (dynamic dispatch) และไม่สามารถเพิ่มคุณสมบัติแบบเก็บได้ ข้อจำกัดเหล่านี้รักษาความสมบูรณ์ของชนิดต้นฉบับ

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

Extension ประกาศด้วยคำสั่ง extension ตามด้วยชนิดที่กำลังขยาย

extension Double {
    var km: Double { return self * 1000.0 }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1000.0 }
}

let distance = 5.0.km
print("5 km = \(distance) meters") // 5000.0

คุณสามารถขยายไม่เพียงแค่ชนิดของคุณเอง แต่ยังรวมถึง ชนิดของไลบรารีมาตรฐาน ของ Swift, Foundation, UIKit และเฟรมเวิร์กอื่น ๆ ทำให้ extension เป็นเครื่องมือที่มีประสิทธิภาพสำหรับการเพิ่มฟังก์ชันเฉพาะโดเมน

การเพิ่มเมธอดผ่าน extension

Extension ช่วยให้เพิ่มเมธอดอินสแตนซ์และชนิดให้กับทุกชนิดที่มีอยู่

extension String {
    func isValidEmail() -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
        return self.range(of: emailRegex, options: .regularExpression) != nil
    }

    static func random(length: Int) -> String {
        let letters = "abcdefghijklmnopqrstuvwxyz0123456789"
        return String((0..<length).map { _ in letters.randomElement()! })
    }
}

let email = "user@example.com"
print(email.isValidEmail()) // true
let code = String.random(length: 8) // "a3f8k2m1"

เมธอด mutating ขยายชนิดค่า (struct, enum) และสามารถเปลี่ยนแปลง self ได้ สำหรับคลาสไม่จำเป็นต้องใช้ mutating Extension สามารถเพิ่มเมธอด mutating แม้แต่ในชนิดไลบรารีมาตรฐาน

คุณสมบัติแบบคำนวณใน extension

Extension สามารถเพิ่มได้เฉพาะคุณสมบัติแบบคำนวณ — คุณสมบัติแบบเก็บได้ไม่อนุญาต เป็นเรื่องที่สมเหตุสมผลเพราะ extension ไม่ได้จัดการหน่วยความจำของชนิดต้นฉบับ

extension Date {
    var isPast: Bool {
        return self < Date()
    }

    var isToday: Bool {
        return Calendar.current.isDateInToday(self)
    }
}

let someDate = Date().addingTimeInterval(3600)
print(someDate.isPast) // false (one hour from now is future)

คุณสมบัติแบบคำนวณใน extension เป็นไปตามกฎเดียวกันกับการใช้งานหลัก: คุณสามารถสร้างคุณสมบัติ { get } และ { get set } ได้ Swift ไม่ได้จำกัดจำนวน extension สำหรับหนึ่งชนิด คุณสามารถประกาศ extension ได้มากเท่าที่ต้องการสำหรับหนึ่งชนิดในไฟล์ต่าง ๆ — นี่เป็นแนวปฏิบัติมาตรฐานในโครงการขนาดใหญ่

การปฏิบัติตามโปรโตคอลผ่าน extension

Extension เป็นวิธีที่ต้องการในการใช้งานโปรโตคอล แทนที่จะทำให้การประกาศชนิดหลักรกเรื้อ เมธอดโปรโตคอลทั้งหมดจะถูกวางไว้ใน extension แยกต่างหาก

struct User {
    let id: Int
    let name: String
    let email: String
}

// Extension per protocol — clean separation
extension User: Equatable {
    static func == (lhs: User, rhs: User) -> Bool {
        return lhs.id == rhs.id
    }
}

extension User: Codable {
    enum CodingKeys: String, CodingKey {
        case id, name, email
    }
}

วิธีการนี้แยกความรับผิดชอบ: โครงสร้างหลักมีเพียง คุณสมบัติแบบเก็บได้ extensions มีการใช้งานโปรโตคอล Swift แม้แต่อนุญาตให้ใช้งานโปรโตคอลผ่าน extension สำหรับชนิดที่เราไม่ได้ควบคุม

Extension และการจัดระเบียบโค้ด

Extension ไม่ใช่แค่คุณสมบัติภาษา แต่เป็นเครื่องมือจัดระเบียบเชิงสถาปัตยกรรม การใช้ extensions อย่างถูกต้องทำให้โค้ดอ่านง่ายและบำรุงรักษาได้

• การจัดกลุ่มตามโปรโตคอล — แต่ละโปรโตคอลใน extension แยกต่างหาก
• เครื่องหมาย (MARK) — // MARK: - Equatable สำหรับการนำทาง
• การแยกไฟล์ — extensions สำหรับโปรโตคอลต่าง ๆ ในไฟล์ต่างกัน
• ตัวช่วยส่วนตัว — เมธอดส่วนตัวใน extension ที่มีเครื่องหมาย private

// MARK: - User + Displayable
extension User: Displayable {
    var displayName: String {
        return "\(name) (\(email))"
    }
}

ตาม Swift API Design Guidelines extensions ช่วยเพิ่มความสามารถในการอ่าน: นักพัฒนาเห็นโครงสร้างข้อมูลในการประกาศหลัก และตรรกะใน extensions ซึ่งสอดคล้องกับหลักการแยกส่วนอินเทอร์เฟซ

Extension ที่มีข้อจำกัด where เพิ่มเมธอดเฉพาะสำหรับบางชนิด: extension Array where Element: Equatable { func isUnique() -> Bool } โค้ดแบบนี้กระชับและปลอดภัยทางชนิด — เมธอด isUnique ปรากฏเฉพาะในอาร์เรย์ที่มีองค์ประกอบ Equatable กำจัดข้อผิดพลาดในเวลาคอมไพล์และทำให้ API สะอาดขึ้น ปลอดภัยขึ้น และชัดเจนขึ้นสำหรับนักพัฒนาคนอื่น