Swift Academy · Oppitunti

Mukautettu yhtäsuuruussemantiikka

Toteuta toimialueen kannalta oikeat yhtäsuuruussäännöt.

Oppitunti 4/413 vaihetta

Mukautettu yhtäsuuruussemantiikka on ilmainen Swift Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Swift Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Swift Academy-kurssilla on yhteensä 4 oppituntia.

Kun oletusarvoinen == on väärä

Syntetisoitu == vertailee jokaista tallennettua ominaisuutta. Joskus se on liian tiukka (välitätte vain tunnisteesta) tai liian salliva. Silloin kirjoittakaa == itse.

Tunnisteeseen perustuva yhtäsuuruus

Käsitelkää kaksi tietuetta samanarvoisina, kun niiden tunnisteet täsmäävät, ja jättäkää muut kentät huomiotta:

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

Kirjainkoosta riippumaton yhtäsuuruus

Normalisoikaa ennen vertailua:

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

Hashablen yhdenmukaisuuden säilyttäminen

Jos mukautatte ==-operaattoria, päivittäkää myös hash(into:) käyttämään samoja kenttiä, tai yhtäsuuret arvot voivat saada eri hash-arvon ja rikkoa Setin toiminnan.

Yhdenmukaiset == ja hash(into:)

Molemmissa käytetään vain id-kenttää, joten ne pysyvät yhdenmukaisina:

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

Välimuistin ohittava yhtäsuuruus

Jättäkää johdetut ja välimuistissa olevat kentät vertailun ulkopuolelle:

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

Salliva liukulukujen yhtäsuuruus

Vertailkaa double-arvoja täsmällisen vertailun sijaan epsilon-arvon sisällä:

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

Yhtäsuuruus osan kentistä perusteella

Vertailkaa toimialan kannalta merkityksellistä osajoukkoa:

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

Noudattakaa Equablen lakeja

Mukautetun ==-operaattorin on säilyttävä refleksiivisenä (a == a), symmetrisenä (a == b tarkoittaa, että b == a) ja transitiivisena. Näiden sääntöjen rikkominen sekoittaa kokoelmien ja algoritmien toiminnan.

Symmetrinen toteutus

Normalisoitujen muotojen vertaaminen säilyttää symmetrian:

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

Mukautettu yhtäsuuruus Setissä

Koska vain tunnisteeseen perustuva yhtäsuuruus ja hajautus ovat yhdenmukaisia, Set käsittelee saman tunnisteen arvoja yhtenä:

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

Pikatarkistus

Kun olette kirjoittaneet mukautetun ==-operaattorin, joka käyttää vain joitakin kenttiä, mitä muuta teidän on tehtävä?

Vastaa interaktiivisessa oppitunnissa

Kertaus

Opitte mukautetun yhtäsuuruuden perusteet:

Kirjoittakaa oma ==-operaattori, kun koko rakenteen oletusarvoinen vertailu on väärä
Yleisiä tapauksia ovat vain tunnisteen huomioiva vertailu, kirjainkoosta riippumaton vertailu, epsilon-arvoon perustuvat liukuluvut ja välimuistien ohittaminen
Pitäkää hash(into:) yhdenmukaisena samoja kenttiä käyttävän vertailun kanssa
Säilyttäkää refleksiivisyys, symmetrisyys ja transitiivisuus

Kurssi on suoritettu! Seuraavaksi: CustomStringConvertible ja Mirror.

Aloita maksutta

Opi Swift tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 122
Oppitunnit: 409

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Mukautettu yhtäsuuruussemantiikka” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Swift Academy-oppimispolun 3 oppituntia, myös oppitunnin “Mukautettu yhtäsuuruussemantiikka”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Swift Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Mukautettu yhtäsuuruussemantiikka”?

Toteuta toimialueen kannalta oikeat yhtäsuuruussäännöt. Harjoittelet Swift Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Swift Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Swift Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Mukautettu yhtäsuuruussemantiikka”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Swift Academy-oppitunnilla?

Kyllä. Jokainen Swift Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Swift Academy