Swift Academy · Les

Aangepaste gelijkheidssemantiek

Implementeer gelijkheidsregels die correct zijn voor uw domein.

Les 4 van 413 stappen

Aangepaste gelijkheidssemantiek is een gratis Swift Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Swift Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Swift Academy bevat in totaal 4 lessen.

Wanneer de standaard-== verkeerd is

Automatisch gegenereerde == vergelijkt elke opgeslagen eigenschap. Soms is dat te streng (je let alleen op een id) of te ruim. Dan schrijf je == zelf.

Gelijkheid op basis van identiteit

Behandel twee records als gelijk wanneer hun id's overeenkomen en negeer andere velden:

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

Hoofdletterongevoelige gelijkheid

Normaliseer voordat je vergelijkt:

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

Houd Hashable consistent

Als je == aanpast, MOET je hash(into:) bijwerken zodat dezelfde velden worden gebruikt. Anders kunnen gelijke waarden verschillende hashes krijgen en kunnen sets verkeerd gaan werken.

Overeenkomende == en hash(into:)

Beide gebruiken alleen id en blijven zo consistent:

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

Gelijkheid die een cache negeert

Sluit afgeleide of gecachte velden uit van de vergelijking:

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

Tolerante gelijkheid voor kommagetallen

Vergelijk doublewaarden binnen een epsilon in plaats van exact:

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

Gelijkheid op basis van een deelverzameling velden

Vergelijk een betekenisvolle deelverzameling voor gelijkheid binnen het domein:

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

Respecteer de wetten van Equatable

Aangepaste == moet reflexief blijven (a == a), symmetrisch (a == b impliceert b == a) en transitief. Als je deze regels schendt, raken verzamelingen en algoritmen in de war.

Een symmetrische implementatie

Door genormaliseerde vormen te vergelijken blijft de symmetrie behouden:

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

Aangepaste gelijkheid in een Set

Omdat gelijkheid en hashing op basis van alleen id overeenkomen, behandelt de Set waarden met dezelfde id als één waarde:

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

Korte controle

Wat moet je ook doen nadat je een aangepaste == hebt geschreven die slechts enkele velden gebruikt?

Beantwoord dit in de interactieve les

Samenvatting

Je hebt aangepaste gelijkheid geleerd:

Schrijf je eigen == wanneer de standaardvergelijking van de hele structuur niet klopt
Veelvoorkomende gevallen: alleen id, hoofdletterongevoelig, kommagetallen met epsilon en caches negeren
Houd hash(into:) consistent met dezelfde velden
Blijf reflexief, symmetrisch en transitief

De cursus is voltooid! Volgende: CustomStringConvertible en Mirror.

Gratis beginnen

Leer Swift met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 122
Lessen: 409

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Aangepaste gelijkheidssemantiek” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Swift Academy, waaronder “Aangepaste gelijkheidssemantiek”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Swift Academy bevat in totaal 4 lessen.

Wat leer ik in “Aangepaste gelijkheidssemantiek”?

Implementeer gelijkheidsregels die correct zijn voor uw domein. Je oefent met Swift Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Swift Academy te beginnen?

Ervaring vooraf is niet nodig. Swift Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Aangepaste gelijkheidssemantiek”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Swift Academy?

Ja. Elke les over Swift Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Swift Academy