Swift：如何检查泛型类型的对象是否是类型的子类型的数组

Question

我正在处理一个涉及 Alamofire、ObjectMapper 和 RealmSwift 的 Swift 项目，遇到了一种情况，我必须检查泛型类型的对象是否是 Realm 的 Objects 数组。

我的问题是：如何检查泛型类型的对象是否是 Swift 中某个类型的子类型的数组？

冗长的版本：我为我的问题做了一个最小的工作示例。请看我的gist here。 您可以将其复制到 Xcode Playground 并查看第 31 行运行而第 35 行没有运行。

我能够通过更改第 70 和 71 行使其工作

来自

if let array = data as? [Object] {
  add(array)
}

到

if let array = data as? NSArray where array.count > 0 && array[0] is Object {
  add(array as! [Object])
}

但该解决方案甚至还不够完美，因为它必须涉及Foundation。我更喜欢“纯”Swift。

<script src="https://gist.github.com/T-Pham/44fe5b7c3a669db34d856b54e15f278a.js"></script>

已删除：简短版本并不能完全代表实际问题。

短版：

protocol Protocol {
  init()
}

class Parent {}
final class Child1: Parent, Protocol {}
final class Child2: Parent, Protocol {}

func foo<T: Protocol>(array: [T]) {
  if array is [Parent] { // This won't compile
  }
}

foo([Child1(), Child1()])

Answer 1

在 Swift 类型系统中，[Child] 和 [Parent] 不相等，因为 Swift 的泛型不支持协变。您可以将重载与泛型类型约束一起使用，而不是子类型多态性和动态类型转换。

首先，创建三个与myRequest〜 方法相同的handleResponse() 方法的重载：

func handleResponse(alamofireReponse: AlamofireReponse<AnyObject, NSError>, completionHandler: (MyResponse<AnyObject> -> Void)) {
    switch alamofireReponse {
    case .Success(let data):
        completionHandler(.Success(data))
    case .Failure(let error):
        completionHandler(.Failure(error))
    }
}

func handleResponse<T: Mappable where T: Object>(alamofireReponse: AlamofireReponse<T, NSError>, completionHandler: (MyResponse<T> -> Void)) {
    switch alamofireReponse {
    case .Success(let data):
        add(data)
        completionHandler(.Success(data))
    case .Failure(let error):
        completionHandler(.Failure(error))
    }
}

func handleResponse<T: Mappable where T: Object>(alamofireReponse: AlamofireReponse<[T], NSError>, completionHandler: (MyResponse<[T]> -> Void)) {
    switch alamofireReponse {
    case .Success(let data):
        add(data)
        completionHandler(.Success(data))
    case .Failure(let error):
        completionHandler(.Failure(error))
    }
}

然后，更改myRequest〜 方法的类型约束以满足每个handleResponse 方法的约束。

func myRequestObject<T: Mappable where T: Object>(completionHandler: (MyResponse<T> -> Void)) {
    responseObject { alamofireReponse in
        handleResponse(alamofireReponse, completionHandler: completionHandler)
    }
}

func myRequestArray<T: Mappable where T: Object>(completionHandler: (MyResponse<[T]> -> Void)) {
    responseArray { alamofireReponse in
        handleResponse(alamofireReponse, completionHandler: completionHandler)
    }
}

通过这样做，handleResponse () 方法和add () 方法将在编译时根据参数的类型分派给适当的方法。您不需要动态检查类型。

整个代码如下，以防万一：

import Foundation

// Alamofire
enum AlamofireReponse<T, E> {
    case Success(T)
    case Failure(E)
}

func responseJSON(alamofireReponse: AlamofireReponse<AnyObject, NSError> -> Void) {
    alamofireReponse(.Success([["type": "not_object"], ["type": "not_object"]]))
}

// ObjectMapper
protocol Mappable {
    init()
}

// AlamofireObjectMapper
func responseObject<T: Mappable>(alamofireReponse: AlamofireReponse<T, NSError> -> Void) {
    alamofireReponse(.Success(T()))
}

func responseArray<T: Mappable>(alamofireReponse: AlamofireReponse<[T], NSError> -> Void) {
    alamofireReponse(.Success([T(), T()]))
}

// RealmSwift
class Object {}

func add(object: Object) {
    print("adding single object works") // This line would run
}

func add<T: SequenceType where T.Generator.Element: Object>(objects: T) {
    print("adding multiple objects works")  // This line would not
}

// My code
final class Post: Object, Mappable {}
final class Comment: Object, Mappable {}

enum MyResponse<T> {
    case Success(T)
    case Failure(NSError)
}

func myRequestJSON(completionHandler: (MyResponse<AnyObject> -> Void)) {
    responseJSON { alamofireReponse in
        handleResponse(alamofireReponse, completionHandler: completionHandler)
    }
}

func myRequestObject<T: Mappable where T: Object>(completionHandler: (MyResponse<T> -> Void)) {
    responseObject { alamofireReponse in
        handleResponse(alamofireReponse, completionHandler: completionHandler)
    }
}

func myRequestArray<T: Mappable where T: Object>(completionHandler: (MyResponse<[T]> -> Void)) {
    responseArray { alamofireReponse in
        handleResponse(alamofireReponse, completionHandler: completionHandler)
    }
}

func handleResponse(alamofireReponse: AlamofireReponse<AnyObject, NSError>, completionHandler: (MyResponse<AnyObject> -> Void)) {
    switch alamofireReponse {
    case .Success(let data):
        completionHandler(.Success(data))
    case .Failure(let error):
        completionHandler(.Failure(error))
    }
}

func handleResponse<T: Mappable where T: Object>(alamofireReponse: AlamofireReponse<T, NSError>, completionHandler: (MyResponse<T> -> Void)) {
    switch alamofireReponse {
    case .Success(let data):
        add(data)
        completionHandler(.Success(data))
    case .Failure(let error):
        completionHandler(.Failure(error))
    }
}

func handleResponse<T: Mappable where T: Object>(alamofireReponse: AlamofireReponse<[T], NSError>, completionHandler: (MyResponse<[T]> -> Void)) {
    switch alamofireReponse {
    case .Success(let data):
        add(data)
        completionHandler(.Success(data))
    case .Failure(let error):
        completionHandler(.Failure(error))
    }
}

// Usage
myRequestJSON { response in
}

myRequestObject { (response: MyResponse<Post>) in
}

myRequestArray { (response: MyResponse<[Post]>) in
}