给定两个数组，一个是旧值集，另一个是新值集，我想找到这两个数组的“差异”，这样对原始数组的更新可以表示为:

enum CollectionChange<T: SequenceType> {
    case Initial(T)
    case Update(T, deletions: [Int], insertions: [Int], modifications: [Int]) 
}

我正在尝试构建一个更简单的 this 版本其中更改对象是基于对象相等性构建的，而不是像 RAC-MutableCollectionProperty 那样的索引(代码是 here，这可能是我在一段时间；没有文档也无济于事)。

对于这个项目来说同样重要的是能够以任何粒度级别观察数组的变化。例如，将 T 限制为 Equatable 的一维数组是一个相对简单的用例。您可以像 RAC-MutableCollectionProperty 一样构建某种描述更改的表，检查对象是否相等。然而，一旦你开始使用二维数组并且更深入，它就会变得有点棘手，因为你不仅必须在最低级别区分元素，而且还要描述部分级别的删除。实际上，实际上只需要 2D 阵列，但最好有一个无论阵列深度如何都能工作的解决方案。我不一定要寻找解决方案(尽管那会很棒)，实际上只是关于如何解决此问题的任何指示和高级解决方案。

我想到的观察多个数组级别的一种方法是编写一个适用于一维数组的差异函数并构造一个属性，以便:

let property: MutableCollectionProperty<MutableCollectionProperty<Int>>

属性将检查其泛型类型是否属于它自己的类型。我必须将更改描述更改为更接近

enum Changes<T> {
    case Initial(T)
    case Update(T, deletions: [NSIndexPath], insertions: [NSIndexPath], modifications: [NSIndexPath])
}

或者类似的东西

enum Changes<T> {
    case Initial(T)
    case UpdateSections(sections: [T], deletions:[Int], insertions: [Int], modifications: [Int])
    case UpdateIndexes(T, deletions: [Int], insertions: [Int], modifications: [Int])
}

虽然这些只是我的初步想法，但我愿意接受任何解决方案或建议。

赏金编辑:

赏金将奖励给能够提供给定以下参数的解决方案的人:

• 设 x 和 y 为两个 swift 数组
• T 类型的两个数组:Equatable
• 两个数组都可以是任意深度
• x 的深度 == y 的深度

可以生成变更集，其中变更集描述:

• 哪些元素已从 x 中删除 到 y(按索引)
• 哪些元素已被插入到 y 中 不在 x 中(按索引)
• 从 x 开始移动了哪些元素 到 y(按索引)

更改只需在数组的最低级别进行描述(无需担心更高级别的插入和删除，尽管您真的以此获得 300 代表)但更改索引必须指示嵌套索引路径。

例如，如果数组是一个 3d 数组，并且 array[0][5][2] 处的一个对象被删除，则由此产生的索引更改应该是一个数组 [0 , 5, 2]。该数组描述了一次删除，所有删除都是 [[Int]] 类型。

编辑:

我正在删除阵列具有任何深度的要求。假设它们只是一维数组。

最佳答案

我不确定这是否满足您的所有赏金要求，但我会发布一些用于计算数组差异的代码:

func arrayInsertionDeletionAndNoopIndexes<T: Equatable>(objects: [T], originalObjects: [T]) -> ([Int], [Int], [Int]) {
    let insertions = objects.filter({ !originalObjects.contains($0) }).map({ objects.index(of: $0)! })
    let noops = originalObjects.filter({ objects.contains($0) }).map({ originalObjects.index(of: $0)! })
    let deletions = originalObjects.filter({ !objects.contains($0) }).map({ originalObjects.index(of: $0)! })

    return (insertions, deletions, noops)
}

func arrayInsertionDeletionAndNoopIndexPaths<T: Equatable>(objects: [T], originalObjects: [T], section: Int = 0) -> ([IndexPath], [IndexPath], [IndexPath]) {
    let (insertions, deletions, noops) = arrayInsertionDeletionAndNoopIndexes(objects: objects, originalObjects: originalObjects)

    let insertionIndexPaths = insertions.map({ IndexPath(row: $0, section: section) })
    let deletionIndexPaths = deletions.map({ IndexPath(row: $0, section: section) })
    let noopIndexPaths = noops.map({ IndexPath(row: $0, section: section) })

    return (insertionIndexPaths, deletionIndexPaths, noopIndexPaths)
}

我的具体用例是计算差异以更新 UITableView，为此我还有以下内容:

extension UITableView {

    func insertAndDeleteCellsForObjects<T: Equatable>(objects: [T], originalObjects: [T], section: Int = 0) {
        let (insertions, deletions, _) = arrayInsertionDeletionAndNoopIndexPaths(objects: objects, originalObjects: originalObjects, section: section)

        if insertions.count > 0 || deletions.count > 0 {
            beginUpdates()
            insertRows(at: insertions, with: .automatic)
            deleteRows(at: deletions, with: .automatic)
            endUpdates()
        }
    }

}

关于ios - Swift 数组差异，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36975864/