Extension a Swift-ben: mi ez, szintaxis és hogyan adjunk hozzá metódusokat

Mi az Extension a Swift-ben?

Extension a Swift-ben egy nyelvi konstrukció, amely lehetővé teszi egy meglévő típus (osztály, struktúra, enum, protokoll) bővítését új képességekkel. Ez az Objective-C kategóriáinak analógja, de több lehetőséggel.

Az extension hozzáadhat:

• Számított tulajdonságokat példány és típus szinten
• Metódusokat példány és típus szinten
• Inicializátorokat (convenience init)
• Subscripteket
• Beágyazott típusokat
• Protocol conformances

Az Apple dokumentációja szerint az extension nem írhatja felül a meglévő metódusokat (dynamic dispatch) és nem adhat hozzá stored properties tulajdonságokat. Ezek a korlátozások megőrzik az eredeti típus integritását.

A kiterjesztések szintaxisa

Extension a extension kulcsszóval deklarálható, megadva a kiterjesztendő típust.

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) méter") // 5000.0

Nem csak saját típusait bővítheti, hanem a Swift, Foundation, UIKit és más keretrendszerek szabványkönyvtárának típusait is. Ez teszi az extension-t hatékony eszközzé domain-specifikus funkciók hozzáadásához.

Metódusok hozzáadása extension-en keresztül

Extension lehetővé teszi példány- és típusmetódusok hozzáadását bármely meglévő típushoz.

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 metódusok értéktípusokat (struct, enum) bővítenek és módosíthatják a self-et. Osztályok esetén a mutating nem szükséges. Az extension mutating metódusokat adhat hozzá még a szabványkönyvtár típusaihoz is.

Computed Properties extension-ben

Extension csak számított tulajdonságokat adhat hozzá — stored properties tilos. Ez logikus: az extension nem kezeli az eredeti típus memóriáját.

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 (egy óra múlva a jövő)

A computed properties az extension-ben ugyanazoknak a szabályoknak engedelmeskedik, mint az alap implementációban: { get } és { get set } tulajdonságok hozhatók létre. A Swift nem korlátozza az extension-ök számát egy típushoz. Tetszőleges számú extension-t deklarálhat egy típushoz különböző fájlokban — ez általános gyakorlat nagy projektekben.

Protokollok implementálása extension-en keresztül

Extension az előnyben részesített módja a protokollok implementálásának. Ahelyett, hogy a típus fő deklarációját zsúfolná, a protokoll összes metódusa egy külön extension-be kerül.

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

// Extension protokollonként — tiszta szétválasztás
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
    }
}

Ez a megközelítés szétválasztja a felelősségeket: a fő struktúra csak stored properties-t tartalmaz, az extension-ök — a protokollok implementációját. A Swift még az általunk nem ellenőrzött típusok számára is lehetővé teszi a protokoll implementációját extension-en keresztül.

Extension és kódszervezés

Extension nem csak egy nyelvi lehetőség, hanem az architekturális szervezés eszköze. Az extension-ök helyes használata olvashatóvá és karbantarthatóvá teszi a kódot.

• Csoportosítás protokollok szerint — minden protokoll külön extension-ben
• Markerek (MARK) — // MARK: - Equatable navigációhoz
• Fájlok szétválasztása — extension-ök különböző protokollokhoz külön fájlokban
• Private helperek — privát metódusok extension-ben private jelöléssel

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

A Swift API Design Guidelines szerint az extension-ök javítják az olvashatóságot: a fejlesztő az adatszerkezetet a fő deklarációban, a logikát pedig az extension-ökben látja. Ez megfelel az interfész elkülönítés elvének (Interface Segregation).

A where-megkötésekkel rendelkező extension csak meghatározott típusokhoz ad metódusokat: extension Array where Element: Equatable { func isUnique() -> Bool }. Az ilyen kód tömör és típusbiztos — az isUnique metódus csak Equatable elemekkel rendelkező tömbökben jelenik meg, kiküszöbölve a hibákat a fordítási fázisban, és tisztábbá, biztonságosabbá és érthetőbbé téve az API-t más fejlesztők számára.