Extension sa Swift: ano ito, syntax at kung paano magdagdag ng mga method

Ano ang Extension sa Swift?

Extension sa Swift ay isang language construct na nagbibigay-daan sa pagpapalawak ng umiiral na uri (klase, struct, enum, protocol) na may mga bagong kakayahan. Ito ay kahalintulad ng mga kategorya sa Objective-C, ngunit may mas maraming kakayahan.

Ang extension ay maaaring magdagdag ng:

• Computed properties ng instance at uri
• Mga method ng instance at uri
• Mga initializer (convenience init)
• Mga subscript
• Mga nested type
• Protocol conformances

Ayon sa dokumentasyon ng Apple, ang extension ay hindi maaaring mag-override ng mga umiiral na method (dynamic dispatch) at hindi maaaring magdagdag ng stored properties. Ang mga limitasyong ito ay nagpapanatili ng integridad ng orihinal na uri.

Syntax ng mga extension

Extension ay idinedeklara gamit ang keyword na extension na may pagtukoy sa uri na pinalalawak.

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) metro") // 5000.0

Maaari mong palawakin hindi lamang ang iyong sariling mga uri, kundi pati na rin ang mga uri ng standard library ng Swift, Foundation, UIKit at iba pang framework. Ginagawa nitong makapangyarihang kasangkapan ang extension para sa pagdagdag ng domain-specific na functionality.

Pagdagdag ng mga method sa pamamagitan ng extension

Extension ay nagbibigay-daan sa pagdagdag ng mga method ng instance at uri sa anumang umiiral na uri.

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 method ay nagpapalawak ng value type (struct, enum) at maaaring magbago ng self. Para sa mga klase, hindi kinakailangan ang mutating. Maaaring magdagdag ang extension ng mutating method kahit sa mga uri ng standard library.

Computed Properties sa extension

Extension ay maaari lamang magdagdag ng computed properties — ang stored properties ay ipinagbabawal. Ito ay lohikal: ang extension ay hindi namamahala ng memorya ng orihinal na uri.

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 (isang oras mula ngayon ay hinaharap)

Ang computed properties sa extension ay sumusunod sa parehong mga patakaran tulad ng sa pangunahing implementasyon: maaaring gumawa ng { get } at { get set } na mga property. Swift ay hindi nagpapataw ng mga limitasyon sa bilang ng extension para sa isang uri. Maaari kang magdeklara ng kahit ilang extension para sa isang uri sa iba't ibang file — ito ay karaniwang kasanayan sa malalaking proyekto.

Pagpapatupad ng mga protocol sa pamamagitan ng extension

Extension ay ang mas gustong paraan ng pagpapatupad ng mga protocol. Sa halip na kalat ang pangunahing deklarasyon ng uri, lahat ng method ng protocol ay inilalagay sa isang hiwalay na extension.

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

// Extension bawat protocol — malinis na paghihiwalay
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
    }
}

Ang pamamaraang ito ay naghihiwalay ng mga responsibilidad: ang pangunahing istraktura ay naglalaman lamang ng stored properties, ang mga extension — pagpapatupad ng protocol. Pinapayagan pa ng Swift ang pagpapatupad ng protocol sa pamamagitan ng extension para sa mga uri na hindi namin kontrolado.

Extension at organisasyon ng code

Extension ay hindi lamang isang language feature, kundi isang kasangkapan para sa arkitektural na organisasyon. Ang tamang paggamit ng mga extension ay ginagawang nababasa at napapanatili ang code.

• Paggrupo ayon sa protocol — bawat protocol sa hiwalay na extension
• Mga marka (MARK) — // MARK: - Equatable para sa nabigasyon
• Paghihiwalay ng file — ang mga extension para sa iba't ibang protocol sa magkahiwalay na file
• Private helpers — pribadong method sa extension ay minamarkahan ng private

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

Ayon sa Swift API Design Guidelines, pinapabuti ng mga extension ang pagbabasa: nakikita ng developer ang istraktura ng data sa pangunahing deklarasyon at ang lohika — sa mga extension. Ito ay naaayon sa prinsipyo ng paghihiwalay ng interface (Interface Segregation).

Ang extension na may where-constraint ay nagdaragdag ng mga method para lamang sa mga tiyak na uri: extension Array where Element: Equatable { func isUnique() -> Bool }. Ang ganitong code ay maikli at type-safe — ang method na isUnique ay lilitaw lamang sa mga array na may Equatable na elemento, inaalis ang mga error sa yugto ng compilation at ginagawang mas malinis, mas ligtas at mas naiintindihan ang API para sa ibang mga developer.