Swift Academy · Aula

Hashable e hash(into:)

Habilite o uso como chaves de dicionários e membros de conjuntos.

Hashable e hash(into:) é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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 é Hashable?

Hashable se baseia em Equatable e fornece um valor de hash. Ele é necessário para usar um tipo como elemento de um Set ou chave de um Dictionary.

Hashable automático

Assim como em Equatable, estruturas e enumerações com membros Hashable recebem essa conformidade sintetizada:

struct Point: Hashable {
    let x: Int
    let y: Int
}
let set: Set<Point> = [Point(x: 0, y: 0), Point(x: 0, y: 0)]
print(set.count)  // 1  -- duplicate collapsed

Usando um tipo como chave de um Dictionary

Tipos Hashable podem ser usados como chaves de um dicionário:

struct Coord: Hashable { let r: Int; let c: Int }
var grid: [Coord: String] = [:]
grid[Coord(r: 0, c: 0)] = "start"
print(grid[Coord(r: 0, c: 0)]!)  // "start"

O contrato de Hashable

Dois valores iguais (==) MUST produzir o mesmo hash. Se você personalizar um deles, mantenha ambos consistentes; caso contrário, conjuntos e dicionários poderão se comportar de forma incorreta.

hash(into:) personalizado

Implemente hash(into:) fornecendo as propriedades relevantes ao gerador de hash:

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

Combinando vários campos

Forneça todos os campos que participam da igualdade:

struct Pair: Hashable {
    let a: Int
    let b: String
    func hash(into hasher: inout Hasher) {
        hasher.combine(a)
        hasher.combine(b)
    }
}
print(Pair(a: 1, b: "x").hashValue == Pair(a: 1, b: "x").hashValue)  // true

Por que usar Only nos campos de identidade

Faça hash apenas dos campos usados em ==. Incluir campos extras (mutáveis) pode violar a regra de que valores iguais devem produzir o mesmo hash:

struct Doc: Hashable {
    let id: Int       // identity
    var title: String // not part of equality
    func hash(into hasher: inout Hasher) { hasher.combine(id) }
    static func == (l: Doc, r: Doc) -> Bool { l.id == r.id }
}
print(Doc(id: 1, title: "v1") == Doc(id: 1, title: "v2"))  // true

Enumerações Hashable

Enumerações são Hashable automaticamente (com valores associados quando eles são Hashable):

enum Direction: Hashable { case north, south, east, west }
let visited: Set<Direction> = [.north, .north, .east]
print(visited.count)  // 2

Removendo duplicatas com um Set

Um uso comum é remover duplicatas passando os valores por um Set:

let nums = [1, 2, 2, 3, 3, 3]
let unique = Array(Set(nums)).sorted()
print(unique)  // [1, 2, 3]

O Hasher é aleatorizado a cada execução

Os valores de hash recebem uma semente a cada execução do programa; portanto, nunca persista um hashValue em disco nem dependa do seu número exato entre diferentes inicializações:

struct K: Hashable { let v: Int }
let h1 = K(v: 5).hashValue
// h1 is stable within this run only
print(K(v: 5) == K(v: 5))  // true  -- equality is what to rely on

Contando com um Dictionary

Chaves Hashable permitem contar frequências — um padrão muito comum:

let letters = ["a", "b", "a", "c", "b", "a"]
var counts: [String: Int] = [:]
for l in letters { counts[l, default: 0] += 1 }
print(counts["a"]!)  // 3

Verificação rápida

Que regra hash(into:) deve respeitar em relação a ==?

Recapitulação

Você aprendeu sobre Hashable:

Hashable aprimora Equatable e é necessário para chaves de Set/Dictionary
É sintetizado para estruturas e enumerações com membros Hashable
Com hash(into:) personalizado, combine somente os campos de identidade usados em ==
Valores iguais devem produzir o mesmo hash; os hashes são aleatorizados a cada execução

Próximo tópico: Comparable e ordenação.

Perguntas Frequentes

A aula “Hashable e hash(into:)” é grátis?

Sim — o texto completo de “Hashable e hash(into:)” é 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 “Hashable e hash(into:)”?

Habilite o uso como chaves de dicionários e membros de conjuntos. 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 4.

Quanto tempo leva a aula “Hashable e hash(into:)”?

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