引言

在iOS开发中，数据排序是日常开发中高频使用的操作。无论是处理用户输入的字符串列表，还是对后端返回的模型对象数组进行排序展示，掌握高效的排序算法和实现技巧，都是开发者必备的技能。本文将围绕字符串数组排序和模型对象数组排序两大核心场景，详细解析iOS开发中的排序实现方法，并提供可复用的代码示例和优化建议。

一、字符串数组排序基础与进阶

1.1 基础排序方法：sorted与sort

在Swift中，对字符串数组进行排序最直接的方式是使用sorted()或sort()方法。两者区别在于：

• sorted()：返回排序后的新数组，原数组不变。
• sort()：直接修改原数组，无返回值。

let fruits = ["banana", "apple", "orange", "grape"]
// 方法1：sorted() 返回新数组
let sortedFruits = fruits.sorted()
print(sortedFruits) // ["apple", "banana", "grape", "orange"]
// 方法2：sort() 直接修改原数组
var mutableFruits = fruits
mutableFruits.sort()
print(mutableFruits) // ["apple", "banana", "grape", "orange"]

1.2 自定义排序规则：闭包实现

当默认的字典序排序不满足需求时，可通过闭包自定义排序规则。例如，按字符串长度排序：

let names = ["Alice", "Bob", "Charlie", "David"]
let sortedByNameLength = names.sorted { $0.count < $1.count }
print(sortedByNameLength) // ["Bob", "Alice", "David", "Charlie"]

闭包中的$0和$1分别代表数组中的两个元素，通过比较它们的count属性实现按长度排序。

1.3 本地化排序：处理特殊字符与大小写

在国际化应用中，需考虑不同语言的排序规则。例如，德语中的ä、ö、ü等字符需按特定规则排序。Swift通过localizedStandardCompare实现本地化排序：

let germanWords = ["äpfel", "apfel", "zebra", "über"]
let sortedGerman = germanWords.sorted {
    $0.localizedStandardCompare($1) == .orderedAscending
}
print(sortedGerman) // ["apfel", "äpfel", "über", "zebra"]

对于大小写不敏感的排序，可统一转换为小写后比较：

let mixedCase = ["Apple", "banana", "apricot", "Blueberry"]
let caseInsensitiveSort = mixedCase.sorted {
    $0.lowercased() < $1.lowercased()
}
print(caseInsensitiveSort) // ["Apple", "apricot", "banana", "Blueberry"]

二、模型对象数组排序：从基础到高级

2.1 模型对象排序基础：实现Comparable协议

对模型对象数组排序，需先让模型实现Comparable协议。例如，对Person模型按年龄排序：

struct Person: Comparable {
    let name: String
    let age: Int
    // 实现Comparable协议
    static func < (lhs: Person, rhs: Person) -> Bool {
        return lhs.age < rhs.age
    }
}
let people = [
    Person(name: "Alice", age: 25),
    Person(name: "Bob", age: 20),
    Person(name: "Charlie", age: 30)
]
let sortedByAge = people.sorted()
print(sortedByAge.map { $0.name }) // ["Bob", "Alice", "Charlie"]

2.2 多条件排序：优先级控制

当需按多个属性排序时（如先按年龄，再按姓名），可通过嵌套闭包实现：

let peopleMulti = [
    Person(name: "Alice", age: 25),
    Person(name: "Bob", age: 25),
    Person(name: "Charlie", age: 20)
]
let sortedMulti = peopleMulti.sorted {
    if $0.age == $1.age {
        return $0.name < $1.name // 年龄相同按姓名排序
    } else {
        return $0.age < $1.age // 否则按年龄排序
    }
}
print(sortedMulti.map { "\($0.name)-\($0.age)" }) 
// ["Charlie-20", "Alice-25", "Bob-25"]

2.3 动态排序：根据用户选择切换规则

在实际应用中，排序规则可能需根据用户选择动态切换。例如，表格视图中的列头点击排序：

enum SortOption {
    case byNameAscending
    case byNameDescending
    case byAgeAscending
    case byAgeDescending
}
func sortPeople(_ people: [Person], by option: SortOption) -> [Person] {
    switch option {
    case .byNameAscending:
        return people.sorted { $0.name < $1.name }
    case .byNameDescending:
        return people.sorted { $0.name > $1.name }
    case .byAgeAscending:
        return people.sorted { $0.age < $1.age }
    case .byAgeDescending:
        return people.sorted { $0.age > $1.age }
    }
}
let sortedByNameAsc = sortPeople(people, by: .byNameAscending)
print(sortedByNameAsc.map { $0.name }) // ["Alice", "Bob", "Charlie"]

三、性能优化与最佳实践

3.1 大数据量排序：避免阻塞主线程

对包含数万条数据的数组排序时，直接在主线程执行可能导致卡顿。建议使用DispatchQueue异步处理：

DispatchQueue.global(qos: .userInitiated).async {
    let largeArray = Array(repeating: "item", count: 100000).enumerated().map { "item\($0)" }
    let sortedLarge = largeArray.sorted()
    DispatchQueue.main.async {
        // 更新UI
    }
}

3.2 稳定性优化：使用stable sort

Swift的sorted()是稳定排序（相等元素的相对顺序不变），但在某些场景下（如分页加载），需手动维护稳定性。可通过添加原始索引辅助排序：

struct IndexedPerson {
    let index: Int
    let person: Person
}
let indexedPeople = people.enumerated().map { IndexedPerson(index: $0, person: $1) }
let stableSorted = indexedPeople.sorted {
    if $0.person.age == $1.person.age {
        return $0.index < $1.index // 年龄相同按原始顺序
    } else {
        return $0.person.age < $1.person.age
    }
}.map { $0.person }

3.3 第三方库选择：何时使用

对于复杂排序需求（如多语言混合排序、自定义权重），可考虑第三方库如SwiftSort或Algorithms。但多数情况下，原生方法已足够高效。

四、常见问题与解决方案

4.1 排序后数组为空？检查数据有效性

若排序后数组为空，可能是数据中包含nil值。对可选类型数组排序时，需先过滤或提供默认值：

let optionalStrings: [String?] = ["a", nil, "b"]
let nonNilStrings = optionalStrings.compactMap { $0 }
let sortedOptionals = nonNilStrings.sorted()
print(sortedOptionals) // ["a", "b"]

4.2 排序规则不符合预期？调试闭包逻辑

当排序结果不符合预期时，可通过打印闭包中的比较值调试：

let confusingSort = people.sorted {
    print("Comparing \($0.age) vs \($1.age)")
    return $0.age < $1.age
}

4.3 性能瓶颈？使用Instrument分析

通过Xcode的Instruments工具中的“Time Profiler”检测排序操作的CPU占用，定位耗时操作。

五、总结与实战建议

1. 字符串数组排序：优先使用sorted()/sort()，复杂需求通过闭包或localizedStandardCompare实现。
2. 模型对象排序：实现Comparable协议或通过闭包动态排序，多条件排序时注意优先级。
3. 性能优化：大数据量异步处理，稳定性需求时维护原始索引。
4. 调试技巧：打印比较值、使用Instruments分析性能。

实战案例：在电商应用中，对商品列表按价格升序、销量降序排序：

struct Product {
    let name: String
    let price: Double
    let sales: Int
}
let products = [
    Product(name: "A", price: 100, sales: 50),
    Product(name: "B", price: 80, sales: 30),
    Product(name: "C", price: 100, sales: 20)
]
let sortedProducts = products.sorted {
    if $0.price == $1.price {
        return $0.sales > $1.sales // 价格相同按销量降序
    } else {
        return $0.price < $1.price // 否则按价格升序
    }
}
print(sortedProducts.map { "\($0.name)-\($0.price)-\($0.sales)" })
// ["B-80.0-30", "A-100.0-50", "C-100.0-20"]

掌握字符串与模型对象数组的排序技巧，不仅能提升代码质量，更能优化用户体验。建议开发者在实际项目中多加练习，灵活运用本文介绍的方法。