Comparable ja lajittelu
Määritä järjestys operaattorilla < lajittelua varten.
Comparable ja lajittelu on ilmainen Swift Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/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.
Mikä on Comparable?
Comparable antaa tyypille järjestysoperaattorit: <, <=, >, >=. Protokollan noudattaminen mahdollistaa sorted()-, min()- ja max()-funktioiden kutsumisen suoraan.
Noudattaminen toteuttamalla <
Toteuttakaa vain <; muut operaattorit johdetaan automaattisesti. (Myös Equatable vaaditaan.)
struct Version: Comparable {
let major: Int
static func < (l: Version, r: Version) -> Bool { l.major < r.major }
}
print(Version(major: 1) < Version(major: 2)) // trueComparable-tyypin lajittelu
Comparable-protokollan avulla sorted() ei tarvitse closurea:
struct Score: Comparable {
let points: Int
static func < (l: Score, r: Score) -> Bool { l.points < r.points }
}
let sorted = [Score(points: 3), Score(points: 1), Score(points: 2)].sorted()
print(sorted.map { $0.points }) // [1, 2, 3]min ja max käyttöön automaattisesti
Comparable ottaa käyttöön myös koostefunktiot:
struct Temp: Comparable {
let c: Int
static func < (l: Temp, r: Temp) -> Bool { l.c < r.c }
}
let temps = [Temp(c: 20), Temp(c: 5), Temp(c: 30)]
print(temps.min()!.c, temps.max()!.c) // 5 30Usean avaimen mukainen järjestys
Kun useita kenttiä käytetään tasatilanteiden ratkaisemiseen, vertailkaa niitä tärkeysjärjestyksessä <-operaattorissa tupleja käyttäen — Swift vertailee tupleja leksikografisesti.
Tuple-vertailun niksi
Vertailkaa ensin sukunimen ja sitten etunimen perusteella:
struct Person: Comparable {
let last: String
let first: String
static func < (l: Person, r: Person) -> Bool {
(l.last, l.first) < (r.last, r.first)
}
}
let p = [Person(last: "Lee", first: "Bo"), Person(last: "Lee", first: "An")].sorted()
print(p.map { $0.first }) // ["An", "Bo"]Lajittelu ilman Comparablea
Voitte aina lajitella trailing closurella, vaikka tyyppi ei olisi Comparable:
struct Item { let name: String; let qty: Int }
let items = [Item(name: "B", qty: 2), Item(name: "A", qty: 5)]
let byQty = items.sorted { $0.qty > $1.qty }
print(byQty.map { $0.name }) // ["A", "B"]Laskeva lajittelu
Kääntäkää vertailu toisinpäin tai kutsukaa .reversed()-metodia:
let nums = [3, 1, 4, 1, 5]
print(nums.sorted(by: >)) // [5, 4, 3, 1, 1]
print(nums.sorted().reversed()) // [5, 4, 3, 1, 1]sorted ja sort: vertailu
sorted() palauttaa uuden taulukon; sort() muuttaa taulukkoa paikallaan (tarvitsee var-muuttujan):
var nums = [3, 1, 2]
nums.sort()
print(nums) // [1, 2, 3]
let copy = [3, 1, 2].sorted()
print(copy) // [1, 2, 3]Vakaaksi taattu lajittelu
Swiftin lajittelun taataan olevan vakaa Swift 5:stä lähtien: yhtä suuret alkiot säilyttävät keskinäisen järjestyksensä. Luottakaa tähän ennakoitavissa olevan monivaiheisen lajittelun yhteydessä:
let words = ["bb", "a", "cc", "d"]
let byLen = words.sorted { $0.count < $1.count }
print(byLen) // ["a", "d", "bb", "cc"] -- "a" before "d", "bb" before "cc"Lajittelu avainpolun mukaan
Voitte lajitella closurella, joka lukee minkä tahansa ominaisuuden, ilman että koko tyyppi noudattaa protokollaa:
struct Player { let name: String; let score: Int }
let players = [Player(name: "A", score: 30), Player(name: "B", score: 50)]
let ranked = players.sorted { $0.score > $1.score }
print(ranked.map { $0.name }) // ["B", "A"]Pikatarkistus
Mikä yksittäinen operaattori on toteutettava Comparable-protokollan noudattamiseksi?
Kertaus
Opitte Comparablen perusteet:
Comparabletarjoaa järjestysoperaattorit; toteuttakaa vain<- Ottaa käyttöön
sorted()-,min()- jamax()-funktiot ilman closurea - Tuple-vertailu tarjoaa helpon tavan järjestää usean avaimen perusteella
sorted()palauttaa uuden taulukon,sort()muokkaa taulukkoa ja lajittelu on vakaa
Seuraavaksi: mukautetut yhtäsuuruussemantiikat.
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
Usein kysytyt kysymykset
Onko oppitunti ”Comparable ja lajittelu” ilmainen?
Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Swift Academy-oppimispolun 3 oppituntia, myös oppitunnin “Comparable ja lajittelu”. 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 ”Comparable ja lajittelu”?
Määritä järjestys operaattorilla < lajittelua varten. 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 3/4.
Kuinka kauan ”Comparable ja lajittelu”-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
- Syntetisoitu Equatable
- Hashable ja hash(into:)
- Comparable ja lajittelu
- Mukautettu yhtäsuuruussemantiikka