0Pricing
Swift Academy · Leçon

Sémantique d’égalité personnalisée

Implémentez des règles d’égalité adaptées au domaine.

Sémantique d’égalité personnalisée est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Quand == par défaut ne convient pas

L’opérateur == synthétisé compare toutes les propriétés stockées. Il est parfois trop strict (vous ne vous intéressez qu’à un identifiant) ou trop permissif. Vous devez alors écrire vous-même ==.

Égalité fondée sur l’identité

Considérez deux enregistrements comme égaux lorsque leurs identifiants correspondent, sans tenir compte des autres champs :

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

Égalité insensible à la casse

Normalisez les valeurs avant de les comparer :

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

Maintenir la cohérence avec Hashable

Si vous personnalisez ==, vous MUST mettre à jour hash(into:) afin qu’il utilise les mêmes champs. Sinon, des valeurs égales pourraient avoir des hachages différents et perturber les ensembles.

Faire correspondre == et hash(into:)

Les deux utilisent uniquement id, ce qui garantit leur cohérence :

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

Une égalité qui ignore un cache

Excluez les champs dérivés ou mis en cache de la comparaison :

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

Égalité tolérante des nombres à virgule flottante

Comparez les valeurs Double dans une marge epsilon plutôt qu’exactement :

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

Égalité fondée sur un sous-ensemble de champs

Comparez un sous-ensemble pertinent pour définir l’égalité dans votre domaine :

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

Respecter les lois d’Equatable

Un == personnalisé doit rester réflexif (a == a), symétrique (a == b implique b == a) et transitif. Le non-respect de ces propriétés perturbe les collections et les algorithmes.

Une implémentation symétrique

La comparaison de formes normalisées préserve la symétrie :

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

Égalité personnalisée dans un ensemble

Puisque l’égalité et le hachage fondés uniquement sur l’identifiant concordent, l’ensemble considère les valeurs ayant le même identifiant comme une seule valeur :

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

Vérification rapide

Après avoir écrit un == personnalisé qui utilise seulement certains champs, que devez-vous également faire ?

Récapitulatif

Vous avez découvert l’égalité personnalisée :

  • Écrivez votre propre == lorsque la comparaison par défaut de toute la structure ne convient pas
  • Cas courants : égalité fondée uniquement sur l’identifiant, insensibilité à la casse, nombres à virgule flottante avec epsilon, exclusion des caches
  • Veillez à ce que hash(into:) utilise les mêmes champs
  • Restez réflexif, symétrique et transitif

Cours terminé ! Ensuite : CustomStringConvertible et Mirror.

Questions Fréquemment Posées

La leçon « Sémantique d’égalité personnalisée » est-elle gratuite ?

Oui — le texte complet de « Sémantique d’égalité personnalisée » 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 « Sémantique d’égalité personnalisée » ?

Implémentez des règles d’égalité adaptées au domaine. 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 4 sur 4.

Combien de temps prend la leçon « Sémantique d’égalité personnalisée » ?

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

  1. Equatable synthétisé
  2. Hashable et hash(into:)
  3. Comparable et tri
  4. Sémantique d’égalité personnalisée
← Retour à Swift Academy