seq.sorted()

// seq.sorted()
func sorted() -> [Self.Element]
  where Self.Element: Comparable

sorted()

// ⭐️ sort `Comparable` elements in ascending order (default).
let numbers: [Int] = [3, 2, 4, 1]
let sortedNumbers = numbers.sorted()

// ⭐️ in descending order.
numbers.sorted(by: >)

// ⭐️ make custom type conform to `Comparable`
extension TodoItem: Comparable {
    static func < (a: TodoItem, b: TodoItem) -> Bool {
        a.date < b.date
    }
}

todolist.sorted()

TodoItem

import Foundation  // Date

// todo item
struct TodoItem {
    let date: Date
    let item: String
}

// todo item samples
let todos = ["eat", "sleep", "play", "relax"]
let now = Date()
let nextyear = now.yearAfter

extension TodoItem {
    static let samples = (1...5).map{ _ in 
        TodoItem(
            date: .random(in: now...nextyear), 
            item: todos.randomElement()!
        )
    }
}

let todolist = TodoItem.samples

📘 手冊

• Swift ⟩ Collections ⟩ Sequence

  • .sorted() - sorted in ascending order, to sort in descending order, use: .sorted(by: >).

  • Array ⟩

    • sort() - sort in place.

    • sort(by:) - sort in place.

📗 參考

• Sundell ⟩ Sorting Swift collections ⭐️

👥 相關

• seq.sorted(by:)

Examples

sorted()

// custom type
enum Response {
    case ok
    case error(Int)
}

// ⭐️ make custom type conform to `Comparable`
extension Response: Comparable {
    // Q: a is before b ?
    static func < (a: Response, b: Response) -> Bool {
        switch (a, b) {
            
            // errors ordered by error codes (increasing)
            case let (.error(m), .error(n)): return m < n

            // successes are equivalent, none is before any other
            case (.ok, .ok): return false

            // error is before success
            case (.error, .ok): return true
            case (.ok, .error): return false
        }
    }
}

let responses: [Response] = [
    .error(500), .ok, .ok, .error(404), .error(403)
]

responses.sorted()
// [.error(403), .error(404), .error(500), .ok, .ok]

sort(by:)

enum Response {
    case ok
    case error(Int)
}

var responses: [Response] = [
    .error(500), .ok, .ok, .error(404), .error(403)
]

// ⭐️ sort in place
responses.sort {
    // Q: $0 is before $1 ?
    switch ($0, $1) {
        
        // error ordered by error code (increasing)
        case let (.error(m), .error(n)): return m < n

        // successes are equivalent, none is before any other
        case (.ok, .ok): return false

        // error is before success
        case (.error, .ok): return true
        case (.ok, .error): return false
    }
}