如何检查“Any”类型的对象是实现某些协议的具体类的数组

Question

我遇到了一个问题。 考虑我有一个协议和两个实现它的类：

protocol Initiatable{
    init()
}

class A: Initiatable{
    required init() {}
}

class B: Initiatable{
    required init() {}
}

然后在某个时候我正在创建一个数组并将其传递给函数：

var array = [A]()

func update(object: Any){

}

update(object: array)

从那个函数update 如果它满足另一个函数的条件，我想将object 传递给另一个函数：

func process<T: Initiatable>(array: T){
    /* ... */
}

那么如何检查Any 类型的对象是实现Initiatable 协议的具体类的数组？我想写一些类似的东西

func update(object: Any){
    if let array = object as Array<T: Initiatable>{
        process(array: array)
    }
}

但那是行不通的。代码如下：

func update(object: Any){
    if let array = object as [Initiatable]{
        process(array: array)
    }
}

func process(array: [Initiatable]){ }

编译得很好，但这不是我想要的——process 函数应该接收Initiatable 的具体实现数组，所以在某些时候它可以使用：

func process<T: Initiatable>(array: [T]){
    /* other code */
    T.init()
}

那么有没有办法做到这一点？非常感谢您！

Answer 1

这个问题有几个部分：

生成类型数组

您的数组声明需要A objects 的数组，而不是A types。要生成 A 类型的数组，可以传入 Postfix self 表达式：(link)

var array = [ A.self ]

这会将array 定义为A.Type 的数组，称为元类型类型(same link)。

您还可以使用此元类型类型生成一个空数组：

var array:[A.Type] = []

如果您想要一个同时包含 A.self 和 B.self 的数组，您可以将其指定为 [Any]...

var array:[Any] = [A.self,B.self]

...或者，使用您创建的Initiatable 协议：

var array:[Initiatable.Type] = [A.self,B.self]

在更新方法中将数组向下转换为类型数组

您在将 Any 对象向下转换为类型数组时遇到了问题。 这是我更新的update 方法：

func update(object: Any){
  if let array = object as? [Initiatable.Type] {    //1
    process(array: array)
  }
}

1. 您现在可以对通过update 方法的数组执行可选的向下转换。将其向下转换为 Initiatable 的元数据类型数组：（这是我从您的方法中修改的唯一行）

在处理方法中接收一个类型作为参数

我假设您只希望您的流程方法接收一个类型数组，并根据其中一种类型实例化一个变量。您没有提到数组中的哪个元素，所以我只使用了第一个。

func process(array: [Initiatable.Type]){    //1
  if let firstType = array.first {          //2
    let firstObject = firstType.init()      //3
  }
}

1. process 方法可以接收采用 Initiatable 协议的类型数组。
2. 我正在使用可选绑定来获取数组中第一个元素的值。这应该是一种类型。
3. 根据数组中的第一个元素实例化一个对象。

Answer 2

如果你的数组是非空的，那么你可以通过从数组中获取一个元素的运行时类型来解决这个问题：

func update(object: Any){
    if let array = object as? [Initiatable]{
        process(array: array)
    } else {
        // Not initiatable
    }
}

func process(array: [Initiatable]) {  // no need for generics here
    guard let first = array.first else {
        // Unable to determine array type
        // throw or return or whatever
    }

    // type(of: first) gives A or B
    type(of: first).init()
}

如果数组为空，那么我不知道如何在 Swift 中执行此操作（无论如何，从 Swift 3 开始）。

• object 的静态类型为Any，因此您需要使用object 的runtime 类型才能到达任何地方。
• 但是，Swift（以及大多数具有泛型的语言）仅根据您传递的值的 静态 类型解析类型参数，如 T。因此，您使用process<T: Initiatable>(array: [T]) 的整个方法是死路一条：T 只能采用编译器已经知道的类型，当您调用process() 时。
• Swift 确实允许您访问运行时类型：type(of: object) 将返回（例如）Array<A>。很近！但：
  • AFAIK，目前无法从元类型中提取类型参数，即从 Array<A> 获取 A，除非编译器已经静态知道类型参数。
  • 您可以获取字符串"Array<A>" 并从中提取字符串A，但是AFAIK 没有办法将字符串映射回Swift 中的类型，除非该类型是Objective-C类。

简而言之，我认为你刚刚达到了 Swift 元类型/反射能力的极限。

Answer 3

不幸的是，在给定的约束条件下，我想不出解决方案。看起来您正在尝试在运行时实现编译时多态性。

使用泛型意味着编译器了解将调用哪个类。但是使用Any 意味着在编译时它可以是任何东西，并且只有在运行时才知道。

我能提出的最接近的解决方案是：

// Either use generic `update` function
func updateGeneric<T: Initiatable>(array: Array<T>){
    process(array: array)
}

// or explicitly convert `Any` to the class, 
// so compiler understands what implementation of `process` to call
func updateExplicit(object: Any) {

    if let array = object as? [A] {
        process(array: array)
    }

    if let array = object as? [B] {
        process(array: array)
    }
}

Answer 4

这对你有帮助吗，

protocol Initiatable{
    init()
}

class A: Initiatable{
    required init() {}
}

class B: Initiatable{
    required init() {}
}

class Test<T : Initiatable>
{

    func update(object: Any){
        if let array = object as? [T]{
            process(array: array)
        }
    }

    func process(array: [T]){

    }
}

Answer 5

我找到了解决这个问题的方法：

func classTypeFrom(_ className: String) -> AnyClass!{
    if  let appName = Bundle.main.object(forInfoDictionaryKey: "CFBundleName") as? String {
        let classStringName = "_TtC\(appName.characters.count)\(appName)\(className.characters.count)\(className)"
        return NSClassFromString(classStringName)
    }
    return nil;
}

func update(object: Any){
    if let array = object as? [Initiatable]{
        let arrayTypeName = "\(type(of: ar))"
        let objectTypeName = arrayTypeName.substringFrom(index: 6, length: arrayTypeName.characters.count - 7)
        if let arrayType = classTypeFrom(objectTypeName) as? Initiatable.Type{
            process(array: array, type: arrayType)
        }
    }
}

func process(array: [Initiatable], type: Initiatable.Type){
    var ar = array
    let newObj = type.init()
    ar.append(newObj)
}