Extension in Swift: cos’è, sintassi e come aggiungere metodi

Cos’è Extension in Swift?

Extension in Swift è una costruzione del linguaggio che consente di estendere un tipo esistente (classe, struct, enum, protocollo) con nuove capacità. È simile alle categorie in Objective-C ma con maggiori potenzialità.

Extension può aggiungere:

• Proprietà calcolate — di istanza e di tipo
• Metodi — di istanza e di tipo
• Inizializzatori (convenience init)
• Subscript
• Tipi annidati
• Conformità ai protocolli

Secondo la documentazione Apple, extension non può sovrascrivere metodi esistenti (dynamic dispatch) e non può aggiungere proprietà archiviate. Questi limiti preservano l’integrità del tipo originale.

Sintassi delle estensioni

Extension si dichiara con la parola chiave extension seguita dal tipo da estendere.

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

Si possono estendere non solo i propri tipi ma anche i tipi della libreria standard di Swift, Foundation, UIKit e altri framework. Ciò rende extension uno strumento potente per aggiungere funzionalità specifiche del dominio.

Aggiungere metodi tramite extension

Extension consente di aggiungere metodi di istanza e di tipo a qualsiasi tipo esistente.

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"

I metodi mutating estendono i tipi valore (struct, enum) e possono modificare self. Per le classi, mutating non è richiesto. Extension può aggiungere metodi mutating persino ai tipi della libreria standard.

Proprietà calcolate in extension

Extension può aggiungere solo proprietà calcolate — le proprietà archiviate non sono consentite. Ciò è logico perché extension non gestisce la memoria del tipo originale.

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 (one hour from now is future)

Le proprietà calcolate in extension seguono le stesse regole dell’implementazione principale: si possono creare proprietà { get } e { get set }. Swift non impone limiti sul numero di estensioni per un tipo. Puoi dichiarare quante estensioni vuoi per un tipo in file diversi — è una pratica standard nei progetti di grandi dimensioni.

Conformità ai protocolli tramite extension

Extension è il modo preferito per implementare i protocolli. Invece di ingombrare la dichiarazione principale del tipo, tutti i metodi del protocollo vengono inseriti in un’extension separata.

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

// Extension per protocol — clean separation
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
    }
}

Questo approccio separa le responsabilità: la struttura principale contiene solo proprietà archiviate, le estensioni contengono le implementazioni dei protocolli. Swift consente persino di implementare un protocollo tramite extension per tipi che non controlliamo.

Extension e organizzazione del codice

Extension non è solo una caratteristica del linguaggio ma uno strumento di organizzazione architetturale. L’uso corretto delle estensioni rende il codice leggibile e manutenibile.

• Raggruppamento per protocollo — ogni protocollo in un’extension separata
• Mark (MARK) — // MARK: - Equatable per la navigazione
• Separazione dei file — estensioni per protocolli diversi in file diversi
• Helper privati — metodi privati in extension contrassegnati come private

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

Secondo le Swift API Design Guidelines, le estensioni migliorano la leggibilità: lo sviluppatore vede la struttura dei dati nella dichiarazione principale e la logica nelle estensioni. Ciò è in linea con il principio di segregazione delle interfacce.

Extension con vincoli where aggiunge metodi solo per tipi specifici: extension Array where Element: Equatable { func isUnique() -> Bool }. Tale codice è conciso e type-safe — il metodo isUnique appare solo sugli array con elementi Equatable, eliminando errori in fase di compilazione e rendendo l’API più pulita, sicura e chiara per altri sviluppatori.