Extension en Swift: qué es, sintaxis y cómo añadir métodos

¿Qué es Extension en Swift?

Extension en Swift es una construcción del lenguaje que permite extender un tipo existente (clase, estructura, enum, protocolo) con nuevas capacidades. Es similar a las categorías en Objective-C pero con mayor potencia.

Extension puede añadir:

• Propiedades computadas — de instancia y de tipo
• Métodos — de instancia y de tipo
• Inicializadores (convenience init)
• Subscripts
• Tipos anidados
• Conformidades con protocolos

Según la documentación de Apple, extension no puede sobrescribir métodos existentes (dynamic dispatch) ni puede añadir propiedades almacenadas. Estas limitaciones preservan la integridad del tipo original.

Sintaxis de las extensiones

Extension se declara con la palabra clave extension seguida del tipo que se extiende.

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

Se pueden extender no solo tipos propios sino también tipos de la biblioteca estándar de Swift, Foundation, UIKit y otros frameworks. Esto hace de extension una herramienta potente para añadir funcionalidad específica del dominio.

Añadir métodos mediante extension

Extension permite añadir métodos de instancia y de tipo a cualquier tipo existente.

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"

Los métodos mutating extienden tipos de valor (struct, enum) y pueden modificar self. Para las clases no se requiere mutating. Extension puede añadir métodos mutating incluso a tipos de la biblioteca estándar.

Propiedades computadas en extension

Extension solo puede añadir propiedades computadas — las propiedades almacenadas no están permitidas. Esto tiene sentido porque extension no gestiona la memoria del tipo 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 (one hour from now is future)

Las propiedades computadas en extension siguen las mismas reglas que en la implementación principal: se pueden crear propiedades { get } y { get set }. Swift no impone límite en la cantidad de extensiones para un tipo. Puedes declarar tantas extensiones para un tipo en diferentes archivos — esto es una práctica estándar en proyectos grandes.

Conformidad con protocolos mediante extension

Extension es la forma preferida de implementar protocolos. En lugar de saturar la declaración principal del tipo, todos los métodos del protocolo se colocan en una extension separada.

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
    }
}

Este enfoque separa responsabilidades: la estructura principal contiene solo propiedades almacenadas, las extensiones contienen implementaciones de protocolos. Swift incluso permite implementar un protocolo mediante extension para tipos que no controlamos.

Extension y organización del código

Extension no es solo una característica del lenguaje sino una herramienta de organización arquitectónica. El uso adecuado de las extensions hace que el código sea legible y mantenible.

• Agrupación por protocolo — cada protocolo en una extension separada
• Marcas (MARK) — // MARK: - Equatable para navegación
• Separación de archivos — extensions para diferentes protocolos en diferentes archivos
• Helpers privados — métodos privados en extension marcados como private

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

Según las Swift API Design Guidelines, las extensions mejoran la legibilidad: el desarrollador ve la estructura de datos en la declaración principal y la lógica en las extensions. Esto se alinea con el principio de Segregación de Interfaces.

Extension con restricciones where añade métodos solo para tipos específicos: extension Array where Element: Equatable { func isUnique() -> Bool }. Este código es conciso y type-safe — el método isUnique aparece solo en arrays con elementos Equatable, eliminando errores en tiempo de compilación y haciendo la API más limpia, segura y clara para otros desarrolladores.