Самоанализ и обобщения в классе Swift

Я пытаюсь динамически создать classтип на основе экземпляра с использованием универсальных шаблонов, однако у меня возникают трудности с самоанализом класса.

Вот вопросы:

• Есть ли Swift-эквивалент Obj-C self.class?
• Есть ли способ создать экземпляр класса, используя AnyClassрезультат NSClassFromString?
• Есть ли способ получить AnyClassили иным образом ввести информацию строго из общего параметра T? (Аналогично typeof(T)синтаксису C # )

Ну, во- первых , Swift эквивалент [NSString class]is .self(см. Документацию Metatype , хотя они довольно тонкие).

На самом деле NSString.classдаже не работает! Вы должны использовать NSString.self.

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

Точно так же с быстрым классом я пробовал ...

class MyClass {

}

let MyClassRef = MyClass.self

// ERROR :(
let my_obj = MyClassRef()

Хм… ошибка говорит:

Не удалось выполнить игровую площадку: ошибка:: 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выдает ошибку на игровой площадке.

Вот как пользоваться 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 этих классов; это очень важно, потому что иначе мы не знаем измененную строку, обозначающую каждый класс.

Теперь мы можем использовать 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
    }

Если я правильно читаю документацию, если вы имеете дело с экземплярами и, например, хотите вернуть новый экземпляр того же типа, что и объект, который вам был предоставлен, и тип может быть создан с помощью init (), вы можете сделать:

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

Я быстро протестировал это с помощью String:

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

который работал нормально.

В быстром 3

object.dynamicType

устарела.

Вместо этого используйте:

type(of:object)

Быстрая реализация сравнения типов

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

ПРИМЕЧАНИЕ: обратите внимание, что он также работает с протоколами, которые объект может или не может расширять.

Наконец-то есть над чем работать. Это немного лениво, но даже маршрут 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 +, чтобы ваш класс автоматически вставлялся в карту классов глобальной функцией mapClass.

Вот еще один пример, показывающий реализацию иерархии классов, аналогичную принятому ответу, обновленному для первого выпуска 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