Obtendo o nome da classe de um objeto como Stringusando:

object_getClassName(myViewController)

retorna algo como isto:

_TtC5AppName22CalendarViewController

Eu estou procurando a pura versão: "CalendarViewController". Como obtenho uma sequência limpa do nome da classe?

Encontrei algumas tentativas de perguntas sobre isso, mas não uma resposta real. Não é possível?

String de uma instância :

String(describing: YourType.self)

String de um tipo :

String(describing: self)

Exemplo:

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"

Testado com class, structe enum.

ATUALIZADO PARA SWIFT 5

Podemos obter descrições bonitas de nomes de tipos usando a variável de instância através do Stringinicializador e criar novos objetos de uma determinada classe

Como, por exemplo print(String(describing: type(of: object))). Onde objectpode ser uma variável de instância como matriz, dicionário, an Int, a NSDateetc.

Como NSObjecté a classe raiz da maioria das hierarquias de classe Objective-C, você pode tentar fazer uma extensão para NSObjectobter o nome da classe de cada subclasse de NSObject. Como isso:

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

Ou você pode criar uma função estática, cujo parâmetro é do tipo Any(O protocolo ao qual todos os tipos estão implicitamente em conformidade) e retorna o nome da classe como String. Como isso:

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

Agora você pode fazer algo assim:

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

    }
}

Além disso, uma vez que podemos obter o nome da classe como String, podemos instanciar novos objetos dessa classe :

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

Talvez isso ajude alguém por aí!

Swift 5

Aqui está a extensão para obter a typeNamevariável (trabalhe com o tipo de valor ou tipo de referência).

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

Como usar:

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

Sugiro tal abordagem ( muito 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)"
}

Ele não usa nem introspecção nem desmontagem manual ( sem mágica! ).

Aqui está uma demonstração:

// 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

Se você digitar Foo, o código a seguir fornecerá o "Foo"Swift 3 e o Swift 4:

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

O problema com a maioria das respostas aqui é que elas fornecem "Foo.Type"a sequência resultante quando você não tem nenhuma instância do tipo, quando o que você realmente deseja é justo "Foo". A seguir "Foo.Type", como mencionado em várias outras respostas.

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

A type(of:)peça é desnecessária se você apenas quiser "Foo".

No Swift 4.1 e agora no 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)

Se você não tem uma instância por perto:

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

Se você tem uma instância em torno de:

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 obter o nome de uma classe Swift de um objeto, por exemplo, para o objeto var: SomeClass (), use

String(describing: type(of: object))

Para obter o nome de uma classe Swift de um tipo de classe, por exemplo, SomeClass, use:

String(describing: SomeClass.self)

Resultado:

"SomeClass"

Você pode tentar desta maneira:

self.classForCoder.description()

Você pode usar a função de biblioteca padrão Swift chamada _stdlib_getDemangledTypeNameassim:

let name = _stdlib_getDemangledTypeName(myViewController)

Para obter o nome do tipo como uma string no Swift 4 (não verifiquei as versões anteriores), basta usar a interpolação de string:

"\(type(of: myViewController))"

Você pode usar .selfem um tipo em si e a type(of:_)função em uma instância:

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

Pode-se também usar espelhos:

let vc = UIViewController()

String(Mirror(reflecting: vc).subjectType)

NB: Este método também pode ser usado para estruturas e enums. Existe um displayStyle que fornece uma indicação de que tipo de estrutura:

Mirror(reflecting: vc).displayStyle

O retorno é uma enumeração para que você possa:

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

Swift 5.1

Você pode obter nomes de classe, estrutura, enumeração, protocolo e NSObject Self.self.

print("\(Self.self)")

Swift 3.0: você pode criar uma extensão como esta. Devolve o nome da classe sem o nome do projeto

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

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

Você pode estender NSObjectProtocolno Swift 4 assim:

import Foundation

extension NSObjectProtocol {

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

Isso tornará a variável calculada classNamedisponível para TODAS as classes. Usar isso dentro de um print()in CalendarViewControllerserá impresso "CalendarViewController"no console.

Eu tenho procurado esta resposta de vez em quando por um tempo. Eu uso GKStateMachine e gosto de observar alterações de estado e queria uma maneira fácil de ver apenas o nome da classe. Não tenho certeza se é apenas o iOS 10 ou o Swift 2.3, mas nesse ambiente, o seguinte faz exatamente o que eu quero:

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

// Output:    
// Class Name: GKState

Você pode obter o nome da classe fazendo algo como:

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

Para obter o nome da classe como String, declare sua classe da seguinte maneira

@objc(YourClassName) class YourClassName{}

E obtenha o nome da classe usando a seguinte sintaxe

NSStringFromClass(YourClassName)

Experimente reflect().summarya classe própria ou a instância dynamicType. Desembrulhe os opcionais antes de obter dynamicType, caso contrário, o dynamicType é o wrapper 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;

O resumo é um caminho de classe com os tipos genéricos descritos. Para obter um nome de classe simples do resumo, tente 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;
}

As soluções acima não funcionaram para mim. O produzido principalmente as questões mencionadas em vários comentários:

MyAppName.ClassName

ou

MyFrameWorkName.ClassName

Essas soluções funcionaram no XCode 9, Swift 3.0:

Eu o nomeei classNameCleanedpara facilitar o acesso e não entrar em conflito com className()alterações futuras :

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 e posterior), você pode obtê-lo em className

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

Eu tentei type(of:...)no Playground com o Swift 3. Esse é o meu resultado. Esta é a versão em 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 exemplo para a classe var. Não inclua o nome do pacote.

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

Se você não gosta do nome mutilado, pode ditar seu próprio nome:

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

No entanto, seria melhor a longo prazo aprender a analisar o nome mutilado. O formato é padrão e significativo e não muda.

Às vezes, as outras soluções dão um nome não útil, dependendo do objeto que você está tentando olhar. Nesse caso, você pode obter o nome da classe como uma string usando o seguinte.

String(cString: object_getClassName(Any!))

⌘ clique na função no xcode para ver alguns métodos relacionados que são bastante úteis. ou verifique aqui https://developer.apple.com/reference/objectivec/objective_c_functions

Swift 5 Você pode obter class_name como uma string com String (descrevendo: Self.self)

print(String(describing: Self.self))

Eu uso no Swift 2.2

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

Swift 5.1: -

Você também pode usar a função genérica para obter o nome da classe do objeto como string

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

}

Chame esta função usando o seguinte: -

let name = GenericFunctions.className(ViewController.self)

Happy Coding :)

Swift 5.2:

String(describing: type(of: self))