0Pricing
Swift Academy · Aula

Extensões de protocolos versus extensões de tipos

Compare extensões de protocolos (que adicionam implementações padrão a um protocolo, até condicionalmente) com extensões de tipos (que adicionam APIs a um tipo concreto). Entenda o comportamento da distribuição e as restrições.

Extensões de protocolos versus extensões de tipos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 3. 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 3 aulas no total.

Visão geral

Objetivo: saiba quando usar uma extensão de protocolo (comportamento padrão para todos os tipos conformes) em vez de uma extensão de tipo (APIs para um único tipo concreto). Também veremos as regras de despacho.

Protocolo e conformidade

Os protocolos declaram requisitos. Os tipos entram em conformidade implementando esses requisitos.

protocol Greeter {
    func greet() -> String
}
struct Person: Greeter {
    var name: String
    func greet() -> String { "Hi, I'm \\(name)" }  // concrete requirement impl
}
print(Person(name: "Ada").greet())

Implementações padrão por meio de extensões de protocolo

Uma extensão de protocolo pode fornecer implementações padrão usadas por todos os tipos conformes, a menos que eles forneçam suas próprias implementações.

protocol Describable {
    func describe() -> String
}
extension Describable {
    // default for ALL conformers until they override
    func describe() -> String { "No description" }
}

struct Car: Describable { }             // uses default
struct Book: Describable {
    func describe() -> String { "A book" } // custom override
}
print(Car().describe(), Book().describe())

APIs de extensões de tipo

As extensões de tipo adicionam métodos/propriedades calculadas a um único tipo concreto. Elas não adicionam propriedades armazenadas.

struct Point { var x: Int; var y: Int }

extension Point {
    // add helper just to Point
    var lengthSquared: Int { x*x + y*y }
    func moved(dx: Int, dy: Int) -> Point { Point(x: x+dx, y: y+dy) }
}
let p = Point(x: 2, y: 3)
print(p.lengthSquared, p.moved(dx: 1, dy: -1))

Extensões condicionais

Adicione comportamento a alguns tipos conformes usando uma cláusula condicional na extensão de protocolo.

protocol Summable { }
extension Int: Summable { }
extension Array where Element: Summable {
    // only for arrays whose elements conform to Summable
    func joinedCount() -> Int { self.count }
}
print([1,2,3].joinedCount())   // works (Int conforms)
 // print(["a","b"].joinedCount()) // not available

Comportamento do despacho (visão geral)

Regra prática: se um método for um requisito de protocolo e um tipo conforme o implementar, a implementação do tipo terá precedência (de modo semelhante ao dinâmico). Métodos adicionados apenas em uma extensão de protocolo, e que não sejam requisitos, usam despacho estático.

protocol Speaker { func speak() -> String }
extension Speaker { func speak() -> String { "default" } }

struct Cat: Speaker { }
struct Dog: Speaker {
    func speak() -> String { "woof" } // requirement impl overrides default
}

let s1: Speaker = Cat()
let s2: Speaker = Dog()
print(s1.speak()) // "default" (uses default impl)
print(s2.speak()) // "woof" (Dog provides requirement impl)

let c = Cat()
print(c.speak())  // "default" via extension on protocol

Extensão de protocolo vs de tipo

Verificação rápida: qual é a principal diferença?

Recapitulação

Recapitulação: use extensões de protocolo para padrões reutilizáveis, opcionalmente condicionais. Use extensões de tipo para ampliar um único tipo. Lembre-se do despacho: implementações que substituem requisitos têm precedência sobre métodos padrão de extensões.

Perguntas Frequentes

A aula “Extensões de protocolos versus extensões de tipos” é grátis?

Sim — o texto completo de “Extensões de protocolos versus extensões de tipos” é 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 3 aulas no total.

O que vou aprender em “Extensões de protocolos versus extensões de tipos”?

Compare extensões de protocolos (que adicionam implementações padrão a um protocolo, até condicionalmente) com extensões de tipos (que adicionam APIs a um tipo concreto). Entenda o comportamento da d… 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 3.

Quanto tempo leva a aula “Extensões de protocolos versus extensões de tipos”?

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

  1. Fundamentos de protocolos e extensões
  2. Extensões de protocolos versus extensões de tipos
  3. Requisitos estáticos versus de instância
← Voltar para Swift Academy