我正在实现一个名为ofType的函数,它过滤掉给定类型的所有元素.
这是我的代码：
class Animal {}
class Mammal: Animal {}
class Monkey: Mammal {}
class Pig: Mammal {}
class Human: Mammal {}
extension Array {
func ofType<T>(_ Metatype: T.Type) -> [T] {
return flatMap { type(of: $0) == Metatype ? $0 as? T : nil }
// return flatMap { $0 as? T } // This is not working as the T is always the static type of the parameter,which is Animal in this example.
// return flatMap { $0 as? Metatype } // This is not working either because of the grammar restriction.
}
}
let animals = [Monkey(),Pig(),Human(),Mammal(),Animal()]
func animalType() -> Animal.Type {
return Mammal.self
}
animals.ofType(animalType()).count // returns 1,expect to be 4.
在Objc中,我可以使用isKindOf()来检查对象是类的实例还是子类.在swift和as中有类似的操作,但是它们之后的类型应该是静态类型,而不是动态类型值(例如我可以写的是Mammal,但不是Mammal.self).
我不能使用类型参数T,因为在这个例子中,T等于Animal,这不是我想要的.
你对如何实现这个功能有任何想法吗？
就个人而言,我认为
@JeremyP’s suggestion使用Mirror是最好的;虽然我会做一些调整：
/// Conditionally cast `x` to a given dynamic Metatype value,taking into consideration
/// class inheritance hierarchies.
func conditionallyCast<T,U>(_ x: T,to destType: U.Type) -> U? {
if type(of: x) is AnyClass && destType is AnyClass { // class-to-class
let isCastable = sequence(
first: Mirror(reflecting: x),next: { $0.superclassMirror }
)
.contains { $0.subjectType == destType }
return isCastable ? (x as! U) : nil
}
// otherwise fall back to as?
return x as? U
}
在这里,我们使用sequence(first:next:)从动态类型的x创建一个元类型序列,通过它可能具有的任何超类元类型(可能是第一次使用我看过的看起来不太糟糕的函数：P).另外,我们又回到了做什么？当我们知道我们没有进行类到类的转换时,它会使该函数也能使用协议元类型.
然后你可以简单地说：
extension Sequence {
func ofType<T>(_ Metatype: T.Type) -> [T] {
return flatMap { conditionallyCast($0,to: Metatype) }
}
}
protocol P {}
class Animal {}
class Mammal: Animal {}
class Monkey: Mammal,P {}
class Pig: Mammal {}
class Human: Mammal,P {}
let animals = [Monkey(),Animal()]
let animalType: Animal.Type = Mammal.self
print(animals.ofType(animalType)) // [Monkey,Pig,Human,Mammal]
print(animals.ofType(P.self)) // [Monkey,Human]
假设您在Apple平台上(即可以访问Objective-C运行时),另一个选择是使用Objective-C元类方法isSubclass(of:)来检查给定的元类型是否相等,或者是否为子类另一个：
import Foundation
/// Conditionally cast `x` to a given dynamic Metatype value,to destType: U.Type) -> U? {
let sourceType = type(of: x)
if let sourceType = sourceType as? AnyClass,let destType = destType as? AnyClass { // class-to-class
return sourceType.isSubclass(of: destType) ? (x as! U) : nil
}
// otherwise fall back to as?
return x as? U
}
这是有效的,因为在Apple平台上,Swift类构建在Obj-C类之上 – 因此Swift类的元类型是Obj-C元类对象.