Swift Academy · Aula

Composição de protocolos com &

Combine vários protocolos em um único requisito de tipo.

Composição de protocolos com & é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 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.

Boas-vindas

A composição de protocolos permite combinar vários protocolos em um único requisito de tipo usando `&`. Essa é a resposta do Swift à herança múltipla.

Composição básica

```swift protocol Named { var name: String { get } } protocol Aged { var age: Int { get } } func describe(_ entity: Named & Aged) { print("\(entity.name) is \(entity.age)") } ``` `Named & Aged` é um requisito de tipo temporário, não um protocolo novo.

Usando em parâmetros de função

```swift protocol Drawable { func draw() } protocol Animatable { func animate() } func render(_ view: Drawable & Animatable) { view.draw() view.animate() } ```

Armazenando tipos compostos

```swift var entity: Named & Aged = makePerson() entity.name // accessible entity.age // accessible ``` O tipo da variável restringe quais membros dos protocolos podem ser acessados.

Composição com classes

```swift protocol Configurable { func configure() } func setup(_ vc: T) { vc.configure() present(vc, animated: true) } ``` Combine um requisito de classe com um protocolo usando `&` em genéricos.

Composição de protocolos vs. novo protocolo

```swift // Don't create a new protocol just to combine: protocol NamedAndAged: Named, Aged {} // often unnecessary // Prefer inline composition at use sites: func describe(_ e: Named & Aged) { } ``` Os protocolos novos só fazem sentido quando a combinação precisa de métodos de extensão.

Alias de tipo para composições longas

```swift typealias Service = Authenticable & Cacheable & Loggable func process(service: Service) { service.authenticate() service.log("processing") } ``` Use `typealias` para dar nome às composições usadas com frequência.

Composição em restrições genéricas

```swift func fetchAndCache(_ resource: T) async throws { let data = try await resource.fetch() resource.cache(data) } ```

Herança de protocolos vs. composição

• Herança: `protocol C: A, B {}` — C herda todos os requisitos de A e B • Composição: `A & B` — em linha, sem um tipo novo Use herança quando todos os tipos conformes precisarem satisfazer ambos; use composição nos pontos de chamada.

Exemplo do mundo real: Delegado + DataSource

```swift func setup(_ vc: UITableViewDelegate & UITableViewDataSource) { tableView.delegate = vc tableView.dataSource = vc } ``` Um único controlador de visualização geralmente satisfaz ambos — a composição permite expressar isso de forma concisa.

Verificação rápida

Qual operador combina vários protocolos em um único requisito de tipo?

Recapitulação

Principais conclusões: • `Protocol1 & Protocol2` — composição em linha • Use em parâmetros, tipos de retorno e restrições genéricas • `typealias` dá nome às composições usadas com frequência • Prefira a composição a criar protocolos novos sem conteúdo • É possível combinar requisitos de classe: `UIViewController & MyProtocol` Próximo: conformidade condicional.

Perguntas Frequentes

A aula “Composição de protocolos com &” é grátis?

Sim — o texto completo de “Composição de protocolos com &” é 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 “Composição de protocolos com &”?

Combine vários protocolos em um único requisito de tipo. 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 1 de 4.

Quanto tempo leva a aula “Composição de protocolos com &”?

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

Composição de protocolos com &
Conformidade condicional
Requisitos de Self e design com Equatable
Princípios de design orientado a protocolos

← Voltar para Swift Academy