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

Question

直到现在（Swift 2.2）我一直很高兴地使用这个答案中的代码——它很迅速，很优雅，它像梦一样工作。

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 改变了一切。

使用代码迁移工具和提案 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 的早期阶段，所以根本没有文档。

作为一种解决方法，我已经从我的代码中删除了 sort（以前是 sort-in-place）函数，并将其替换为

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

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

Answer 1

比较 Swift 2.2 中可用的方法：

使用 Swift 3 中的方法：

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

这就是为什么您的函数无法编译的原因。

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

Answer 2

让 sortedArray = users.sorted { $0.name < $1.name }

Answer 3

在Swift 3.0中

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

Answer 4

使用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
        }
    }
}