0Pricing
Swift Academy · Aula

Requisitos de Self e design com Equatable

Conheça protocolos que usam Self e entenda como Equatable e Comparable se aproveitam deles.

Requisitos de Self e design com Equatable é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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

`Self` em um protocolo se refere ao tipo concreto que está em conformidade. Isso permite que protocolos como `Equatable` e `Comparable` funcionem com tipos heterogêneos de forma segura.

Self como tipo de parâmetro

```swift protocol Equatable { static func == (lhs: Self, rhs: Self) -> Bool } ``` `Self` significa que ambos os parâmetros devem ser do *mesmo* tipo concreto. Não é possível comparar um `Int` com uma `String` por meio desse protocolo.

Conformidade com Equatable

```swift struct Point: Equatable { var x: Double var y: Double // Auto-synthesised: // static func == (lhs: Point, rhs: Point) -> Bool // { lhs.x == rhs.x && lhs.y == rhs.y } } print(Point(x:1,y:2) == Point(x:1,y:2)) // true ```

Comparable com Self

```swift struct Version: Comparable { let major, minor, patch: Int static func < (lhs: Version, rhs: Version) -> Bool { (lhs.major, lhs.minor, lhs.patch) < (rhs.major, rhs.minor, rhs.patch) } } let v1 = Version(major:1,minor:2,patch:0) let v2 = Version(major:2,minor:0,patch:0) print(v1 < v2) // true ```

Self como tipo de retorno

```swift protocol Clonable { func clone() -> Self } class Animal: Clonable { var name: String = "" required init() {} func clone() -> Self { type(of: self).init() } } ``` `Self` no tipo de retorno significa que as subclasses retornam o próprio tipo, não `Animal`.

Protocolo com requisito de Self (PAT)

```swift protocol Scalable { func scaled(by factor: Double) -> Self } struct Size: Scalable { var w, h: Double func scaled(by f: Double) -> Size { Size(w: w*f, h: h*f) } } ```

Hashable: Self + Equatable

```swift struct Color: Hashable { var r, g, b: UInt8 // Auto-synthesised: func hash(into:) and == } var palette: Set = [] palette.insert(Color(r:255,g:0,b:0)) ``` `Hashable` exige `Equatable` — ambos são sintetizados automaticamente para estruturas simples.

Protocolos com Self não podem ser usados diretamente como existenciais

```swift // Before Swift 5.7: var shapes: [Equatable] = [] // ❌ Equatable has Self requirement // After Swift 5.7 with 'any': var boxes: [any Equatable] = [] // ⚠️ limited API ``` A palavra-chave `any` opta explicitamente pelo encapsulamento existencial.

Pré-requisitos para a síntese

A síntese automática de `Equatable`/`Hashable`/`Comparable` exige: • Todas as propriedades armazenadas devem estar em conformidade com o mesmo protocolo • Os casos do enum, incluindo os valores associados, devem estar em conformidade ```swift struct Pair: Equatable { var a, b: T } // Equatable synthesised automatically ```

Implementação personalizada de Equatable

```swift struct Person: Equatable { var id: UUID var name: String // Only compare by id, ignore name: static func == (lhs: Person, rhs: Person) -> Bool { lhs.id == rhs.id } } ```

Verificação rápida

Em um protocolo, a que `Self` se refere?

Recapitulação

Principais conclusões: • `Self` = o tipo concreto que está em conformidade • `Equatable`, `Comparable` e `Hashable` usam `Self` • O Swift sintetiza esses protocolos automaticamente para estruturas e enums simples • `Self` em tipos de retorno fornece APIs que preservam o tipo • Protocolos com requisitos de Self precisam de `any` para existenciais (Swift 5.7+) Próximo: princípios do projeto orientado a protocolos.

Perguntas Frequentes

A aula “Requisitos de Self e design com Equatable” é grátis?

Sim — o texto completo de “Requisitos de Self e design com Equatable” é 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 “Requisitos de Self e design com Equatable”?

Conheça protocolos que usam Self e entenda como Equatable e Comparable se aproveitam deles. 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 3 de 4.

Quanto tempo leva a aula “Requisitos de Self e design com Equatable”?

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. Composição de protocolos com &
  2. Conformidade condicional
  3. Requisitos de Self e design com Equatable
  4. Princípios de design orientado a protocolos
← Voltar para Swift Academy