การวิปัสสนาและยาสามัญอย่างรวดเร็ว

ฉันพยายามสร้างclassประเภทตามอินสแตนซ์แบบไดนามิกโดยใช้ generics แต่ฉันกำลังประสบกับความยากลำบากในการวิปัสสนาในชั้นเรียน

คำถามมีดังนี้

• มี Swift เทียบเท่ากับ Obj-C self.classหรือไม่?
• มีวิธีสร้างอินสแตนซ์คลาสโดยใช้AnyClassผลลัพธ์จากNSClassFromStringหรือไม่
• มีวิธีรับAnyClassหรือพิมพ์ข้อมูลจากพารามิเตอร์ทั่วไปอย่างเคร่งครัดTหรือไม่? (คล้ายกับtypeof(T)ไวยากรณ์ของ C # )

อย่างหนึ่งสิ่งที่เทียบเท่ากับ Swift [NSString class]คือ.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 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
    }

หากฉันอ่านเอกสารถูกต้องหากคุณจัดการกับอินสแตนซ์และเช่นต้องการส่งคืนอินสแตนซ์ใหม่ที่เป็น Type เดียวกันกับวัตถุที่คุณได้รับและ Type สามารถสร้างด้วย 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