Swift Academy · Aula

Implementações Padrão em Extensões

Forneça comportamentos compartilhados por meio de extensões de protocolos.

Implementações Padrão em Extensões é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O problema

Os protocolos declaram requisitos, mas não fornecem comportamento. Se todo tipo que entrasse em conformidade precisasse repetir a mesma lógica, haveria duplicação de código. As extensões de protocolo resolvem isso fornecendo implementações padrão.

protocol Greeter {
    func greet() -> String
}

Adicionando um padrão

Uma extensão do protocolo pode implementar um requisito. Os tipos que entram em conformidade obtêm esse comportamento gratuitamente, a menos que o substituam.

protocol Greeter { func greet() -> String }

extension Greeter {
    func greet() -> String { "Hello!" }
}

struct Robot: Greeter {}
print(Robot().greet())

Substituindo o padrão

Um tipo que entra em conformidade pode fornecer sua própria implementação, que tem prioridade sobre o padrão da extensão.

protocol Greeter { func greet() -> String }
extension Greeter { func greet() -> String { "Hello!" } }

struct French: Greeter {
    func greet() -> String { "Bonjour!" }
}
print(French().greet())

Adicionando métodos extras

As extensões podem adicionar métodos totalmente novos que nem sequer fazem parte do protocolo. Todo tipo que entra em conformidade os recebe automaticamente.

protocol Named { var name: String { get } }

extension Named {
    func loudName() -> String { name.uppercased() }
}

struct City: Named { let name: String }
print(City(name: "paris").loudName())

Propriedades calculadas padrão

As extensões também podem fornecer propriedades calculadas como padrões.

protocol Sized {
    var width: Double { get }
    var height: Double { get }
}

extension Sized {
    var area: Double { width * height }
}

struct Rect: Sized { let width: Double; let height: Double }
print(Rect(width: 2, height: 5).area)

Baseando-se nos requisitos

Uma implementação padrão pode chamar os próprios requisitos do protocolo, compondo um comportamento mais completo a partir do contrato mínimo que cada tipo precisa fornecer.

protocol Summable {
    var values: [Int] { get }
}

extension Summable {
    var total: Int { values.reduce(0, +) }
}

struct Cart: Summable { let values: [Int] }
print(Cart(values: [10, 20, 30]).total)

Extensões condicionais

Utilize uma cláusula where para que um padrão se aplique somente quando condições extras forem atendidas. Aqui, o padrão existe somente quando Self também é Equatable.

protocol Container {
    associatedtype Item
    var items: [Item] { get }
}

extension Container where Item: Equatable {
    func contains(_ x: Item) -> Bool { items.contains(x) }
}

struct Bag: Container { let items: [Int] }
print(Bag(items: [1, 2, 3]).contains(2))

Padrão e requisito juntos

É possível declarar um método no protocolo AND fornecer um padrão. Listá-lo no protocolo habilita o despacho dinâmico por meio do tipo do protocolo.

protocol Logger {
    func log() -> String
}
extension Logger {
    func log() -> String { "default log" }
}

struct A: Logger {}
struct B: Logger { func log() -> String { "B log" } }

let loggers: [Logger] = [A(), B()]
for l in loggers { print(l.log()) }

Armadilha do despacho estático

Se um método estiver ONLY na extensão, e não no protocolo, as chamadas por meio de um valor tipado como protocolo utilizarão a versão da extensão, mesmo que o tipo concreto tenha definido a sua própria. Declare o método no protocolo para obter despacho dinâmico.

protocol P {}
extension P { func who() -> String { "P-default" } }
struct Q: P { func who() -> String { "Q" } }

let direct = Q()
let asP: P = Q()
print(direct.who())
print(asP.who())

Reduzindo código repetitivo

A combinação de uma pequena superfície obrigatória com padrões abrangentes é o cerne do design orientado a protocolos: os tipos que entram em conformidade implementam o mínimo, e o comportamento compartilhado fica em um único lugar.

protocol Identifiable { var id: Int { get } }
extension Identifiable {
    var tag: String { "ID-" + String(id) }
}
struct Order: Identifiable { let id: Int }
print(Order(id: 7).tag)

Combinando várias extensões

É possível dividir os padrões entre várias extensões para organizar o código; todas contribuem para o tipo que entra em conformidade.

protocol Money { var cents: Int { get } }
extension Money { var dollars: Double { Double(cents) / 100 } }
extension Money { var label: String { "$" + String(format: "%.2f", dollars) } }

struct Price: Money { let cents: Int }
print(Price(cents: 1299).label)

Verificação rápida

Teste sua compreensão dos padrões das extensões de protocolo.

Recapitulação

As extensões de protocolo fornecem implementações padrão, permitindo que os tipos que entram em conformidade herdem comportamento compartilhado e o substituam quando necessário. É possível adicionar métodos extras e propriedades calculadas, restringir padrões com where e aplicar a regra de despacho estático versus dinâmico: declare um método no protocolo para obter despacho dinâmico.

Perguntas Frequentes

A aula “Implementações Padrão em Extensões” é grátis?

Sim — o texto completo de “Implementações Padrão em Extensões” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Implementações Padrão em Extensões”?

Forneça comportamentos compartilhados por meio de extensões de protocolos. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Implementações Padrão em Extensões”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy