0Pricing
Swift Academy · Урок

Comparable и сортировка

Задавайте порядок с помощью < для сортировки.

«Comparable и сортировка» — бесплатный урок Swift Academy на CoddyKit. Это урок 3 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения 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

Сортировка сопоставимого типа

При поддержке сопоставимости для 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 без дополнительных усилий

Сопоставимость также открывает доступ к вспомогательным функциям для агрегирования:

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

Сортировка без сопоставимости

Вы всегда можете отсортировать значения с помощью замыкания в конце, даже если тип не поддерживает сопоставимость:

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 гарантированно стабильна начиная со Swift 5: равные элементы сохраняют относительный порядок. Это можно использовать для предсказуемой многоэтапной сортировки:

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"

Сортировка по пути к свойству

Можно сортировать с помощью замыкания, которое читает любое свойство, не добавляя соответствие всему типу:

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:

  • Comparable предоставляет операторы упорядочивания; реализовать нужно только <
  • Позволяет использовать sorted(), min() и max() без замыкания
  • Сравнение кортежей упрощает упорядочивание по нескольким ключам
  • sorted() возвращает новый массив, sort() изменяет массив, а сортировка является стабильной

Далее: пользовательская семантика равенства.

Часто задаваемые вопросы

Урок «Comparable и сортировка» бесплатный?

Да — полный текст урока «Comparable и сортировка» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Swift Academy, подпишись на CoddyKit PRO. Курс Swift Academy содержит 4 уроков всего.

Чему я научусь в уроке «Comparable и сортировка»?

Задавайте порядок с помощью < для сортировки. Ты практикуешь Swift Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Swift Academy?

Предыдущий опыт не требуется. Swift Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 3 из 4.

Сколько времени занимает урок «Comparable и сортировка»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Swift Academy?

Да. Каждый урок Swift Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Синтезированный Equatable
  2. Hashable и hash(into:)
  3. Comparable и сортировка
  4. Пользовательская семантика равенства
← Назад к Swift Academy