0Pricing
Swift Academy · Lezione

Comparable e ordinamento

Definisci l’ordinamento con < per eseguire il sorting.

Comparable e ordinamento è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Che cos'è Comparable?

Comparable fornisce a un tipo gli operatori di ordinamento: <, <=, >, >=. La conformità consente di chiamare direttamente sorted(), min() e max().

Conformità con <

Deve implementare solo <; gli altri operatori vengono derivati. (È necessaria anche Equatable.)

struct Version: Comparable {
    let major: Int
    static func < (l: Version, r: Version) -> Bool { l.major < r.major }
}
print(Version(major: 1) < Version(major: 2))  // true

Ordinare un tipo Comparable

Con Comparable, sorted() non richiede alcuna closure:

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 e max senza codice aggiuntivo

Comparable abilita anche gli helper aggregati:

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 30

Ordinamento su più chiavi

Per risolvere i pari merito su più campi, li confronti nell'ordine di priorità all'interno di < usando le tuple: Swift confronta le tuple in ordine lessicografico.

Il trucco del confronto tra tuple

Confronti prima per cognome e poi per nome:

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"]

Ordinare senza Comparable

Può sempre ordinare con una closure finale anche se il tipo non è 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"]

Ordinamento decrescente

Inverta il confronto oppure chiami .reversed():

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 e sort

sorted() restituisce un nuovo array; sort() modifica l'array sul posto (è necessario usare var):

var nums = [3, 1, 2]
nums.sort()
print(nums)  // [1, 2, 3]
let copy = [3, 1, 2].sorted()
print(copy)  // [1, 2, 3]

Ordinamento stabile

L'ordinamento di Swift è stabile per contratto a partire da Swift 5: gli elementi uguali mantengono il loro ordine relativo. Può fare affidamento su questo comportamento per ottenere ordinamenti prevedibili in più passaggi:

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"

Ordinare in base a un key path

Può ordinare con una closure che legge qualsiasi proprietà senza rendere conforme l'intero tipo:

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"]

Verifica rapida

Quale singolo operatore deve implementare per conformarsi a Comparable?

Riepilogo

Ha imparato a usare Comparable:

  • Comparable fornisce gli operatori di ordinamento; implementi solo <
  • Abilita sorted(), min() e max() senza closure
  • Il confronto tra tuple semplifica l'ordinamento su più chiavi
  • sorted() restituisce un nuovo array; sort() lo modifica; l'ordinamento è stabile

Successivo: semantica dell'uguaglianza personalizzata.

Domande Frequenti

La lezione «Comparable e ordinamento» è gratuita?

Sì — il testo completo di «Comparable e ordinamento» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Comparable e ordinamento»?

Definisci l’ordinamento con < per eseguire il sorting. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Comparable e ordinamento»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Equatable sintetizzato
  2. Hashable e hash(into:)
  3. Comparable e ordinamento
  4. Semantica di uguaglianza personalizzata
← Torna a Swift Academy