Extension ve Swift: co to je, syntaxe a jak přidávat metody

Co je Extension ve Swift?

Extension ve Swift je jazyková konstrukce, která umožňuje rozšířit stávající typ (třídu, strukturu, enum, protokol) o nové možnosti. Je to obdoba kategorií v Objective-C, ale s většími možnostmi.

Extension může přidávat:

• Vypočítávané vlastnosti instance a typu
• Metody instance a typu
• Inicializátory (convenience init)
• Subskripty
• Vnořené typy
• Protocol conformances

Podle dokumentace Apple extension nemůže přepsat stávající metody (dynamic dispatch) a nemůže přidávat stored properties. Tato omezení zachovávají integritu původního typu.

Syntaxe rozšíření

Extension se deklaruje klíčovým slovem extension s uvedením rozšiřovaného typu.

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

Můžete rozšiřovat nejen své vlastní typy, ale také typy standardní knihovny Swift, Foundation, UIKit a dalších frameworků. To dělá z extension mocný nástroj pro přidávání doménově specifické funkcionality.

Přidávání metod přes extension

Extension umožňuje přidávat metody instance a typu k jakémukoli stávajícímu typu.

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"

Mutující metody rozšiřují hodnotové typy (struct, enum) a mohou měnit self. U tříd mutování není vyžadováno. Extension může přidávat mutující metody i k typům standardní knihovny.

Computed Properties v extension

Extension může přidávat pouze vypočítávané vlastnosti — stored properties jsou zakázány. To je logické: extension nespravuje paměť původního typu.

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 (hodinu od teď je budoucnost)

Computed properties v extension podléhají stejným pravidlům jako v hlavní implementaci: lze vytvářet vlastnosti { get } a { get set }. Swift neklade omezení na počet extension pro jeden typ. Můžete deklarovat libovolný počet extension pro jeden typ v různých souborech — to je standardní praxe ve velkých projektech.

Implementace protokolů přes extension

Extension je preferovaný způsob implementace protokolů. Místo aby byla hlavní deklarace typu přeplněna, všechny metody protokolu jsou umístěny do samostatného extension.

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

// Extension podle protokolu — čisté oddělení
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
    }
}

Tento přístup odděluje odpovědnosti: hlavní struktura obsahuje pouze stored properties, extensions — implementaci protokolů. Swift dokonce umožňuje implementaci protokolu přes extension pro typy, které nekontrolujeme.

Extension a organizace kódu

Extension není jen jazyková možnost, ale nástroj architektonické organizace. Správné použití extensions činí kód čitelným a udržovatelným.

• Seskupování podle protokolů — každý protokol v samostatném extension
• Značky (MARK) — // MARK: - Equatable pro navigaci
• Oddělení souborů — extensions pro různé protokoly v různých souborech
• Private helpers — soukromé metody v extension označené private

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

Podle Swift API Design Guidelines extensions zlepšují čitelnost: vývojář vidí strukturu dat v hlavní deklaraci a logiku — v extensions. To odpovídá principu oddělení rozhraní (Interface Segregation).

Extension s where-omezeními přidává metody pouze pro určité typy: extension Array where Element: Equatable { func isUnique() -> Bool }. Takový kód je stručný a typově bezpečný — metoda isUnique se objevuje pouze v polích s Equatable prvky, eliminuje chyby ve fázi kompilace a činí API čistším, bezpečnějším a srozumitelnějším pro ostatní vývojáře.