Come scopri il tipo di un oggetto (in Swift)?

Quando si cerca di capire un programma, o in alcuni casi angolari, è utile poter effettivamente scoprire di che tipo è qualcosa. So che il debugger può mostrarti alcune informazioni sul tipo, e di solito puoi fare affidamento sull'inferenza del tipo per evitare di specificare il tipo in quelle situazioni, ma comunque, mi piacerebbe davvero avere qualcosa come Pythontype()

dynamicType (vedi questa domanda )

Aggiornamento: questo è stato modificato in una versione recente di Swift, obj.dynamicTypeora fornisce un riferimento al tipo e non all'istanza del tipo dinamico.

Questo sembra il più promettente, ma finora non sono stato in grado di scoprire il tipo reale

class MyClass {
    var count = 0
}

let mc = MyClass()

# update: this now evaluates as true
mc.dynamicType === MyClass.self

Ho anche provato ad utilizzare un riferimento di classe creare un'istanza di un nuovo oggetto, che fa il lavoro, ma stranamente mi ha dato un errore dicendo devo aggiungere un requiredinizializzatore:

lavori:

class MyClass {
    var count = 0
    required init() {
    }
}

let myClass2 = MyClass.self
let mc2 = MyClass2()

Tuttavia, resta solo un piccolo passo verso la scoperta del tipo di un determinato oggetto

modifica : ho rimosso un numero considerevole di dettagli ora irrilevanti - guarda la cronologia delle modifiche se sei interessato :)

Versione Swift 3:

type(of: yourObject)

Swift 2.0:

Il modo corretto di fare questo tipo di introspezione di tipo sarebbe con la struttura Mirror ,

    let stringObject:String = "testing"
    let stringArrayObject:[String] = ["one", "two"]
    let viewObject = UIView()
    let anyObject:Any = "testing"

    let stringMirror = Mirror(reflecting: stringObject)
    let stringArrayMirror = Mirror(reflecting: stringArrayObject)
    let viewMirror = Mirror(reflecting: viewObject)
    let anyMirror = Mirror(reflecting: anyObject)

Quindi per accedere al tipo stesso dalla Mirrorstruttura dovresti usare la proprietà in questo subjectTypemodo:

    // Prints "String"
    print(stringMirror.subjectType)

    // Prints "Array<String>"
    print(stringArrayMirror.subjectType)

    // Prints "UIView"
    print(viewMirror.subjectType)

    // Prints "String"
    print(anyMirror.subjectType)

È quindi possibile utilizzare qualcosa del genere:

    if anyMirror.subjectType == String.self {
        print("anyObject is a string!")
    } else {
        print("anyObject is not a string!")
    }

Il dynamicType.printClassNamecodice proviene da un esempio nel libro Swift. Non so per quale motivo afferrare direttamente un nome di classe personalizzato, ma puoi controllare un tipo di istanza usando la isparola chiave come mostrato di seguito. Questo esempio mostra anche come implementare una funzione className personalizzata, se si desidera davvero il nome della classe come stringa.

class Shape {
    class func className() -> String {
        return "Shape"
    }
}

class Square: Shape {
    override class func className() -> String {
        return "Square"
    }
}

class Circle: Shape {
    override class func className() -> String {
        return "Circle"
    }
}

func getShape() -> Shape {
    return Square() // hardcoded for example
}

let newShape: Shape = getShape()
newShape is Square // true
newShape is Circle // false
newShape.dynamicType.className() // "Square"
newShape.dynamicType.className() == Square.className() // true

Nota:
che le sottoclassi di NSObjectimplementano già la propria funzione className. Se lavori con Cocoa, puoi semplicemente usare questa proprietà.

class MyObj: NSObject {
    init() {
        super.init()
        println("My class is \(self.className)")
    }
}
MyObj()

A partire da Xcode 6.0.1 (almeno, non sono sicuro quando lo hanno aggiunto), il tuo esempio originale ora funziona:

class MyClass {
    var count = 0
}

let mc = MyClass()
mc.dynamicType === MyClass.self // returns `true`

Aggiornare:

Per rispondere alla domanda originale, puoi effettivamente utilizzare correttamente il runtime Objective-C con semplici oggetti Swift.

Prova quanto segue:

import Foundation
class MyClass { }
class SubClass: MyClass { }

let mc = MyClass()
let m2 = SubClass()

// Both of these return .Some("__lldb_expr_35.SubClass"), which is the fully mangled class name from the playground
String.fromCString(class_getName(m2.dynamicType))
String.fromCString(object_getClassName(m2))
// Returns .Some("__lldb_expr_42.MyClass")
String.fromCString(object_getClassName(mc))

Se hai semplicemente bisogno di verificare se la variabile è di tipo X o se è conforme ad un protocollo, puoi usare is, o as?come nel seguito:

var unknownTypeVariable = …

if unknownTypeVariable is <ClassName> {
    //the variable is of type <ClassName>
} else {
    //variable is not of type <ClassName>
}

Questo è equivalente a isKindOfClassin Obj-C.

E questo equivale a conformsToProtocol, oisMemberOfClass

var unknownTypeVariable = …

if let myClass = unknownTypeVariable as? <ClassName or ProtocolName> {
    //unknownTypeVarible is of type <ClassName or ProtocolName>
} else {
    //unknownTypeVariable is not of type <ClassName or ProtocolName>
}

Swift 3:

if unknownType is MyClass {
   //unknownType is of class type MyClass
}

Per Swift 3.0

String(describing: <Class-Name>.self)

Per Swift 2.0 - 2.3

String(<Class-Name>)

Ecco 2 modi in cui consiglio di farlo:

if let thisShape = aShape as? Square 

O:

aShape.isKindOfClass(Square)

Ecco un esempio dettagliato:

class Shape { }
class Square: Shape { } 
class Circle: Shape { }

var aShape = Shape()
aShape = Square()

if let thisShape = aShape as? Square {
    println("Its a square")
} else {
    println("Its not a square")
}

if aShape.isKindOfClass(Square) {
    println("Its a square")
} else {
    println("Its not a square")
}

Dipende dal caso d'uso. Ma supponiamo che tu voglia fare qualcosa di utile con i tuoi tipi "variabili". L' switchaffermazione Swift è molto potente e può aiutarti a ottenere i risultati che stai cercando ...

    let dd2 = ["x" : 9, "y" : "home9"]
    let dds = dd2.filter {
        let eIndex = "x"
        let eValue:Any = 9
        var r = false

        switch eValue {
        case let testString as String:
            r = $1 == testString
        case let testUInt as UInt:
            r = $1 == testUInt
        case let testInt as Int:
            r = $1 == testInt
        default:
            r = false
        }

        return r && $0 == eIndex
    }

In questo caso, disporre di un dizionario semplice che contiene coppie chiave / valore che possono essere UInt, Int o String. Nel .filter()metodo sul dizionario, devo assicurarmi di testare i valori correttamente e testare una stringa solo quando è una stringa, ecc. L'istruzione switch lo rende semplice e sicuro! Assegnando 9 alla variabile di tipo Any, esegue lo switch per Int. Prova a cambiarlo in:

   let eValue:Any = "home9"

..e riprovare. Questa volta esegue il as Stringcaso.

Se ricevi un avviso "sempre vero / non riuscito", potresti dover eseguire il cast su Qualsiasi prima di utilizzarlo is

(foo as Any) is SomeClass

//: Playground - noun: a place where people can play

import UIKit

class A {
    class func a() {
        print("yeah")
    }

    func getInnerValue() {
        self.dynamicType.a()
    }
}

class B: A {
    override class func a() {
        print("yeah yeah")
    }
}

B.a() // yeah yeah
A.a() // yeah
B().getInnerValue() // yeah yeah
A().getInnerValue() // yeah