Question

我有两个数组，它们有两个不同的对象，都包含一个ID字段。我需要做的是在表视图控制器中按顺序显示它们。它们共享相同的基本信息，大小和ID，除了它们的对象类型之外，它们是显示的唯一数据。当用户选择一个单元格时，它会移动到一个新视图，显示该对象的更精细细节。

现在，我在表中有两个部分，一个用于TypeA，另一个用于TypeB。他们对各自列表中的所有项目进行排序，但在项目制作时出现故障。所以它看起来像：

TypeA
  ID 1
  ID 2
  ID 5
  ID 6
TypeB
  ID 3
  ID 4
  ID 7

我需要的是将它们全部分为1个部分，并在选中时打开详细视图。

思想

我可以将它们全部放入AnyObject字典中，当查看单个项目时，确定它们是一种对象类型还是另一种。我觉得这样可行，但我怎样才能正确排序呢？

Answer 1

你可以这样做：

class TypeA {
    var ID: Int

    init(_ id: Int) {
        self.ID = id
    }
}

class TypeB {
    var ID: Int

    init(_ id: Int) {
        self.ID = id
    }
}

struct Wrap {
    var ID: Int {
        return a?.ID ?? b?.ID ?? 0
    }
    let a: TypeA?
    let b: TypeB?
}

var arrayA = [TypeA(1), TypeA(3), TypeA(5)]
var arrayB = [TypeB(2), TypeB(4)]

let sortedArray = (arrayA.map { Wrap(a: $0, b: nil) } + arrayB.map { Wrap(a: nil, b: $0)})
                      .sort { $0.ID < $1.ID }

选择行时，您可以使用以下内容确定对象：

if let a = sortedArray[index].a {
    // TypeA row selected
} else if let b = sortedArray[index].b {
    // TypeB row selected
}

Answer 2

将所有常见属性放入协议中，构建并排序该常用协议的数组：

protocol HasID {
    var id: Int { get }
}

class TypeA : HasID, CustomStringConvertible {
    var id: Int

    init(_ id: Int) {
        self.id = id
    }

    var description : String {
        return ("TypeA(\(self.id))")
    }
}

class TypeB : HasID, CustomStringConvertible {
    var id: Int

    init(_ id: Int) {
        self.id = id
    }

    var description : String {
        return ("TypeB(\(self.id))")
    }
}

let typeA = [TypeA(1), TypeA(2), TypeA(5), TypeA(6)]
let typeB = [TypeB(3), TypeB(4), TypeB(7)]
let result = (typeA.map { $0 as HasID } + typeB.map { $0 as HasID })
                .sort { $0.id < $1.id }

print(result)

Answer 3

如果你不想用TypeA协议加载TypeB和HasID类，那么你可以在视图控制器中定义这些类的扩展名，以此来回答Zoff Dino：

class TypeA {
    var ID: Int

    init(_ id: Int) {
        self.ID = id
    }
}

class TypeB {
    var ID: Int

    init(_ id: Int) {
        self.ID = id
    }
}

protocol HasID {
    var ID: Int { get }
}

// place this in your view controller

extension TypeA: HasID {
}

extension TypeB: HasID {
}

var arrayA = [TypeA(1), TypeA(3), TypeA(5)]
var arrayB = [TypeB(2), TypeB(4)]

let sortedArray = (arrayA.map { $0 as HasID } + arrayB.map { $0 as HasID })
                      .sort { $0.ID < $1.ID }

将两个不同类型的数组排序为一个

3 个答案: