Swift Academy · Aula

Equatable Sintetizado

Obtenha == automaticamente e personalize quando necessário.

Equatable Sintetizado é 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.

O que é Equatable?

Equatable é o protocolo que fornece o operador == a um tipo. A conformidade permite comparar dois valores quanto à igualdade e usá-los com contains, firstIndex e muito mais.

Conformidade automática

Para uma estrutura cujas propriedades armazenadas são todas Equatable, o Swift gera == automaticamente para você — basta declarar a conformidade:

struct Point: Equatable {
    let x: Int
    let y: Int
}
print(Point(x: 1, y: 2) == Point(x: 1, y: 2))  // true
print(Point(x: 1, y: 2) == Point(x: 9, y: 2))  // false

Como funciona a síntese

O == gerado compara cada par de propriedades armazenadas. Todas devem ser iguais para que os valores sejam iguais:

struct User: Equatable {
    let name: String
    let age: Int
}
let a = User(name: "Ann", age: 30)
let b = User(name: "Ann", age: 31)
print(a == b)  // false  (age differs)

Usando == em coleções

Equatable habilita muitas operações de matriz:

struct Tag: Equatable { let name: String }
let tags = [Tag(name: "a"), Tag(name: "b")]
print(tags.contains(Tag(name: "b")))        // true
print(tags.firstIndex(of: Tag(name: "a"))!) // 0

Enumerações também são Equatable

As enumerações também recebem Equatable sintetizado. Enumerações sem valores associados são Equatable mesmo sem declará-lo; com valores associados, declare a conformidade e os valores também serão comparados.

Enumeração Equatable com valores associados

Os valores associados participam da comparação:

enum Status: Equatable {
    case active
    case error(code: Int)
}
print(Status.error(code: 404) == Status.error(code: 404))  // true
print(Status.error(code: 404) == Status.error(code: 500))  // false

Tipos aninhados

A síntese é composta: uma estrutura que contém membros Equatable também pode ter sua conformidade sintetizada:

struct Line: Equatable {
    let start: Int
    let end: Int
}
struct Shape: Equatable {
    let lines: [Line]
}
print(Shape(lines: [Line(start: 0, end: 1)]) == Shape(lines: [Line(start: 0, end: 1)]))  // true

Quando a síntese falha

Se alguma propriedade armazenada não for Equatable, a síntese não estará disponível e você deverá escrever == por conta própria (isso será abordado mais adiante):

struct Box: Equatable {
    let id: Int
    static func == (l: Box, r: Box) -> Bool { l.id == r.id }
}
print(Box(id: 1) == Box(id: 1))  // true

Classes não têm síntese automática

Tipos por referência não recebem == sintetizado; você deve implementá-lo (comparando a identidade ou os campos):

final class Account: Equatable {
    let id: Int
    init(id: Int) { self.id = id }
    static func == (l: Account, r: Account) -> Bool { l.id == r.id }
}
print(Account(id: 7) == Account(id: 7))  // true

!= vem automaticamente

Quando == existe, != é derivado automaticamente como sua negação:

struct Color: Equatable { let hex: String }
print(Color(hex: "#fff") != Color(hex: "#000"))  // true

Equatable em código genérico

Equatable permite que funções genéricas comparem elementos — muitos algoritmos exigem isso:

func allSame<T: Equatable>(_ xs: [T]) -> Bool {
    guard let first = xs.first else { return true }
    return xs.allSatisfy { $0 == first }
}
print(allSame([2, 2, 2]))  // true
print(allSame(["a", "b"]))  // false

Verificação rápida

Para qual tipo o Swift sintetiza automaticamente == quando você declara Equatable?

Recapitulação

Você aprendeu sobre Equatable:

Equatable fornece == (e != gratuitamente)
Estruturas e enumerações com membros Equatable recebem == sintetizado
Habilita contains, firstIndex(of:) etc.
Classes e membros que não são Equatable exigem um == manual

Próximo tópico: Hashable.

Perguntas Frequentes

A aula “Equatable Sintetizado” é grátis?

Sim — o texto completo de “Equatable Sintetizado” é 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 “Equatable Sintetizado”?

Obtenha == automaticamente e personalize quando necessário. 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 “Equatable Sintetizado”?

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