Extension em Swift: o que é, sintaxe e como adicionar métodos

O que é Extension em Swift?

Extension em Swift é uma construção da linguagem que permite estender um tipo existente (classe, struct, enum, protocolo) com novas capacidades. É semelhante às categorias em Objective-C mas com mais poder.

Extension pode adicionar:

• Propriedades computadas — de instância e de tipo
• Métodos — de instância e de tipo
• Inicializadores (convenience init)
• Subscripts
• Tipos aninhados
• Conformidades com protocolos

De acordo com a documentação da Apple, extension não pode sobrescrever métodos existentes (dynamic dispatch) e não pode adicionar propriedades armazenadas. Essas limitações preservam a integridade do tipo original.

Sintaxe das extensões

Extension é declarada com a palavra-chave extension seguida do tipo que está sendo estendido.

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

Você pode estender não apenas seus próprios tipos mas também tipos da biblioteca padrão do Swift, Foundation, UIKit e outros frameworks. Isso torna extension uma ferramenta poderosa para adicionar funcionalidades específicas de domínio.

Adicionar métodos via extension

Extension permite adicionar métodos de instância e de tipo a qualquer 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"

Métodos mutating estendem tipos de valor (struct, enum) e podem modificar self. Para classes, mutating não é necessário. Extension pode adicionar métodos mutating até mesmo a tipos da biblioteca padrão.

Propriedades computadas em extension

Extension só pode adicionar propriedades computadas — propriedades armazenadas não são permitidas. Isso faz sentido porque extension não gerencia a memória do 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)

Propriedades computadas em extension seguem as mesmas regras da implementação principal: você pode criar propriedades { get } e { get set }. Swift não impõe limite no número de extensões para um tipo. Você pode declarar quantas extensões quiser para um tipo em arquivos diferentes — isso é prática padrão em projetos grandes.

Conformidade com protocolos via extension

Extension é a forma preferida de implementar protocolos. Em vez de poluir a declaração principal do tipo, todos os métodos do protocolo são colocados em uma 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
    }
}

Essa abordagem separa responsabilidades: a estrutura principal contém apenas propriedades armazenadas, as extensions contêm implementações de protocolos. Swift até permite implementar um protocolo via extension para tipos que não controlamos.

Extension e organização do código

Extension não é apenas um recurso da linguagem mas uma ferramenta de organização arquitetônica. O uso adequado de extensions torna o código legível e sustentável.

• Agrupamento por protocolo — cada protocolo em uma extension separada
• Marcas (MARK) — // MARK: - Equatable para navegação
• Separação de arquivos — extensions para diferentes protocolos em arquivos diferentes
• Helpers privados — métodos privados em extension marcados como private

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

De acordo com as Swift API Design Guidelines, as extensions melhoram a legibilidade: o desenvolvedor vê a estrutura de dados na declaração principal e a lógica nas extensions. Isso está alinhado com o princípio de Segregação de Interfaces.

Extension com restrições where adiciona métodos apenas para tipos específicos: extension Array where Element: Equatable { func isUnique() -> Bool }. Esse código é conciso e type-safe — o método isUnique aparece apenas em arrays com elementos Equatable, eliminando erros em tempo de compilação e tornando a API mais limpa, segura e clara para outros desenvolvedores.