Extension w Swift: co to jest, składnia i jak dodawać metody

Czym jest Extension w Swift?

Extension w Swift to konstrukcja językowa umożliwiająca rozszerzenie istniejącego typu (klasy, struktury, enum, protokołu) o nowe możliwości. To odpowiednik kategorii w Objective-C, ale z większymi możliwościami.

Extension może dodawać:

• Właściwości obliczane instancji i typu
• Metody instancji i typu
• Inicjalizatory (convenience init)
• Subskrypty
• Typy zagnieżdżone
• Protocol conformances

Według dokumentacji Apple, extension nie może nadpisywać istniejących metod (dynamic dispatch) ani dodawać stored properties. Te ograniczenia zachowują integralność oryginalnego typu.

Składnia rozszerzeń

Extension deklaruje się za pomocą słowa kluczowego extension z podaniem rozszerzanego 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ów") // 5000.0

Rozszerzać można nie tylko własne typy, ale także typy biblioteki standardowej Swift, Foundation, UIKit i innych frameworków. To czyni extension potężnym narzędziem do dodawania funkcjonalności specyficznej dla domeny.

Dodawanie metod przez extension

Extension umożliwia dodawanie metod instancji i typu do dowolnego istniejącego 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"

Metody mutujące rozszerzają typy wartościowe (struct, enum) i mogą modyfikować self. Dla klas mutowanie nie jest wymagane. Extension może dodawać metody mutujące nawet do typów biblioteki standardowej.

Computed Properties w extension

Extension może dodawać tylko właściwości obliczane — stored properties są zabronione. Jest to logiczne: extension nie zarządza pamięcią oryginalnego 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 (godzina od teraz to przyszłość)

Computed properties w extension podlegają tym samym zasadom co w podstawowej implementacji: można tworzyć właściwości { get } i { get set }. Swift nie nakłada ograniczeń na liczbę extension dla jednego typu. Możesz zadeklarować dowolnie wiele extension dla jednego typu w różnych plikach — to standardowa praktyka w dużych projektach.

Implementacja protokołów przez extension

Extension to preferowany sposób implementacji protokołów. Zamiast zaśmiecać podstawową deklarację typu, wszystkie metody protokołu są wyodrębniane w osobny extension.

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

// Extension według protokołu — czyste rozdzielenie
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
    }
}

Takie podejście dzieli odpowiedzialność: podstawowa struktura zawiera tylko stored properties, a extensions — implementację protokołów. Swift pozwala nawet na implementację protokołu przez extension dla typów, których nie kontrolujemy.

Extension a organizacja kodu

Extension to nie tylko możliwość językowa, ale narzędzie organizacji architektury. Prawidłowe użycie extensions sprawia, że kod jest czytelny i łatwy w utrzymaniu.

• Grupowanie według protokołów — każdy protokół w osobnym extension
• Marki (MARK) — // MARK: - Equatable dla nawigacji
• Podział plików — extensions dla różnych protokołów w różnych plikach
• Private helpers — prywatne metody w extension oznaczone private

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

Według Swift API Design Guidelines, extensions poprawiają czytelność: programista widzi strukturę danych w podstawowej deklaracji, a logikę — w extensions. Jest to zgodne z zasadą separacji interfejsu (Interface Segregation).

Extension z where-ograniczeniami dodaje metody tylko dla określonych typów: extension Array where Element: Equatable { func isUnique() -> Bool }. Taki kod jest zwięzły i bezpieczny typowo — metoda isUnique pojawia się tylko w tablicach z elementami Equatable, eliminując błędy na etapie kompilacji i czyniąc API czystszym, bezpieczniejszym i bardziej zrozumiałym dla innych programistów.