Clase Swift introspección y genéricos

He aquí cómo usar NSClassFromString. Tienes que conocer la superclase con la que vas a terminar. Aquí hay un par superclase-subclase que saben cómo describirse a sí mismos para 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"}
}

Observe el uso de la sintaxis especial @obj para dictar el nombre munged Objective-C de estas clases; eso es crucial, porque de lo contrario no conocemos la cadena munged que designa a cada clase.

Ahora podemos usar NSClassFromString para hacer la clase Zork o la clase Zilk, porque sabemos que podemos escribir es como un NSObject y no se bloquea más tarde:

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

Y es reversible; println(NSStringFromClass(anObject.dynamicType)) también funciona.

Si estoy leyendo bien la documentación, si trata con instancias y, por ejemplo, desea devolver una nueva instancia del mismo Tipo que el objeto que se le ha dado y el Tipo se puede construir con un init (), puede hacer:

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

Lo probé rápidamente con String:

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

Que funcionó bien.

In swift 3

object.dynamicType

Está en desuso.

En su lugar use:

type(of:object)

Implementación rápida de tipos de comparación

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

NOTA: Observe que también funciona con protocolos que el objeto puede o no extender

Finalmente tengo algo que trabajar. Es un poco perezoso, pero incluso la ruta NSClassFromString() no funcionó para mí...

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")

Y bingo, "makeFoo" contiene una instancia de Foo.

El inconveniente es que sus clases deben derrive desde factoryObject y DEBEN tener el método Obj-C +initialize para que su clase se inserte automáticamente en el mapa de clases mediante la función global "mapClass".

Aquí hay otro ejemplo que muestra la implementación de la jerarquía de clases, similar a accepted answer, actualizada para la primera versión de 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()

Imprime este resultado:

base
file
display
base
folder
display