Extension în Swift: ce este, sintaxă și cum să adaugi metode

Ce este Extension în Swift?

Extension în Swift este o construcție lingvistică care permite extinderea unui tip existent (clasă, structură, enum, protocol) cu noi capacități. Este analogul categoriilor din Objective-C, dar cu mai multe posibilități.

Extension poate adăuga:

• Proprietăți calculate de instanță și de tip
• Metode de instanță și de tip
• Inițializatori (convenience init)
• Subscripturi
• Tipuri imbricate
• Protocol conformances

Conform documentației Apple, extension nu poate suprascrie metode existente (dynamic dispatch) și nu poate adăuga stored properties. Aceste limitări păstrează integritatea tipului original.

Sintaxa extensiilor

Extension se declară cu cuvântul cheie extension specificând tipul extins.

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

Puteți extinde nu doar propriile tipuri, ci și tipurile bibliotecii standard Swift, Foundation, UIKit și ale altor framework-uri. Aceasta face din extension un instrument puternic pentru adăugarea de funcționalități specifice domeniului.

Adăugarea metodelor prin extension

Extension permite adăugarea de metode de instanță și de tip la orice tip existent.

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"

Metodele mutante extind tipurile-valoare (struct, enum) și pot modifica self. Pentru clase, mutarea nu este necesară. Extension poate adăuga metode mutante chiar și tipurilor din biblioteca standard.

Computed Properties în extension

Extension poate adăuga doar proprietăți calculate — stored properties sunt interzise. Este logic: extension nu gestionează memoria tipului original.

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 (o oră de acum este viitor)

Computed properties în extension respectă aceleași reguli ca în implementarea principală: se pot crea proprietăți { get } și { get set }. Swift nu impune limite pentru numărul de extension pentru un tip. Puteți declara oricâte extension pentru un tip în fișiere diferite — aceasta este o practică standard în proiecte mari.

Implementarea protocoalelor prin extension

Extension este metoda preferată de implementare a protocoalelor. În loc să aglomerați declarația principală a tipului, toate metodele protocolului sunt plasate într-un extension separat.

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

// Extension per protocol — separare curată
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
    }
}

Această abordare separă responsabilitățile: structura principală conține doar stored properties, extensions — implementarea protocoalelor. Swift permite chiar implementarea unui protocol prin extension pentru tipuri pe care nu le controlăm.

Extension și organizarea codului

Extension nu este doar o facilitate lingvistică, ci un instrument de organizare arhitecturală. Utilizarea corectă a extensiilor face codul lizibil și ușor de întreținut.

• Grupare pe protocoale — fiecare protocol într-un extension separat
• Marcaje (MARK) — // MARK: - Equatable pentru navigare
• Separarea fișierelor — extensions pentru protocoale diferite în fișiere separate
• Helperi privați — metode private în extension marcate cu private

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

Conform Swift API Design Guidelines, extensiile îmbunătățesc lizibilitatea: dezvoltatorul vede structura datelor în declarația principală și logica — în extensions. Aceasta corespunde principiului separării interfeței (Interface Segregation).

Extension cu restricții where adaugă metode doar pentru tipuri specifice: extension Array where Element: Equatable { func isUnique() -> Bool }. Un astfel de cod este concis și tip-securizat — metoda isUnique apare doar în array-uri cu elemente Equatable, eliminând erorile în faza de compilare și făcând API-ul mai curat, mai sigur și mai ușor de înțeles pentru alți dezvoltatori.