Swift Academy · Lezione

Hashable e hash(into:)

Abiliti l’uso come chiavi di dizionario e membri di un set.

Hashable e hash(into:) è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Che cos'è Hashable?

Hashable si basa su Equatable e fornisce un valore hash. È necessario per usare un tipo come elemento di un Set o come chiave di un Dictionary.

Hashable automatico

Come per Equatable, le struct e le enumerazioni con membri Hashable lo ottengono tramite sintesi:

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

Utilizzare un tipo come chiave di un Dictionary

I tipi Hashable possono essere usati come chiavi di un dizionario:

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"

Il contratto di Hashable

Due valori uguali (==) DEVONO produrre lo stesso hash. Se personalizza uno dei due, mantenga coerenti entrambi, altrimenti set e dizionari potrebbero comportarsi in modo errato.

hash(into:) personalizzato

Implementi hash(into:) inserendo le proprietà rilevanti nell'hasher:

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

Combinare più campi

Inserisca ogni campo che partecipa all'uguaglianza:

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

Perché usare solo i campi dell'identità

Esegua l'hash solo dei campi utilizzati in ==. Includere campi aggiuntivi e mutabili può violare la regola secondo cui valori uguali devono avere lo stesso 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

Enumerazioni Hashable

Le enumerazioni sono automaticamente Hashable, anche con valori associati quando questi sono Hashable:

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

Rimuovere i duplicati con un Set

Un uso comune consiste nel rimuovere i duplicati passando attraverso un Set:

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

Hasher è casuale a ogni esecuzione

I valori hash vengono inizializzati con un seed a ogni esecuzione del programma; pertanto, non salvi mai un hashValue su disco e non fare affidamento sul suo numero esatto tra un avvio e l'altro:

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

Contare con un Dictionary

Le chiavi Hashable consentono di contare le frequenze: è uno schema molto comune:

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 rapida

Quale regola deve rispettare hash(into:) in relazione a ==?

Riepilogo

Ha imparato a usare Hashable:

Hashable estende Equatable ed è necessario per gli elementi di Set e le chiavi di Dictionary
Viene sintetizzato per le struct e le enumerazioni con membri Hashable
hash(into:) personalizzato: combini solo i campi dell'identità utilizzati in ==
I valori uguali devono produrre lo stesso hash; gli hash sono casuali a ogni esecuzione

Successivo: Comparable e l'ordinamento.

Domande Frequenti

La lezione «Hashable e hash(into:)» è gratuita?

Sì — il testo completo di «Hashable e hash(into:)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Hashable e hash(into:)»?

Abiliti l’uso come chiavi di dizionario e membri di un set. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Hashable e hash(into:)»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Swift Academy