Extension в Swift: какво е, синтаксис и как да добавяме методи

Какво е Extension в Swift?

Extension в Swift е езикова конструкция, която позволява разширяване на съществуващ тип (клас, структура, enum, протокол) с нови възможности. Това е аналог на категориите в Objective-C, но с повече възможности.

Extension може да добавя:

• Изчислявани свойства на инстанция и тип
• Методи на инстанция и тип
• Инициализатори (convenience init)
• Subscripts
• Вложени типове
• Protocol conformances

Според документацията на Apple, extension не може да презаписва съществуващи методи (dynamic dispatch) и не може да добавя stored properties. Тези ограничения запазват целостта на оригиналния тип.

Синтаксис на разширенията

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) метра") // 5000.0

Можете да разширявате не само собствените си типове, но и типовете от стандартната библиотека на Swift, Foundation, UIKit и други framework-ове. Това прави 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 методи дори към типове от стандартната библиотека.

Computed Properties в extension

Extension може да добавя само изчислявани свойства — stored properties са забранени. Това е логично: 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 (един час от сега е бъдеще)

Computed properties в extension се подчиняват на същите правила като в основната имплементация: могат да се създават свойства { get } и { get set }. Swift не налага ограничения на броя extension за един тип. Можете да декларирате колкото искате extension за един тип в различни файлове — това е стандартна практика в големи проекти.

Имплементация на протоколи чрез extension

Extension е предпочитаният начин за имплементация на протоколи. Вместо да претрупвате основната декларация на типа, всички методи на протокола се поставят в отделен extension.

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

// Extension по протокол — чисто разделяне
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
    }
}

Този подход разделя отговорностите: основната структура съдържа само stored properties, extensions — имплементация на протоколи. Swift дори позволява имплементация на протокол чрез extension за типове, които не контролираме.

Extension и организация на код

Extension не е просто езикова възможност, а инструмент за архитектурна организация. Правилното използване на extensions прави кода четим и поддържаем.

• Групиране по протоколи — всеки протокол в отделен extension
• Марки (MARK) — // MARK: - Equatable за навигация
• Разделение на файлове — extensions за различни протоколи в отделни файлове
• Private helpers — частни методи в extension се маркират с private

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

Според Swift API Design Guidelines, extensions подобряват четимостта: разработчикът вижда структурата на данните в основната декларация, а логиката — в extensions. Това съответства на принципа за разделяне на интерфейса (Interface Segregation).

Extension с where-ограничения добавя методи само за определени типове: extension Array where Element: Equatable { func isUnique() -> Bool }. Такъв код е сбит и типобезопасен — методът isUnique се появява само в масиви с Equatable елементи, елиминирайки грешки на етапа на компилация и правейки API-то по-чисто, по-безопасно и разбираемо за други разработчици.