Swift 3：按排序描述符对数组进行排序（以前就地排序）

Question

直到现在（Swift 2.2）我一直在愉快地使用来自this answer 的代码——它很迅速，很优雅，它像梦一样工作。

extension MutableCollectionType where Index : RandomAccessIndexType, Generator.Element : AnyObject {
    /// Sort `self` in-place using criteria stored in a NSSortDescriptors array
    public mutating func sortInPlace(sortDescriptors theSortDescs: [NSSortDescriptor]) {
        sortInPlace {
            for sortDesc in theSortDescs {
                switch sortDesc.compareObject($0, toObject: $1) {
                case .OrderedAscending: return true
                case .OrderedDescending: return false
                case .OrderedSame: continue
                }
            }
            return false
        }
    }
}

extension SequenceType where Generator.Element : AnyObject {
    /// Return an `Array` containing the sorted elements of `source`
    /// using criteria stored in a NSSortDescriptors array.
    @warn_unused_result
    public func sort(sortDescriptors theSortDescs: [NSSortDescriptor]) -> [Self.Generator.Element] {
        return sort {
            for sortDesc in theSortDescs {
                switch sortDesc.compareObject($0, toObject: $1) {
                case .OrderedAscending: return true
                case .OrderedDescending: return false
                case .OrderedSame: continue
                }
            }
            return false
        }
    }
}

Swift 3 改变了一切。

使用代码迁移工具和Proposal SE- 0006 - sort() => sorted(), sortInPlace() => sort() - 我已经做到了

extension MutableCollection where Index : Strideable, Iterator.Element : AnyObject {
    /// Sort `self` in-place using criteria stored in a NSSortDescriptors array
    public mutating func sort(sortDescriptors theSortDescs: [SortDescriptor]) {
        sort {
            for sortDesc in theSortDescs {
                switch sortDesc.compare($0, to: $1) {
                case .orderedAscending: return true
                case .orderedDescending: return false
                case .orderedSame: continue
                }
            }
            return false
        }
    }
}

extension Sequence where Iterator.Element : AnyObject {
    /// Return an `Array` containing the sorted elements of `source`
    /// using criteria stored in a NSSortDescriptors array.

    public func sorted(sortDescriptors theSortDescs: [SortDescriptor]) -> [Self.Iterator.Element] {
        return sorted {
            for sortDesc in theSortDescs {
                switch sortDesc.compare($0, to: $1) {
                case .orderedAscending: return true
                case .orderedDescending: return false
                case .orderedSame: continue
                }
            }
            return false
        }
    }
}

'sorted' 函数可以毫无问题地编译 [并且工作]。对于“排序”，我在“排序”行出现错误：“无法将类型'（_，_）-> _'的值转换为预期的参数类型'[SortDescriptor]'”，这让我完全困惑：我不明白编译器试图在哪里转换任何东西，因为我传入了一个 SortDescriptors 数组，它应该是一个 SortDescriptor 数组。

通常，这种类型的错误意味着您正在处理应该具有确定值的选项，但由于这是一个函数参数 - 并且在 func sorted 中似乎可以顺利工作 - 我可以从中读取是'有什么不对'。到目前为止，我不知道那是什么东西，而且由于我们处于 beta 的早期阶段，所以根本没有文档。

作为一种解决方法，我从我的代码中删除了排序（以前是就地排序）函数，并将其替换为

让 sortedArray = oldArray(sorted[...] oldArray = sortedArray

但如果我能恢复我的就地排序功能，我将不胜感激。

Answer 1

比较 Swift 2.2 中可用的方法：

使用 Swift 3 中的方法：

请注意，Swift 3 没有接受 isOrderedBefore 闭包的 sort 方法。

这就是你的函数无法编译的原因。

这看起来像一个错误，因此我在 bugreport.apple.com 上将其报告为错误 26857748。

Answer 2

让 sortedArray = users.sorted { $0.name

Answer 3

使用RandomAccessCollection协议

extension MutableCollection where Self : RandomAccessCollection {
    /// Sort `self` in-place using criteria stored in a NSSortDescriptors array
    public mutating func sort(sortDescriptors theSortDescs: [NSSortDescriptor]) {
        sort { by:
            for sortDesc in theSortDescs {
                switch sortDesc.compare($0, to: $1) {
                case .orderedAscending: return true
                case .orderedDescending: return false
                case .orderedSame: continue
                }
            }
            return false
        }
    }
}

Answer 4

在 Swift 3.0

let sortedCapitalArray = yourArray.sorted {($0 as AnyObject).localizedCaseInsensitiveCompare(($1 as AnyObject)as! String) == ComparisonResult.orderedAscending}