Swift Academy · Aula

Semântica de Igualdade Personalizada

Implemente regras de igualdade corretas para o domínio.

Semântica de Igualdade Personalizada é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

Quando o == padrão está errado

O == sintetizado compara todas as propriedades armazenadas. Às vezes isso é rigoroso demais (você só se importa com um identificador) ou permissivo demais. Nesse caso, escreva == por conta própria.

Igualdade baseada na identidade

Considere dois registros iguais quando seus identificadores coincidirem, ignorando os demais campos:

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

Igualdade que ignora maiúsculas e minúsculas

Normalize os valores antes de compará-los:

struct Username: Equatable {
    let raw: String
    static func == (l: Username, r: Username) -> Bool {
        l.raw.lowercased() == r.raw.lowercased()
    }
}
print(Username(raw: "Ann") == Username(raw: "ANN"))  // true

Mantenha Hashable consistente

Se você personalizar ==, MUST atualizar hash(into:) para usar os mesmos campos; caso contrário, valores iguais poderão produzir hashes diferentes e quebrar os Sets.

Combinando == e hash(into:)

Ambos usam apenas id, mantendo a consistência:

struct User: Hashable {
    let id: Int
    var name: String
    static func == (l: User, r: User) -> Bool { l.id == r.id }
    func hash(into h: inout Hasher) { h.combine(id) }
}
print(Set([User(id: 1, name: "A"), User(id: 1, name: "B")]).count)  // 1

Igualdade que ignora um cache

Exclua campos derivados ou armazenados em cache da comparação:

struct Doc: Equatable {
    let text: String
    var cachedWordCount: Int
    static func == (l: Doc, r: Doc) -> Bool { l.text == r.text }
}
let a = Doc(text: "hi", cachedWordCount: 1)
let b = Doc(text: "hi", cachedWordCount: 999)
print(a == b)  // true

Igualdade tolerante para números de ponto flutuante

Compare números de ponto flutuante dentro de um épsilon, em vez de compará-los exatamente:

struct Measure: Equatable {
    let value: Double
    static func == (l: Measure, r: Measure) -> Bool {
        abs(l.value - r.value) < 0.0001
    }
}
print(Measure(value: 0.1 + 0.2) == Measure(value: 0.3))  // true

Igualdade entre um subconjunto de campos

Compare um subconjunto significativo para representar a igualdade do domínio:

struct Card: Equatable {
    let rank: Int
    let suit: String
    let isFaceUp: Bool   // display state, not identity
    static func == (l: Card, r: Card) -> Bool {
        l.rank == r.rank && l.suit == r.suit
    }
}
print(Card(rank: 1, suit: "H", isFaceUp: true) == Card(rank: 1, suit: "H", isFaceUp: false))  // true

Respeite as leis de Equatable

O == personalizado deve continuar reflexivo (a == a), simétrico (a == b implica b == a) e transitivo. Violá-las confunde coleções e algoritmos.

Uma implementação simétrica

Comparar formas normalizadas mantém a simetria intacta:

struct Email: Equatable {
    let address: String
    static func == (l: Email, r: Email) -> Bool {
        l.address.lowercased() == r.address.lowercased()
    }
}
let x = Email(address: "A@x.com")
let y = Email(address: "a@X.com")
print(x == y, y == x)  // true true

Igualdade personalizada em um Set

Como a igualdade baseada apenas no identificador e o hashing concordam, o Set trata valores com o mesmo identificador como um só:

struct Item: Hashable {
    let id: Int
    var note: String
    static func == (l: Item, r: Item) -> Bool { l.id == r.id }
    func hash(into h: inout Hasher) { h.combine(id) }
}
let s: Set<Item> = [Item(id: 1, note: "x"), Item(id: 1, note: "y")]
print(s.count)  // 1

Verificação rápida

Depois de escrever um == personalizado que usa apenas alguns campos, o que mais você deve fazer?

Recapitulação

Você aprendeu sobre igualdade personalizada:

Escreva seu próprio == quando a comparação padrão de toda a estrutura estiver errada
Casos comuns: somente o identificador, sem distinção entre maiúsculas e minúsculas, números de ponto flutuante com épsilon e ignorar caches
Mantenha hash(into:) consistente com os mesmos campos
Permaneça reflexivo, simétrico e transitivo

Curso concluído! Próximo tópico: CustomStringConvertible e Mirror.

Perguntas Frequentes

A aula “Semântica de Igualdade Personalizada” é grátis?

Sim — o texto completo de “Semântica de Igualdade Personalizada” é 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 “Semântica de Igualdade Personalizada”?

Implemente regras de igualdade corretas para o domínio. 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 4 de 4.

Quanto tempo leva a aula “Semântica de Igualdade Personalizada”?

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