Swift 类内省和泛型

Question

我正在尝试使用泛型动态创建基于 class 实例的类型，但是在进行类自省时遇到了困难。

以下是问题：

• 是否有与 Obj-C 的 self.class 等效的 Swift 版本？
• 有没有办法使用来自NSClassFromString 的AnyClass 结果实例化一个类？
• 有没有办法从泛型参数T 中严格获取AnyClass 或其他类型信息？ （类似于 C# 的 typeof(T) 语法）

Answer 1

好吧，首先，[NSString class] 的 Swift 等效项是 .self（请参阅 Metatype docs，尽管它们很薄）。

事实上，NSString.class 甚至不起作用！你必须使用NSString.self。

let s = NSString.self
var str = s()
str = "asdf"

同样，我尝试了一个 swift 类...

class MyClass {

}

let MyClassRef = MyClass.self

// ERROR :(
let my_obj = MyClassRef()

嗯……错误说：

Playground 执行失败：错误：：16:1：错误：使用元类型值构造类类型“X”的对象需要一个“@required”初始化器

 Y().me()
 ^
 <REPL>:3:7: note: selected implicit initializer with type '()'
 class X {
       ^

我花了一段时间才弄清楚这意味着什么……结果它希望班级有一个@required init()

class X {
    func me() {
        println("asdf")
    }

    required init () {

    }
}

let Y = X.self

// prints "asdf"
Y().me()

一些文档将此称为.Type，但MyClass.Type 在操场上给了我一个错误。

Answer 2

这里是如何使用NSClassFromString。你必须知道你最终会得到什么的超类。这是一对知道如何为println 描述自己的超类-子类：

@objc(Zilk) class Zilk : NSObject {
    override var description : String {return "I am a Zilk"}
}

@objc(Zork) class Zork : Zilk {
    override var description : String {return "I am a Zork"}
}

注意使用特殊的@obj 语法来指示这些类的Objective-C munged 名称；这很关键，否则我们不知道指定每个类的 munged 字符串。

现在我们可以使用NSClassFromString 来创建 Zork 类或 Zilk 类，因为我们知道我们可以将其作为 NSObject 输入，并且以后不会崩溃：

let aClass = NSClassFromString("Zork") as NSObject.Type
let anObject = aClass()
println(anObject) // "I am a Zork"

而且它是可逆的； println(NSStringFromClass(anObject.dynamicType)) 也可以。

---

现代版：

    if let aClass = NSClassFromString("Zork") as? NSObject.Type {
        let anObject = aClass.init()
        print(anObject) // "I am a Zork"
        print(NSStringFromClass(type(of:anObject))) // Zork
    }

Answer 3

如果我正确阅读文档，如果您处理实例，例如想要返回与给定对象相同类型的新实例，并且可以使用 init() 构造类型：

let typeOfObject = aGivenObject.dynamicType
var freshInstance = typeOfObject()

我很快用 String 测试了一下：

let someType = "Fooo".dynamicType
let emptyString = someType()
let threeString = someType("Three")

效果很好。

Answer 4

在swift 3中

object.dynamicType

已弃用。

改为使用：

type(of:object)

Answer 5

比较类型的 Swift 实现

protocol Decoratable{}
class A:Decoratable{}
class B:Decoratable{}
let object:AnyObject = A()
object.dynamicType is A.Type//true
object.dynamicType is B.Type//false
object.dynamicType is Decoratable.Type//true

注意：请注意，它也适用于对象可能扩展或不扩展的协议

Answer 6

终于找到工作了。它有点懒，但即使是 NSClassFromString() 路线也不适合我......

import Foundation

var classMap = Dictionary<String, AnyObject>()

func mapClass(name: String, constructor: AnyObject) -> ()
{
    classMap[name] = constructor;
}

class Factory
{
    class func create(className: String) -> AnyObject?
    {
        var something : AnyObject?

        var template : FactoryObject? = classMap[className] as? FactoryObject

        if (template)
        {
            let somethingElse : FactoryObject = template!.dynamicType()

            return somethingElse
        }

        return nil
    }
}


 import ObjectiveC

 class FactoryObject : NSObject
{
    @required init() {}
//...
}

class Foo : FactoryObject
{
    class override func initialize()
    {
        mapClass("LocalData", LocalData())
    }
    init () { super.init() }
}

var makeFoo : AnyObject? = Factory.create("Foo")

宾果游戏，“makeFoo”包含一个 Foo 实例。

缺点是您的类必须派生自 FactoryObject，并且它们必须具有 Obj-C +initialize 方法，以便您的类通过全局函数“mapClass”自动插入到类映射中。

Answer 7

这是另一个显示类层次结构实现的示例，类似于已接受的答案，已针对 Swift 的第一个版本进行了更新。

class NamedItem : NSObject {
    func display() {
        println("display")
    }

    required override init() {
        super.init()
        println("base")
    }
}

class File : NamedItem {
    required init() {
        super.init()
        println("folder")
    }
}

class Folder : NamedItem {
    required init() {
        super.init()
        println("file")
    }
}

let y = Folder.self
y().display()
let z = File.self
z().display()

打印这个结果：

base
file
display
base
folder
display