Obtener el nombre de clase de un objeto como Stringusando:

object_getClassName(myViewController)

devuelve algo como esto:

_TtC5AppName22CalendarViewController

Busco a la pura versión: "CalendarViewController". ¿Cómo obtengo una cadena limpia del nombre de la clase en su lugar?

Encontré algunos intentos de preguntas sobre esto, pero no una respuesta real. ¿No es posible en absoluto?

Cadena de una instancia :

String(describing: YourType.self)

Cadena de un tipo :

String(describing: self)

Ejemplo:

struct Foo {

    // Instance Level
    var typeName: String {
        return String(describing: Foo.self)
    }

    // Instance Level - Alternative Way
    var otherTypeName: String {
        let thisType = type(of: self)
        return String(describing: thisType)
    }

    // Type Level
    static var typeName: String {
        return String(describing: self)
    }

}

Foo().typeName       // = "Foo"
Foo().otherTypeName  // = "Foo"
Foo.typeName         // = "Foo"

Probado con class, structy enum.

ACTUALIZADO A SWIFT 5

Podemos obtener descripciones bonitas de nombres de tipos usando la variable de instancia a través del Stringinicializador y crear nuevos objetos de una clase determinada

Me gusta, por ejemplo print(String(describing: type(of: object))). Donde objectpuede haber una variable de instancia como array, un diccionario, an Int, a NSDate, etc.

Debido a que NSObjectes la clase raíz de la mayoría de las jerarquías de clase Objective-C, podría intentar hacer una extensión para NSObjectobtener el nombre de clase de cada subclase de NSObject. Me gusta esto:

extension NSObject {
    var theClassName: String {
        return NSStringFromClass(type(of: self))
    }
}

O podría hacer una función estática cuyo parámetro sea de tipo Any(El protocolo al que todos los tipos se ajustan implícitamente) y devuelva el nombre de la clase como Cadena. Me gusta esto:

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

Ahora puedes hacer algo como esto:

class ClassOne : UIViewController{ /* some code here */ }
class ClassTwo : ClassOne{ /* some code here */ }

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // Get the class name as String
        let dictionary: [String: CGFloat] = [:]
        let array: [Int] = []
        let int = 9
        let numFloat: CGFloat = 3.0
        let numDouble: Double = 1.0
        let classOne = ClassOne()
        let classTwo: ClassTwo? = ClassTwo()
        let now = NSDate()
        let lbl = UILabel()

        print("dictionary: [String: CGFloat] = [:] -> \(Utility.classNameAsString(dictionary))")
        print("array: [Int] = [] -> \(Utility.classNameAsString(array))")
        print("int = 9 -> \(Utility.classNameAsString(int))")
        print("numFloat: CGFloat = 3.0 -> \(Utility.classNameAsString(numFloat))")
        print("numDouble: Double = 1.0 -> \(Utility.classNameAsString(numDouble))")
        print("classOne = ClassOne() -> \((ClassOne).self)") //we use the Extension
        if classTwo != nil {
            print("classTwo: ClassTwo? = ClassTwo() -> \(Utility.classNameAsString(classTwo!))") //now we can use a Forced-Value Expression and unwrap the value
        }
        print("now = Date() -> \(Utility.classNameAsString(now))")
        print("lbl = UILabel() -> \(String(describing: type(of: lbl)))") // we use the String initializer directly

    }
}

Además, una vez que podamos obtener el nombre de la clase como String, podemos crear instancias de nuevos objetos de esa clase :

// Instantiate a class from a String
print("\nInstantiate a class from a String")
let aClassName = classOne.theClassName
let aClassType = NSClassFromString(aClassName) as! NSObject.Type
let instance = aClassType.init() // we create a new object
print(String(cString: class_getName(type(of: instance))))
print(instance.self is ClassOne)

¡Quizás esto ayude a alguien!

Swift 5

Aquí está la extensión para obtener el typeNamecomo una variable (trabajar tanto con el tipo de valor como con el tipo de referencia).

protocol NameDescribable {
    var typeName: String { get }
    static var typeName: String { get }
}

extension NameDescribable {
    var typeName: String {
        return String(describing: type(of: self))
    }

    static var typeName: String {
        return String(describing: self)
    }
}

Cómo utilizar:

// Extend with class/struct/enum...
extension NSObject: NameDescribable {}
extension Array: NameDescribable {}
extension UIBarStyle: NameDescribable { }

print(UITabBarController().typeName)
print(UINavigationController.typeName)
print([Int]().typeName)
print(UIBarStyle.typeName)

// Out put:
UITabBarController
UINavigationController
Array<Int>
UIBarStyle

Swift 3.0

String(describing: MyViewController.self)

Sugiero tal enfoque ( muy Swifty ):

// Swift 3
func typeName(_ some: Any) -> String {
    return (some is Any.Type) ? "\(some)" : "\(type(of: some))"
}

// Swift 2
func typeName(some: Any) -> String {
    return (some is Any.Type) ? "\(some)" : "\(some.dynamicType)"
}

No utiliza ni introspección ni demanda manual (¡ sin magia! ).

Aquí hay una demostración:

// Swift 3

import class Foundation.NSObject

func typeName(_ some: Any) -> String {
    return (some is Any.Type) ? "\(some)" : "\(type(of: some))"
}

class GenericClass<T> {
    var x: T? = nil
}

protocol Proto1 {
    func f(x: Int) -> Int
}


@objc(ObjCClass1)
class Class1: NSObject, Proto1 {
    func f(x: Int) -> Int {
        return x
    }
}

struct Struct1 {
    var x: Int
}

enum Enum1 {
    case X
}

print(typeName(GenericClass<Int>.self)) // GenericClass<Int>
print(typeName(GenericClass<Int>()))  // GenericClass<Int>

print(typeName(Proto1.self)) // Proto1

print(typeName(Class1.self))   // Class1
print(typeName(Class1())) // Class1
print(typeName(Class1().f)) // (Int) -> Int

print(typeName(Struct1.self)) // Struct1
print(typeName(Struct1(x: 1))) // Struct1
print(typeName(Enum1.self)) // Enum1
print(typeName(Enum1.X)) // Enum1

Si tiene tipo Foo, el siguiente código le dará "Foo"en Swift 3 y Swift 4:

let className = String(describing: Foo.self) // Gives you "Foo"

El problema con la mayoría de las respuestas aquí es que te dan "Foo.Type"como la cadena resultante cuando no tienes ninguna instancia del tipo, cuando lo que realmente quieres es justo "Foo". Lo siguiente le da "Foo.Type", como se menciona en un montón de las otras respuestas.

let className = String(describing: type(of: Foo.self)) // Gives you "Foo.Type"

La type(of:)parte es innecesaria si solo quieres "Foo".

En Swift 4.1 y ahora Swift 4.2 :

import Foundation

class SomeClass {
    class InnerClass {
        let foo: Int

        init(foo: Int) {
            self.foo = foo
        }
    }

    let foo: Int

    init(foo: Int) {
        self.foo = foo
    }
}

class AnotherClass : NSObject {
    let foo: Int

    init(foo: Int) {
        self.foo = foo
        super.init()
    }
}

struct SomeStruct {
    let bar: Int

    init(bar: Int) {
        self.bar = bar
    }
}

let c = SomeClass(foo: 42)
let s = SomeStruct(bar: 1337)
let i = SomeClass.InnerClass(foo: 2018)
let a = AnotherClass(foo: 1<<8)

Si no tiene una instancia alrededor:

String(describing: SomeClass.self) // Result: SomeClass
String(describing: SomeStruct.self) // Result: SomeStruct
String(describing: SomeClass.InnerClass.self) // Result: InnerClass
String(describing: AnotherClass.self) // Result: AnotherClass

Si tiene una instancia alrededor:

String(describing: type(of: c)) // Result: SomeClass
String(describing: type(of: s)) // Result: SomeStruct
String(describing: type(of: i)) // Result: InnerClass
String(describing: type(of: a)) // Result: AnotherClass

Para obtener el nombre de una clase Swift de un objeto, por ejemplo, para un objeto var: SomeClass (), use

String(describing: type(of: object))

Para obtener el nombre de una clase Swift de un tipo de clase, por ejemplo, SomeClass, use:

String(describing: SomeClass.self)

Salida:

"SomeClass"

Puedes probar de esta manera:

self.classForCoder.description()

Puede usar la función de biblioteca estándar Swift llamada _stdlib_getDemangledTypeNameasí:

let name = _stdlib_getDemangledTypeName(myViewController)

Para obtener el nombre del tipo como una cadena en Swift 4 (no he verificado las versiones anteriores), solo use la interpolación de cadenas:

"\(type(of: myViewController))"

Puede usar .selfun tipo en sí mismo y la type(of:_)función en una instancia:

// Both constants will have "UIViewController" as their value
let stringFromType = "\(UIViewController.self)"
let stringFromInstance = "\(type(of: UIViewController()))"

También se pueden usar espejos:

let vc = UIViewController()

String(Mirror(reflecting: vc).subjectType)

NB: este método también se puede utilizar para estructuras y enumeraciones. Hay un displayStyle que da una indicación de qué tipo de estructura:

Mirror(reflecting: vc).displayStyle

El retorno es una enumeración para que pueda:

Mirror(reflecting: vc).displayStyle == .Class

Swift 5.1

Sin embargo, puede obtener nombres de clase, estructura, enumeración, protocolo y NSObject Self.self.

print("\(Self.self)")

Swift 3.0: puede crear una extensión como esta. Devuelve el nombre de la clase sin el nombre del proyecto

extension NSObject {
    var className: String {
        return NSStringFromClass(self as! AnyClass).components(separatedBy: ".").last ?? ""
    }

    public class var className: String {
        return NSStringFromClass(self).components(separatedBy: ".").last ?? ""
    }
}

Puede ampliar NSObjectProtocolen Swift 4 de esta manera:

import Foundation

extension NSObjectProtocol {

    var className: String {
        return String(describing: Self.self)
    }
}

Esto hará que la variable calculada classNameesté disponible para TODAS las clases. El uso de este dentro de una print()en CalendarViewControllerimprimirá "CalendarViewController"en la consola.

He estado buscando esta respuesta de vez en cuando. Uso GKStateMachine y me gusta observar los cambios de estado y quería una manera fácil de ver solo el nombre de la clase. No estoy seguro de si es solo iOS 10 o Swift 2.3, pero en ese entorno, lo siguiente hace exactamente lo que quiero:

let state:GKState?
print("Class Name: \(String(state.classForCoder)")

// Output:    
// Class Name: GKState

Puede obtener el nombre de la clase haciendo algo como:

class Person {}
String(describing: Person.self)

Para obtener el nombre de la clase como String, declare su clase de la siguiente manera

@objc(YourClassName) class YourClassName{}

Y obtenga el nombre de la clase usando la siguiente sintaxis

NSStringFromClass(YourClassName)

Pruébelo reflect().summaryen Clase propia o instancia tipo dinámico. Desenvuelva los opcionales antes de obtener dynamicType; de ​​lo contrario, dynamicType es el contenedor opcional.

class SampleClass { class InnerClass{} }
let sampleClassName = reflect(SampleClass.self).summary;
let instance = SampleClass();
let instanceClassName = reflect(instance.dynamicType).summary;
let innerInstance = SampleClass.InnerClass();
let InnerInstanceClassName = reflect(innerInstance.dynamicType).summary.pathExtension;
let tupleArray = [(Int,[String:Int])]();
let tupleArrayTypeName = reflect(tupleArray.dynamicType).summary;

El resumen es una ruta de clase con tipos genéricos descritos. Para obtener un nombre de clase simple del resumen, pruebe este método.

func simpleClassName( complexClassName:String ) -> String {
    var result = complexClassName;
    var range = result.rangeOfString( "<" );
    if ( nil != range ) { result = result.substringToIndex( range!.startIndex ); }
    range = result.rangeOfString( "." );
    if ( nil != range ) { result = result.pathExtension; }
    return result;
}

Las soluciones anteriores no funcionaron para mí. La mayoría de los problemas se mencionan en varios comentarios:

MyAppName.ClassName

o

MyFrameWorkName.ClassName

Estas soluciones funcionaron en XCode 9, Swift 3.0:

Lo nombré classNameCleanedpara que sea más fácil acceder y no entre en conflicto con futuros className()cambios:

extension NSObject {

static var classNameCleaned : String {

    let className = self.className()
    if className.contains(".") {
        let namesArray = className.components(separatedBy: ".")
        return namesArray.last ?? className
    } else {
        return self.className()
    }

}

}

Uso:

NSViewController.classNameCleaned
MyCustomClass.classNameCleaned

Swift 3.0 (macOS 10.10 y posterior), puede obtenerlo de className

self.className.components(separatedBy: ".").last!

Lo intenté type(of:...)en Playground con Swift 3. Este es mi resultado. Esta es la versión en formato de código.

print(String(describing: type(of: UIButton.self)))
print(String(describing: type(of: UIButton())))
UIButton.Type
UIButton

Swift 5

 NSStringFromClass(CustomClass.self)

Este tipo de ejemplo para la clase var. No incluya el nombre del paquete.

extension NSObject {
    class var className: String {
        return "\(self)"
    }
}

Si no le gusta el nombre destrozado, puede dictar su propio nombre:

@objc(CalendarViewController) class CalendarViewController : UIViewController {
    // ...
}

Sin embargo, a la larga sería mejor aprender a analizar el nombre destrozado. El formato es estándar y significativo y no cambiará.

A veces, las otras soluciones darán un nombre no útil según el objeto que intente mirar. En ese caso, puede obtener el nombre de la clase como una cadena utilizando lo siguiente.

String(cString: object_getClassName(Any!))

Haga clic en la función en xcode para ver algunos métodos relacionados que son bastante útiles. o marque aquí https://developer.apple.com/reference/objectivec/objective_c_functions

Swift 5 Puede obtener class_name como una cadena con String (que describe: Self.self)

print(String(describing: Self.self))

Lo uso en Swift 2.2

guard let currentController = UIApplication.topViewController() else { return }
currentController.classForCoder.description().componentsSeparatedByString(".").last!

Swift 5.1: -

También puede usar la función genérica para obtener el nombre de clase del objeto como cadena

struct GenericFunctions {
 static func className<T>(_ name: T) -> String {
        return "\(name)"
    }

}

Llame a esta función usando lo siguiente: -

let name = GenericFunctions.className(ViewController.self)

Happy Coding :)

Swift 5.2:

String(describing: type(of: self))