0Pricing
Swift Academy · Lección

Comparable y ordenación

Defina el orden con < para ordenar.

Comparable y ordenación es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué es Comparable?

Comparable proporciona a un tipo operadores de ordenación: <, <=, >, >=. Adoptarlo permite llamar directamente a sorted(), min() y max().

Conformidad con <

Solo debe implementar <; el resto se deriva automáticamente. (También se requiere 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

Ordenar un tipo Comparable

Con Comparable, sorted() no necesita ninguna clausura:

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 y max sin esfuerzo

Comparable también habilita funciones auxiliares de agregación:

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

Ordenación por varias claves

Para resolver empates entre varios campos, compárelos dentro de < en orden de prioridad mediante tuplas; Swift compara las tuplas lexicográficamente.

Truco para comparar tuplas

Compare por apellido y después por nombre:

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

Ordenar sin Comparable

Siempre puede ordenar con una clausura final aunque el tipo no sea 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"]

Ordenación descendente

Invierta la comparación o llame a .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 frente a sort

sorted() devuelve un array nuevo; sort() modifica el array en el mismo lugar (necesita una variable declarada con var):

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

Ordenación suficientemente estable

La ordenación de Swift es estable desde Swift 5: los elementos iguales conservan su orden relativo. Puede confiar en ello para obtener ordenaciones predecibles en varias pasadas:

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"

Ordenar mediante una ruta de clave

Puede ordenar con una clausura que lea cualquier propiedad sin hacer que todo el tipo adopte un protocolo:

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

Comprobación rápida

¿Qué único operador debe implementar para adoptar Comparable?

Resumen

Ha aprendido Comparable:

  • Comparable proporciona operadores de ordenación; solo debe implementar <
  • Habilita sorted(), min() y max() sin una clausura
  • La comparación de tuplas facilita la ordenación por varias claves
  • sorted() devuelve uno nuevo; sort() modifica el original; la ordenación es estable

Siguiente: semántica de igualdad personalizada.

Preguntas frecuentes

¿La lección «Comparable y ordenación» es gratis?

Sí — el texto completo de «Comparable y ordenación» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Comparable y ordenación»?

Defina el orden con < para ordenar. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Comparable y ordenación»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Equatable sintetizado
  2. Hashable y hash(into:)
  3. Comparable y ordenación
  4. Semántica de igualdad personalizada
← Volver a Swift Academy