Swift Academy · 课时

Comparable 与排序

Q: 「Comparable 与排序」课时是免费的吗？

是的 — 「Comparable 与排序」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Swift Academy 课程的其余内容，请升级到 CoddyKit PRO。 Swift Academy 课程共包含 4 节课。

Q: 「Comparable 与排序」这节课中我会学到什么？

使用 < 定义排序顺序。 你通过在浏览器中直接运行的动手代码来练习 Swift Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

Q: 学习 Swift Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Swift Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。

Q: 「Comparable 与排序」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

Q: 我能在这节 Swift Academy 课中编写并运行代码吗？

能。每节 Swift Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

使用 < 定义排序顺序。

Comparable 与排序 是 CoddyKit 上的免费 Swift Academy 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Swift Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Swift Academy 课程共包含 4 节课。

什么是可比较协议

Comparable 为类型提供排序运算符：<、<=、>、>=。遵循该协议后，您可以直接调用 sorted()、min() 和 max()。

通过 < 遵循协议

您只需实现 <，其余运算符会自动生成。（同时也必须遵循 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

对可比较类型排序

遵循 Comparable 后，sorted() 无需闭包：

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 和 max

Comparable 还支持聚合辅助方法：

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

多关键字排序

要根据多个字段逐层打破平局，请在 < 中按优先级使用元组进行比较，Swift 会按字典序比较元组。

元组比较技巧

先按姓氏排序，再按名字排序：

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

不使用 Comparable 进行排序

即使类型不遵循 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"]

降序排序

反转比较结果，或调用 .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 与 sort

sorted() 返回一个新数组；sort() 原地修改数组（需要使用 var）：

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

足够稳定的排序

从 Swift 5 起，Swift 排序保证稳定：相等元素会保持其相对顺序。您可以依赖这一点来实现可预测的多轮排序：

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"

按键路径排序

您可以使用读取任意属性的闭包进行排序，而不必让整个类型遵循 Comparable：

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

快速检查

要遵循 Comparable，必须实现哪一个运算符？

总结

您学习了可比较协议：

Comparable 提供排序运算符；只需实现 <
无需闭包即可使用 sorted()、min() 和 max()
通过元组比较可以轻松实现多关键字排序
sorted() 返回新数组；sort() 原地修改数组；排序是稳定的

接下来：自定义相等语义。

常见问题解答