Swift Academy · Leçon

Hashable et hash(into:)

Permettez l’utilisation comme clés de dictionnaire et membres d’un ensemble.

Hashable et hash(into:) est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Qu’est-ce que Hashable ?

Hashable s’appuie sur Equatable et fournit une valeur de hachage. Il est nécessaire pour utiliser un type comme élément d’un Set ou comme clé d’un Dictionary.

Hashable automatique

Comme pour Equatable, les structures et les énumérations dont les membres sont Hashable bénéficient de la synthèse :

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

Utiliser un type comme clé de dictionnaire

Les types Hashable peuvent servir de clés dans un dictionnaire :

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"

Le contrat de Hashable

Deux valeurs égales (==) MUST produire la même valeur de hachage. Si vous personnalisez l’un des deux éléments, veillez à maintenir leur cohérence, sinon les ensembles et les dictionnaires risquent de se comporter de manière incorrecte.

Personnaliser hash(into:)

Implémentez hash(into:) en transmettant les propriétés pertinentes au hacheur :

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

Combiner plusieurs champs

Transmettez chaque champ qui participe à l’égalité :

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

Pourquoi utiliser uniquement les champs d’identité

Ne hachez que les champs utilisés dans ==. L’inclusion de champs supplémentaires et modifiables peut enfreindre la règle selon laquelle deux valeurs égales doivent avoir le même hachage :

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

Énumérations Hashable

Les énumérations sont automatiquement Hashable (avec leurs valeurs associées lorsque celles-ci sont Hashable) :

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

Éliminer les doublons avec un ensemble

Un usage courant consiste à supprimer les doublons en passant par un ensemble :

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

Le hacheur est aléatoire à chaque exécution

Les valeurs de hachage sont initialisées différemment à chaque exécution du programme. Ne sauvegardez donc jamais un hashValue sur disque et ne vous fiez pas à son nombre exact entre deux lancements :

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

Compter avec un dictionnaire

Les clés Hashable permettent de compter les fréquences — un modèle très courant :

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

Vérification rapide

Quelle règle hash(into:) doit-il respecter par rapport à == ?

Récapitulatif

Vous avez découvert Hashable :

Hashable affine Equatable et est nécessaire pour les clés de Set/Dictionary
Il est synthétisé pour les structures et les énumérations dont les membres sont Hashable
Avec hash(into:) personnalisé, combinez uniquement les champs d’identité utilisés dans ==
Les valeurs égales doivent avoir le même hachage ; les hachages sont aléatoires à chaque exécution

Ensuite : Comparable et le tri.

Questions Fréquemment Posées

La leçon « Hashable et hash(into:) » est-elle gratuite ?

Oui — le texte complet de « Hashable et hash(into:) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Hashable et hash(into:) » ?

Permettez l’utilisation comme clés de dictionnaire et membres d’un ensemble. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Hashable et hash(into:) » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Swift Academy