0Pricing
Swift Academy · Aula

Comparable e Ordenação

Defina a ordenação com < para classificar.

Comparable e Ordenação é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O que é Comparable?

Comparable fornece operadores de ordenação a um tipo: <, <=, >, >=. A conformidade permite chamar diretamente sorted(), min() e max().

Conformidade com <

Você só implementa <; os demais operadores são derivados. (Equatable também é obrigatório.)

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

Ordenando um tipo Comparable

Com Comparable, sorted() não precisa de uma 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 gratuitamente

Comparable também habilita funções auxiliares de agregação:

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

Ordenação por várias chaves

Para desempatar usando vários campos, compare-os na ordem de prioridade dentro de < usando tuplas — o Swift compara tuplas lexicograficamente.

Truque de comparação de tuplas

Compare pelo sobrenome e depois pelo primeiro 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"]

Ordenando sem Comparable

Você sempre pode ordenar com uma closure final, mesmo que o tipo não seja 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"]

Ordenação decrescente

Inverta a comparação ou chame .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 versus sort

sorted() retorna uma nova matriz; sort() modifica a matriz no próprio lugar (exige uma variável declarada com var):

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

Ordenação suficientemente estável

A ordenação do Swift tem estabilidade garantida desde o Swift 5: elementos iguais mantêm sua ordem relativa. Você pode depender disso para obter ordenações previsíveis em várias passagens:

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"

Ordenando por um caminho de chave

Você pode ordenar com uma closure que lê qualquer propriedade sem tornar o tipo inteiro conforme:

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ção rápida

Qual é o único operador que você deve implementar para estar em conformidade com Comparable?

Recapitulação

Você aprendeu sobre Comparable:

  • Comparable fornece operadores de ordenação; implemente apenas <
  • Habilita sorted(), min() e max() sem uma closure
  • A comparação de tuplas facilita a ordenação por várias chaves
  • sorted() retorna uma nova matriz; sort() modifica a matriz; a ordenação é estável

Próximo tópico: semântica de igualdade personalizada.

Perguntas Frequentes

A aula “Comparable e Ordenação” é grátis?

Sim — o texto completo de “Comparable e Ordenação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Comparable e Ordenação”?

Defina a ordenação com < para classificar. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Comparable e Ordenação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Equatable Sintetizado
  2. Hashable e hash(into:)
  3. Comparable e Ordenação
  4. Semântica de Igualdade Personalizada
← Voltar para Swift Academy