Swift Academy · Lektion

Hashable und hash(into:)

Ermöglichen Sie die Verwendung als Dictionary-Schlüssel und Set-Elemente.

Hashable und hash(into:) ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Hashable?

Hashable baut auf Equatable auf und stellt einen Hashwert bereit. Es ist erforderlich, wenn Sie einen Typ als Element eines Set oder als Schlüssel eines Dictionary verwenden möchten.

Automatisches Hashable

Wie bei Equatable wird es für Strukturen und Enums mit Hashable-Mitgliedern synthetisiert:

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

Einen Typ als Dictionary-Schlüssel verwenden

Hashable-Typen können als Schlüssel eines Dictionarys verwendet werden:

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"

Der Hashable-Vertrag

Zwei gleiche Werte (==) MÜSSEN denselben Hash erzeugen. Wenn Sie eine der beiden Funktionen anpassen, müssen Sie sie konsistent halten, sonst verhalten sich Sets und Dictionarys fehlerhaft.

Eigenes hash(into:)

Implementieren Sie hash(into:), indem Sie dem Hasher die relevanten Eigenschaften zuführen:

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

Mehrere Felder kombinieren

Führen Sie jedes Feld zu, das an der Gleichheitsprüfung beteiligt ist:

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

Warum nur Identitätsfelder?

Verwenden Sie für den Hash nur die Felder, die in == verwendet werden. Zusätzliche (veränderliche) Felder können die Regel „Gleichheit impliziert denselben Hash“ verletzen:

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

Hashable-Enums

Enums sind automatisch Hashable (auch mit zugehörigen Werten, sofern diese Hashable sind):

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

Duplikate mit einem Set entfernen

Eine häufige Anwendung: Entfernen Sie Duplikate, indem Sie die Werte durch ein Set führen:

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

Hasher wird für jeden Lauf zufällig initialisiert

Hashwerte werden für jeden Programmlauf mit einem eigenen Startwert versehen. Speichern Sie daher niemals einen hashValue auf der Festplatte und verlassen Sie sich nicht auf seine genaue Zahl über mehrere Programmstarts hinweg:

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

Mit einem Dictionary zählen

Hashable-Schlüssel ermöglichen Häufigkeitszählungen — ein sehr häufig verwendetes Muster:

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

Schnelltest

Welche Regel muss hash(into:) in Bezug auf == einhalten?

Zusammenfassung

Sie haben Hashable kennengelernt:

Hashable erweitert Equatable und ist für Set-Elemente bzw. Dictionary-Schlüssel erforderlich
Wird für Strukturen und Enums mit Hashable-Mitgliedern synthetisiert
Eigenes hash(into:) — kombinieren Sie nur die in == verwendeten Identitätsfelder
Gleiche Werte müssen denselben Hash liefern; Hashes werden für jeden Lauf zufällig initialisiert

Als Nächstes: Comparable und Sortieren.

Häufig gestellte Fragen

Ist die Lektion „Hashable und hash(into:)“ kostenlos?

Ja — der vollständige Text von „Hashable und hash(into:)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Hashable und hash(into:)“?

Ermöglichen Sie die Verwendung als Dictionary-Schlüssel und Set-Elemente. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Hashable und hash(into:)“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy