Obtenir un nom de classe de l'objet comme une chaîne de caractères en Swift

Chaîne à partir d'un instance:

String(describing: YourType.self)

Chaîne à partir d'une type:

String(describing: self)

Exemple:

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"

Testé avec class, struct et enum.

Swift 4.2

Ici est l'extension pour obtenir le typeName comme une variable (pour les deux type de la valeur de référence ou type).

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

Comment utiliser:

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

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

Je suggère une telle approche (très 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)"
}

Il n'utilise pas ni introspection ni manuel demangling (pas de magie!).

Voici une démo:

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

Dans Swift 4.1 et maintenant 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 vous n'avez pas une instance autour de:

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 vous avez une instance autour 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

Pour obtenir le nom du type comme une chaîne de caractères dans Swift 4 (je n'ai pas vérifié les versions antérieures), il suffit d'utiliser la chaîne de l'interpolation:

"\(type(of: myViewController))"

Vous pouvez utiliser .self sur un type en lui-même, et le type(of:_) fonction sur un exemple:

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

On peut aussi utiliser des miroirs:

let vc = UIViewController()

String(Mirror(reflecting: vc).subjectType)

NB: Cette méthode peut également être utilisé pour les Structures et les Énumérations. Il y a un displayStyle qui donne une indication de ce type de la structure:

Mirror(reflecting: vc).displayStyle

Le retour est un enum de sorte que vous pouvez:

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

J'ai été à la recherche pour répondre à cette question pendant un certain temps. J'utilise GKStateMachine et aime observer les changements d'état et voulait un moyen facile de voir juste le nom de la classe. Je ne suis pas sûr si c'est juste iOS 10 ou Swift 2.3, mais dans cet environnement, la suite est exactement ce que je veux:

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

//Output:    
// Class Name: GKState

Les solutions ci-dessus ne fonctionne pas pour moi. Le produit principalement les questions de mentionner dans plusieurs commentaires:

MyAppName.ClassName

ou

MyFrameWorkName.ClassName

Cette solutions travaillé sur XCode 9, Swift 3.0:

J'ai nommé il classNameCleaned de sorte qu'il est plus facile d'accès et n'entre pas en conflit avec les futurs className() changements:

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

}

}

Utilisation:

NSViewController.classNameCleaned
MyCustomClass.classNameCleaned

Pour obtenir le nom d'un Swift de la classe d'un objet, par exemple pour la var objet: SomeClass(), utilisez

String(describing: type(of: object))

Pour obtenir le nom d'un Swift classe à partir d'un type de classe, par exemple SomeClass, utilisation:

String(describing: SomeClass.self)

De sortie:

"SomeClass"

Swift 3.0 (mac os 10.10 et ultérieure), vous pouvez l'obtenir à partir d'un nom de classe

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

Vous pouvez obtenir le nom de la classe de faire quelque chose comme:

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

- Je l'utiliser dans Swift 2.2

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

Dans mon cas String(décrivant: auto) a renvoyé quelque chose comme:

< My_project.ExampleViewController: 0x10b2bb2b0>

Mais j'aimerais avoir quelque chose comme getSimpleName sur Android.

J'ai donc créé une petite extension:

extension UIViewController {

    func getSimpleClassName() -> String {
        let describing = String(describing: self)
        if let dotIndex = describing.index(of: "."), let commaIndex = describing.index(of: ":") {
            let afterDotIndex = describing.index(after: dotIndex)
            if(afterDotIndex < commaIndex) {
                return String(describing[afterDotIndex ..< commaIndex])
            }
        }
        return describing
    }

}

Et maintenant il retourne:

ExampleViewController

L'extension de NSObject au lieu de UIViewController devrait également fonctionner. La fonction ci-dessus est également fail-safe 🙂