C'è un modo per stampare il tipo di runtime di una variabile in swift? Per esempio:

var now = NSDate()
var soon = now.dateByAddingTimeInterval(5.0)

println("\(now.dynamicType)") 
// Prints "(Metatype)"

println("\(now.dynamicType.description()")
// Prints "__NSDate" since objective-c Class objects have a "description" selector

println("\(soon.dynamicType.description()")
// Compile-time error since ImplicitlyUnwrappedOptional<NSDate> has no "description" method

Nell'esempio sopra, sto cercando un modo per mostrare che la variabile "presto" è di tipo ImplicitlyUnwrappedOptional<NSDate>, o almeno NSDate!.

Aggiornamento settembre 2016

Swift 3.0: utilizzare type(of:), ad es. type(of: someThing)(Poiché la dynamicTypeparola chiave è stata rimossa)

Aggiornamento ottobre 2015 :

Ho aggiornato gli esempi seguenti con la nuova sintassi di Swift 2.0 (ad es. È printlnstato sostituito con print, lo toString()è ora String()).

Dalle note sulla versione di Xcode 6.3 :

@nschum sottolinea nei commenti che le note di rilascio di Xcode 6.3 mostrano un altro modo:

I valori del tipo ora vengono stampati come nome completo del tipo smangolato se utilizzati con println o interpolazione di stringhe.

import Foundation

class PureSwiftClass { }

var myvar0 = NSString() // Objective-C class
var myvar1 = PureSwiftClass()
var myvar2 = 42
var myvar3 = "Hans"

print( "String(myvar0.dynamicType) -> \(myvar0.dynamicType)")
print( "String(myvar1.dynamicType) -> \(myvar1.dynamicType)")
print( "String(myvar2.dynamicType) -> \(myvar2.dynamicType)")
print( "String(myvar3.dynamicType) -> \(myvar3.dynamicType)")

print( "String(Int.self)           -> \(Int.self)")
print( "String((Int?).self         -> \((Int?).self)")
print( "String(NSString.self)      -> \(NSString.self)")
print( "String(Array<String>.self) -> \(Array<String>.self)")

Quali uscite:

String(myvar0.dynamicType) -> __NSCFConstantString
String(myvar1.dynamicType) -> PureSwiftClass
String(myvar2.dynamicType) -> Int
String(myvar3.dynamicType) -> String
String(Int.self)           -> Int
String((Int?).self         -> Optional<Int>
String(NSString.self)      -> NSString
String(Array<String>.self) -> Array<String>

Aggiornamento per Xcode 6.3:

Puoi usare _stdlib_getDemangledTypeName():

print( "TypeName0 = \(_stdlib_getDemangledTypeName(myvar0))")
print( "TypeName1 = \(_stdlib_getDemangledTypeName(myvar1))")
print( "TypeName2 = \(_stdlib_getDemangledTypeName(myvar2))")
print( "TypeName3 = \(_stdlib_getDemangledTypeName(myvar3))")

e ottieni questo come output:

TypeName0 = NSString
TypeName1 = __lldb_expr_26.PureSwiftClass
TypeName2 = Swift.Int
TypeName3 = Swift.String

Risposta originale:

Prima di Xcode 6.3 ha _stdlib_getTypeNameottenuto il nome del tipo alterato di una variabile. Il blog di Ewan Swick aiuta a decifrare queste stringhe:

ad esempio _TtSista per il Inttipo interno di Swift .

Mike Ash ha un bellissimo post sul blog che tratta lo stesso argomento .

Modifica: una nuova toStringfunzione è stata introdotta in Swift 1.2 (Xcode 6.3) .

Ora puoi stampare il tipo di demangled di qualsiasi tipo usando .selfe qualsiasi istanza usando .dynamicType:

struct Box<T> {}

toString("foo".dynamicType)            // Swift.String
toString([1, 23, 456].dynamicType)     // Swift.Array<Swift.Int>
toString((7 as NSNumber).dynamicType)  // __NSCFNumber

toString((Bool?).self)                 // Swift.Optional<Swift.Bool>
toString(Box<SinkOf<Character>>.self)  // __lldb_expr_1.Box<Swift.SinkOf<Swift.Character>>
toString(NSStream.self)                // NSStream

Prova a chiamare YourClass.selfe yourObject.dynamicType.

Riferimento: https://devforums.apple.com/thread/227425 .

Swift 3.0

let string = "Hello"
let stringArray = ["one", "two"]
let dictionary = ["key": 2]

print(type(of: string)) // "String"

// Get type name as a string
String(describing: type(of: string)) // "String"
String(describing: type(of: stringArray)) // "Array<String>"
String(describing: type(of: dictionary)) // "Dictionary<String, Int>"

// Get full type as a string
String(reflecting: type(of: string)) // "Swift.String"
String(reflecting: type(of: stringArray)) // "Swift.Array<Swift.String>"
String(reflecting: type(of: dictionary)) // "Swift.Dictionary<Swift.String, Swift.Int>"

È questo quello che stai cercando?

println("\(object_getClassName(now))");

Stampa "__NSDate"

AGGIORNAMENTO : Nota che questo non funziona più a partire da Beta05

Il mio attuale Xcode è la versione 6.0 (6A280e).

import Foundation

class Person { var name: String; init(name: String) { self.name = name }}
class Patient: Person {}
class Doctor: Person {}

var variables:[Any] = [
    5,
    7.5,
    true,
    "maple",
    Person(name:"Sarah"),
    Patient(name:"Pat"),
    Doctor(name:"Sandy")
]

for variable in variables {
    let typeLongName = _stdlib_getDemangledTypeName(variable)
    let tokens = split(typeLongName, { $0 == "." })
    if let typeName = tokens.last {
        println("Variable \(variable) is of Type \(typeName).")
    }
}

Produzione:

Variable 5 is of Type Int.
Variable 7.5 is of Type Double.
Variable true is of Type Bool.
Variable maple is of Type String.
Variable Swift001.Person is of Type Person.
Variable Swift001.Patient is of Type Patient.
Variable Swift001.Doctor is of Type Doctor.

A partire da Xcode 6.3 con Swift 1.2, puoi semplicemente convertire i valori di tipo in tutto il demangled String.

toString(Int)                   // "Swift.Int"
toString(Int.Type)              // "Swift.Int.Type"
toString((10).dynamicType)      // "Swift.Int"
println(Bool.self)              // "Swift.Bool"
println([UTF8].self)            // "Swift.Array<Swift.UTF8>"
println((Int, String).self)     // "(Swift.Int, Swift.String)"
println((String?()).dynamicType)// "Swift.Optional<Swift.String>"
println(NSDate)                 // "NSDate"
println(NSDate.Type)            // "NSDate.Type"
println(WKWebView)              // "WKWebView"
toString(MyClass)               // "[Module Name].MyClass"
toString(MyClass().dynamicType) // "[Module Name].MyClass"

Puoi ancora accedere alla classe, tramite className(che restituisce a String).

In realtà ci sono diversi modi per ottenere la classe, per esempio classForArchiver, classForCoder, classForKeyedArchiver(tutti di ritorno AnyClass!).

Non è possibile ottenere il tipo di primitiva (una primitiva non è una classe).

Esempio:

var ivar = [:]
ivar.className // __NSDictionaryI

var i = 1
i.className // error: 'Int' does not have a member named 'className'

Se vuoi ottenere il tipo di primitiva, devi usare bridgeToObjectiveC(). Esempio:

var i = 1
i.bridgeToObjectiveC().className // __NSCFNumber

È possibile utilizzare reflection per ottenere informazioni sull'oggetto.
Ad esempio il nome della classe di oggetti:

var classname = reflection (ora) .summary

Ho avuto fortuna con:

let className = NSStringFromClass(obj.dynamicType)

Xcode 8 Swift 3.0 usa il tipo (di :)

let className = "\(type(of: instance))"

In Xcode 8, Swift 3.0

passi:

1. Ottieni il tipo:

Opzione 1:

let type : Type = MyClass.self  //Determines Type from Class

Opzione 2:

let type : Type = type(of:self) //Determines Type from self

2. Converti il ​​tipo in stringa:

let string : String = "\(type)" //String

In Swift 3.0, puoi utilizzare type(of:), poiché la dynamicTypeparola chiave è stata rimossa.

SWIFT 5

Con l'ultima versione di Swift 3 possiamo ottenere belle descrizioni dei nomi dei tipi attraverso l' Stringinizializzatore. Ad esempio print(String(describing: type(of: object))). Dove object può essere una variabile di istanza come array, un dizionario, an Int, a NSDate, un'istanza di una classe personalizzata, ecc.

Ecco la mia risposta completa: Ottieni il nome della classe dell'oggetto come stringa in Swift

Quella domanda è alla ricerca di un modo per ottenere il nome della classe di un oggetto come stringa, ma ho anche proposto un altro modo per ottenere il nome della classe di una variabile di cui non è una sottoclasse NSObject. Ecco qui:

class Utility{
    class func classNameAsString(obj: Any) -> String {
        //prints more readable results for dictionaries, arrays, Int, etc
        return String(describing: type(of: obj))
    }
}

Ho creato una funzione statica che accetta come parametro un oggetto di tipo Anye restituisce il nome della sua classe come String:).

Ho testato questa funzione con alcune variabili come:

    let diccionary: [String: CGFloat] = [:]
    let array: [Int] = []
    let numInt = 9
    let numFloat: CGFloat = 3.0
    let numDouble: Double = 1.0
    let classOne = ClassOne()
    let classTwo: ClassTwo? = ClassTwo()
    let now = NSDate()
    let lbl = UILabel()

e l'output era:

• diccionary è di tipo Dizionario
• array è di tipo Array
• numInt è di tipo Int
• numFloat è di tipo CGFloat
• numDouble è di tipo Double
• classOne è di tipo: ClassOne
• classTwo è di tipo: ClassTwo
• ora è di tipo: data
• lbl è di tipo: UILabel

Quando si utilizza Cocoa (non CocoaTouch), è possibile utilizzare la classNameproprietà per oggetti che sono sottoclassi di NSObject.

println(now.className)

Questa proprietà non è disponibile per i normali oggetti Swift, che non sono sottoclassi di NSObject (e in effetti, non vi è alcun ID root o tipo di oggetto in Swift).

class Person {
    var name: String?
}

var p = Person()
println(person.className) // <- Compiler error

In CocoaTouch, al momento non esiste un modo per ottenere una descrizione stringa del tipo di una determinata variabile. Funzionalità simili non esistono anche per i tipi primitivi in ​​Cocoa o CocoaTouch.

Swift REPL è in grado di stampare un riepilogo dei valori incluso il suo tipo, quindi è possibile che questo modo di introspezione sia possibile in futuro tramite un'API.

EDIT : dump(object)sembra fare il trucco.

La risposta migliore non ha un esempio funzionante del nuovo modo di farlo usando type(of:. Quindi, per aiutare i principianti come me, ecco un esempio funzionante, tratto principalmente dai documenti di Apple qui - https://developer.apple.com/documentation/swift/2885064-type

doubleNum = 30.1

func printInfo(_ value: Any) {
    let varType = type(of: value)
    print("'\(value)' of type '\(varType)'")
}

printInfo(doubleNum)
//'30.1' of type 'Double'

Ho provato alcune delle altre risposte qui, ma il milage sembra molto su quale sia l'oggetto sottostante.

Tuttavia, ho trovato un modo per ottenere il nome della classe Object-C per un oggetto nel modo seguente:

now?.superclass as AnyObject! //replace now with the object you are trying to get the class name for

Ecco un esempio di come lo useresti:

let now = NSDate()
println("what is this = \(now?.superclass as AnyObject!)")

In questo caso stamperà NSDate nella console.

Ho trovato questa soluzione che si spera possa funzionare per qualcun altro. Ho creato un metodo di classe per accedere al valore. Tieni presente che funzionerà solo per la sottoclasse NSObject. Ma almeno è una soluzione pulita e ordinata.

class var className: String!{
    let classString : String = NSStringFromClass(self.classForCoder())
    return classString.componentsSeparatedByString(".").last;
}

Nell'ultimo XCode 6.3 con Swift 1.2, questo è l'unico modo in cui ho trovato:

if view.classForCoder.description() == "UISegment" {
    ...
}

Molte delle risposte qui non funzionano con l'ultimo Swift (Xcode 7.1.1 al momento della scrittura).

Il modo attuale di ottenere le informazioni è creare un Mirrore interrogarlo. Per il nome della classe è semplice come:

let mirror = Mirror(reflecting: instanceToInspect)
let classname:String = mirror.description

Ulteriori informazioni sull'oggetto possono anche essere recuperate dal Mirror. Vedi http://swiftdoc.org/v2.1/type/Mirror/ per i dettagli.

In lldb a partire da beta 5, puoi vedere la classe di un oggetto con il comando:

fr v -d r shipDate

che produce qualcosa di simile:

(DBSalesOrderShipDate_DBSalesOrderShipDate_ *) shipDate = 0x7f859940

Il comando espanso significa qualcosa del tipo:

Frame Variable (stampa una variabile di frame) -d run_target (espandi tipi dinamici)

Qualcosa di utile da sapere è che l'uso di "Frame Variable" per generare valori variabili garantisce che non venga eseguito alcun codice.

Ho trovato una soluzione per lezioni auto-sviluppate (o simili a cui hai accesso).

Inserire la seguente proprietà calcolata nella definizione della classe degli oggetti:

var className: String? {
    return __FILE__.lastPathComponent.stringByDeletingPathExtension
}

Ora puoi semplicemente chiamare il nome della classe sul tuo oggetto in questo modo:

myObject.className

Nota che funzionerà solo se la tua definizione di classe viene fatta all'interno di un file che è chiamato esattamente come la classe di cui desideri il nome.

Poiché questo è comunemente il caso, la risposta sopra dovrebbe farlo nella maggior parte dei casi . Ma in alcuni casi speciali potresti dover trovare una soluzione diversa.

Se hai bisogno del nome della classe all'interno della classe (file) stessa , puoi semplicemente usare questa riga:

let className = __FILE__.lastPathComponent.stringByDeletingPathExtension

Forse questo metodo aiuta alcune persone là fuori.

Sulla base delle risposte e dei commenti forniti da Klass e Kevin Ballard sopra, vorrei andare con:

println(_stdlib_getDemangledTypeName(now).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(soon).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(soon?).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(soon!).componentsSeparatedByString(".").last!)

println(_stdlib_getDemangledTypeName(myvar0).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(myvar1).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(myvar2).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(myvar3).componentsSeparatedByString(".").last!)

che stamperà:

"NSDate"
"ImplicitlyUnwrappedOptional"
"Optional"
"NSDate"

"NSString"
"PureSwiftClass"
"Int"
"Double"

let i: Int = 20


  func getTypeName(v: Any) -> String {
    let fullName = _stdlib_demangleName(_stdlib_getTypeName(i))
    if let range = fullName.rangeOfString(".") {
        return fullName.substringFromIndex(range.endIndex)
    }
    return fullName
}

println("Var type is \(getTypeName(i)) = \(i)")

Swift versione 4:

print("\(type(of: self)) ,\(#function)")
// within a function of a class

Grazie @Joshua Dance

Swift 4:

// "TypeName"
func stringType(of some: Any) -> String {
    let string = (some is Any.Type) ? String(describing: some) : String(describing: type(of: some))
    return string
}

// "ModuleName.TypeName"
func fullStringType(of some: Any) -> String {
    let string = (some is Any.Type) ? String(reflecting: some) : String(reflecting: type(of: some))
    return string
}

Uso:

print(stringType(of: SomeClass()))     // "SomeClass"
print(stringType(of: SomeClass.self))  // "SomeClass"
print(stringType(of: String()))        // "String"
print(fullStringType(of: String()))    // "Swift.String"

Non sembra esserci un modo generico per stampare il nome del tipo di un valore di valore arbitrario. Come altri hanno già notato, per le istanze di classe è possibile stamparevalue.className ma per i valori primitivi sembra che in fase di esecuzione le informazioni sul tipo siano sparite.

Ad esempio, sembra che non ci sia un modo per digitare: 1.something()e uscire Intper qualsiasi valore di something. (È possibile, come suggerito da un'altra risposta, utilizzare i.bridgeToObjectiveC().classNameper darti un suggerimento, ma in realtà non__NSCFNumber è il tipo di - proprio in cosa verrà convertito quando attraversa il confine di una chiamata di funzione Objective-C.)i

Sarei felice di essere smentito, ma sembra che il controllo del tipo sia tutto fatto in fase di compilazione, e come il C ++ (con RTTI disabilitato) gran parte delle informazioni sul tipo sono andate in fase di esecuzione.

Questo è il modo in cui ottieni una stringa di tipo del tuo oggetto o Tipo che è coerente e prende in considerazione a quale modulo appartiene la definizione dell'oggetto o in cui è nidificato. Funziona in Swift 4.x.

@inline(__always) func typeString(for _type: Any.Type) -> String {
    return String(reflecting: type(of: _type))
}

@inline(__always) func typeString(for object: Any) -> String {
    return String(reflecting: type(of: type(of: object)))
}

struct Lol {
    struct Kek {}
}

// if you run this in playground the results will be something like
typeString(for: Lol.self)    //    __lldb_expr_74.Lol.Type
typeString(for: Lol())       //    __lldb_expr_74.Lol.Type
typeString(for: Lol.Kek.self)//    __lldb_expr_74.Lol.Kek.Type
typeString(for: Lol.Kek())   //    __lldb_expr_74.Lol.Kek.Type

Per ottenere un tipo di oggetto o una classe di oggetti in Swift , è necessario utilizzare un tipo (di: yourObject)

tipo (di: yourObject)

Non esattamente quello che stai cercando, ma puoi anche controllare il tipo di variabile rispetto ai tipi Swift in questo modo:

let object: AnyObject = 1

if object is Int {
}
else if object is String {
}

Per esempio.

Xcode 7.3.1, Swift 2.2:

String(instanceToPrint.self).componentsSeparatedByString(".").last