¿Hay alguna manera de imprimir el tipo de tiempo de ejecución de una variable en swift? Por ejemplo:

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

En el ejemplo anterior, estoy buscando una manera de mostrar que la variable "pronto" es de tipo ImplicitlyUnwrappedOptional<NSDate>, o al menos NSDate!.

Actualización de septiembre de 2016

Swift 3.0: uso type(of:), p. Ej. type(of: someThing)(Ya que dynamicTypese eliminó la palabra clave)

Actualización de octubre de 2015 :

Actualicé los ejemplos a continuación a la nueva sintaxis de Swift 2.0 (por ejemplo, printlnse reemplazó por print, toString()ahora esString() ).

De las notas de la versión Xcode 6.3 :

@nschum señala en los comentarios que las notas de lanzamiento de Xcode 6.3 muestran otra forma:

Los valores de tipo ahora se imprimen como el nombre de tipo demandado completo cuando se usa con println o interpolación de cadenas.

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

Qué salidas:

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>

Actualización para Xcode 6.3:

Puedes usar el _stdlib_getDemangledTypeName():

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

y obtener esto como salida:

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

Respuesta original:

Antes de Xcode 6.3 _stdlib_getTypeNameobtuvo el nombre de tipo destrozado de una variable. La entrada del blog de Ewan Swick ayuda a descifrar estas cadenas:

Por ejemplo, _TtSisignifica el Inttipo interno de Swift .

Mike Ash tiene una gran entrada de blog que cubre el mismo tema .

Editar: se ha introducido una nueva toStringfunción en Swift 1.2 (Xcode 6.3) .

Ahora puede imprimir el tipo solicitado de cualquier tipo usando .selfy cualquier instancia 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

Intenta llamar YourClass.selfy yourObject.dynamicType.

Referencia: 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>"

¿Es esto lo que estás buscando?

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

Imprime "__NSDate"

ACTUALIZACIÓN : Tenga en cuenta que esto ya no parece funcionar a partir de Beta05

Mi Xcode actual es la versión 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).")
    }
}

Salida:

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 partir de Xcode 6.3 con Swift 1.2, simplemente puede convertir los valores de tipo al valor total requerido 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"

Todavía puede acceder a la clase, a través de className(que devuelve a String).

En realidad, hay varias maneras de obtener la clase, por ejemplo classForArchiver, classForCoder, classForKeyedArchiver(todos de retorno AnyClass!).

No se puede obtener el tipo de primitivo (un primitivo no es una clase).

Ejemplo:

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

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

Si desea obtener el tipo de primitivo, debe usarlo bridgeToObjectiveC(). Ejemplo:

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

Puede usar reflect para obtener información sobre el objeto.
Por ejemplo, nombre de la clase de objeto:

var classname = reflect (now) .summary

Tuve suerte con:

let className = NSStringFromClass(obj.dynamicType)

Tipo de uso de Xcode 8 Swift 3.0 (de :)

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

En Xcode 8, Swift 3.0

Pasos:

1. Obtenga el tipo:

Opción 1:

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

Opcion 2:

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

2. Convertir tipo a cadena:

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

En Swift 3.0, puede usar type(of:), ya que la dynamicTypepalabra clave se ha eliminado.

SWIFT 5

Con la última versión de Swift 3 podemos obtener descripciones bonitas de los nombres de tipo a través del Stringinicializador. Me gusta, por ejemplo print(String(describing: type(of: object))). ¿Dónde object puede haber una variable de instancia como matriz, un diccionario, una Int, una NSDate, una instancia de una clase personalizada, etc.

Aquí está mi respuesta completa: obtener el nombre de clase del objeto como cadena en Swift

Esa pregunta está buscando una forma de obtener el nombre de clase de un objeto como una cadena, pero también propuse otra forma de obtener el nombre de clase de una variable que no es una subclase de NSObject. Aquí está:

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

Hice una función estática que toma como parámetro un objeto de tipo Anyy devuelve su nombre de clase como String:).

Probé esta función con algunas variables como:

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

y la salida fue:

• el diccionario es de tipo Diccionario
• array es de tipo Array
• numInt es de tipo Int
• numFloat es del tipo CGFloat
• numDouble es de tipo Double
• classOne es de tipo: ClassOne
• classTwo es de tipo: ClassTwo
• ahora es de tipo: Fecha
• lbl es de tipo: UILabel

Al usar Cocoa (no CocoaTouch), puede usar la classNamepropiedad para objetos que son subclases de NSObject.

println(now.className)

Esta propiedad no está disponible para objetos Swift normales, que no son subclases de NSObject (y de hecho, no hay identificación de raíz o tipo de objeto en Swift).

class Person {
    var name: String?
}

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

En CocoaTouch, en este momento no hay una manera de obtener una descripción de cadena del tipo de una variable dada. Funcionalidad similar tampoco existe para los tipos primitivos en Cocoa o CocoaTouch.

Swift REPL puede imprimir un resumen de valores, incluido su tipo, por lo que es posible que esta forma de introspección sea posible a través de una API en el futuro.

EDITAR : dump(object)parece hacer el truco.

La respuesta principal no tiene un ejemplo funcional de la nueva forma de hacer esto usando type(of:. Entonces, para ayudar a los novatos como yo, aquí hay un ejemplo de trabajo, tomado principalmente de los documentos de Apple aquí: 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'

He intentado algunas de las otras respuestas aquí, pero parece que Milage sabe muy bien cuál es el objeto subyacente.

Sin embargo, encontré una forma de obtener el nombre de la clase Object-C para un objeto haciendo lo siguiente:

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

Aquí hay un ejemplo de cómo lo usarías:

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

En este caso, imprimirá NSDate en la consola.

Encontré esta solución que, con suerte, podría funcionar para otra persona. Creé un método de clase para acceder al valor. Tenga en cuenta que esto funcionará solo para la subclase NSObject. Pero al menos es una solución limpia y ordenada.

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

En el último XCode 6.3 con Swift 1.2, esta es la única forma en que encontré:

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

Muchas de las respuestas aquí no funcionan con el último Swift (Xcode 7.1.1 al momento de escribir).

La forma actual de obtener la información es crear un Mirrore interrogarlo. Para el nombre de clase es tan simple como:

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

También se puede recuperar información adicional sobre el objeto de Mirror. Ver http://swiftdoc.org/v2.1/type/Mirror/ para más detalles.

En lldb a partir de beta 5, puede ver la clase de un objeto con el comando:

fr v -d r shipDate

que produce algo como:

(DBSalesOrderShipDate_DBSalesOrderShipDate_ *) shipDate = 0x7f859940

El comando expandido significa algo como:

Frame Variable (imprimir una variable de cuadro) -d run_target (expandir tipos dinámicos)

Algo útil para saber es que el uso de "Frame Variable" para generar valores de variables garantiza que no se ejecute ningún código.

He encontrado una solución para las clases de desarrollo propio (o a las que tiene acceso).

Coloque la siguiente propiedad calculada dentro de su definición de clase de objetos:

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

Ahora puede simplemente llamar el nombre de la clase en su objeto de la siguiente manera:

myObject.className

Tenga en cuenta que esto solo funcionará si su definición de clase se realiza dentro de un archivo que se llama exactamente como la clase de la que desea el nombre.

Como este es comúnmente el caso, la respuesta anterior debería hacerlo para la mayoría de los casos . Pero en algunos casos especiales, es posible que deba encontrar una solución diferente.

Si necesita el nombre de la clase dentro de la clase (archivo), simplemente puede usar esta línea:

let className = __FILE__.lastPathComponent.stringByDeletingPathExtension

Quizás este método ayude a algunas personas.

Basado en las respuestas y comentarios dados por Klass y Kevin Ballard arriba, iría 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!)

que imprimirá:

"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 versión 4:

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

Gracias @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"

Parece que no hay una forma genérica de imprimir el nombre del tipo de un valor arbitrario. Como otros han señalado, para las instancias de clase puede imprimirvalue.className pero para valores primitivos parece que en tiempo de ejecución, la información de tipo se ha ido.

Por ejemplo, parece que no hay una forma de escribir: 1.something()y salir Intpor cualquier valor de something. (Puede, como se sugirió otra respuesta, el uso i.bridgeToObjectiveC().classNamea dar una pista, pero __NSCFNumberes no realmente el tipo dei -. Sólo lo que se convertirá en cuando se cruza el límite de una llamada a la función de Objective-C)

Me encantaría que me demuestren que estoy equivocado, pero parece que la verificación de tipos se realiza en tiempo de compilación, y como C ++ (con RTTI deshabilitado), gran parte de la información de tipos desaparece en tiempo de ejecución.

Así es como se obtiene una cadena de tipo de su objeto o Tipo que es coherente y tiene en cuenta a qué módulo pertenece o está anidada la definición del objeto. Funciona en 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

Para obtener un tipo de objeto o clase de objeto en Swift , debe usar un tipo (de: yourObject)

tipo (de: suObjeto)

No es exactamente lo que busca, pero también puede verificar el tipo de la variable con los tipos Swift de la siguiente manera:

let object: AnyObject = 1

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

Por ejemplo.

Xcode 7.3.1, Swift 2.2:

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