Obtenez de l'utilisateur, version lisible du nom de la classe dans swift (en objc NSStringFromClass était très bien)

Est-il un équivalent de NSStringFromClass dans Swift qui donne à l'utilisateur-version lisible du nom de la classe? J'ai essayé de l'utiliser avec un modèle Swift classe que j'ai créée, mais comme vous pouvez le voir, le résultat semble être le compilateur de la représentation interne de la classe nom:

println(NSStringFromClass(MyClass.self))

Résultat:

_TtC5test7MyClass

J'ai essayé d'ajouter le @objc attribut de la classe, et d'en faire une sous-classe de NSObject, mais il ne fait aucune différence. J'ai découvert que si je remplace MyClass avec un Objectif-C classe du même nom, et l'importer dans la transition de l'en-tête, il me donne "MyClass", mais cela ne devrait pas être nécessaire.

Une autre option serait de faire un protocole pour cela, que chaque classe, que je veux utiliser ce moyen doit être conforme à:

protocol Nameable {
    class var className: String { get }
}

Cependant, il serait plus facile d'avoir un haut-moyen de le faire dans la langue.

InformationsquelleAutor jfla | 2014-06-08

cocoa-touch swift

61

Vous pouvez maintenant juste à faire:
```
String(MyClass)
```
- Cela me fait excessivement heureux! Merci Natasha robot.
- Ce doit être marqué comme réponse maintenant.
- Dans Swift 3 cela ne fonctionne pas plus. La Swift 3 convertisseur changé de Chaîne(décrivant: MyClass) mais qui ne fonctionne pas non plus.
- avez-vous essayé String(describing: self) ou simplement de passage de l'objet let object = MyClass() String(describing: object)
InformationsquelleAutor NatashaTheRobot

nouveau format basé sur xcode 6 beta 5.

(project_name).(class_name)

func getName(classType:AnyClass) -> String {

    let classString = NSStringFromClass(classType.self)
    let range = classString.rangeOfString(".", options: NSStringCompareOptions.CaseInsensitiveSearch, range: Range<String.Index>(start:classString.startIndex, end: classString.endIndex), locale: nil)
    return classString.substringFromIndex(range!.endIndex)
}

Dernier Xcode 6.3 Swift 1.2

si vous avez besoin d'une extension ou vous pouvez mettre sur n'importe quel objet commun:

public extension NSObject{
    public class var nameOfClass: String{
        return NSStringFromClass(self).componentsSeparatedByString(".").last!
    }

    public var nameOfClass: String{
        return NSStringFromClass(self.dynamicType).componentsSeparatedByString(".").last!
    }
}

classType.self devrait être écrit comme classType
cela fonctionne aussi: NSStringFromClass(self).componentsSeparatedByString(".").last!
Comme @NatashaTheRobot états-dessous. Utilisez simplement String(MyClass) maintenant.

InformationsquelleAutor ImpactZero

13

Swift 3

type(of: self) imprime ModuleName.ClassName

String(describing: type(of: self)) imprime ClassName

InformationsquelleAutor Timonea
5

Pour le moment, il n'y a aucun moyen fiable de le faire. Voir un des développeurs d'Apple commentaire de https://devforums.apple.com/thread/227425

Swift actuellement nous n'avons pas beaucoup dans la voie de l'introspection.

Il y a une introspection de la machinerie qui est utilisé pour le
les aires de jeux. Je ne sais pas si c'est censé être de l'API.

Certains Swift
les méthodes et les variables peuvent être examinés à l'aide de l'Objective-C runtime
l'introspection. C'est probablement la meilleure solution aujourd'hui.

Swift ne ont la notion de metatype, un peu analogue au type de Classe en Objective C. Vous pouvez le trouver à l'aide de TypeName.self, par exemple:
```
class Foo {
    @required  init() {
    }
}

var normalFoo : Foo = Foo()
var fooType : Foo.Type = Foo.self;
var fooFromMetatype : Foo = fooType();
```
Peut-être, par la libération de temps, metatypes comprendront de plus en plus à l'introspection capacités. Je suggère le dépôt d'un Radar de demande de fonctionnalité pour cette.

InformationsquelleAutor Adam Wright
5

Dans Swift 2 beta 4, vous pouvez obtenir de l'information via le type de l'objet:
```
let className = "\(String.self)"   //gives: "Swift.String"
```
ou si vous avez une instance:
```
let s = "Hello World"
let className = "\(s.dynamicType)" //gives: "Swift.String"
```
Vous obtenez le Module.Class résultat, comme:
```
Swift.String
ABC.MyGenericClass<Swift.Int>
```
Assez drôle, le Type d'objet retourné ne paraît pas conforme à la CustomStringConvertible protocole. Par conséquent, il n'a pas de description de la propriété, bien que la "" modèle encore fait la bonne chose.

P. S.: Avant b4 la même chose peut être accomplie à l'aide de réfléchir(obj.dynamicType).résumé.
- C'est cool, mais jusqu'à ce qu'ils ont explicitement className() la méthode quelque part je suis un peu méfiant. Résumé pourrait être le nom de la classe pour l'instant, mais il n'y a pas de garanties, il va rester de cette façon.
InformationsquelleAutor hnh
3

Dans Swift v3.0, cela a fonctionné pour moi:
```
String.init(describing: self.self)
```
InformationsquelleAutor Coach Roebuck
2

----- Mise à jour -----

Comme @ThomasW mentionné, pour Swift 4, nous avons besoin d'utiliser String(describing:type(of:self))

----- L'ancien poste ----

Je préfère utiliser String(self.dynamicType)

L'utiliser dans mon projet https://github.com/JakeLin/SwiftWeather/blob/e7165b0919dda53fd7fcba9b43fdfe150d73c6f8/SwiftWeather/ForecastView.swift#L135
- Pour Swift 4 cela ne fonctionne plus, mais String(describing:type(of:self)) n'.
- Merci, ont mis à jour le post pour refléter les modifications.
InformationsquelleAutor Jake Lin
1

Si vous voulez avoir que le nom de la classe dans swift, vous pouvez analyser la chaîne de caractères retournée par NSStringFromClass().

Ceci est fait dans nameOfClass.swift de la INSwift Github:
https://github.com/indieSoftware/INSwift
- Notez que cela fonctionne uniquement avec les types de classe -- si vous l'essayez à-dire un protocole Swift va se plaindre error: type 'MyProtocol' does not conform to protocol 'AnyObject'
InformationsquelleAutor Sven

Vous shouls maintenant être en mesure d'utiliser les éléments suivants pour récupérer le nom de la classe dans swift

let nameSpaceClassName = NSStringFromClass(RWTCountryPopoverViewController.self)
let className = nameSpaceClassName.componentsSeparatedByString(".").last! as String

InformationsquelleAutor TheCodingArt

1

C'est un peu plus courte. Pas besoin de NSStringFromClass
```
MyObject.self.description().componentsSeparatedByString(".").last!
```
InformationsquelleAutor nacho4d

Ici est Swift 3+, Xcode, 8+ exemple avec le code:

class MySuperbClass{
    let a = 4
    func getClassName() -> String? {
        return String(describing: type(of:self)).components(separatedBy: ".").first
    }
}


let className = String(describing: type(of:MySuperbClass.self)).components(separatedBy: ".").first
//className = "MySuperbClass" 
let classNameFromObject = MySuperbClass().getClassName()
//classNameFromObject = "MySuperbClass"

InformationsquelleAutor Rafat touqir Rafsun

0
```
myObject.description().componentsSeparatedByString(" ").first!
```
Ce n'est pas exactement ce que vous voulez - il va ajouter indésirables conduisant '<' et les ':'. Mais quand je suis débogage j'valeur de la vitesse au-dessus de la propreté donc cette rapide + sale truc a fonctionné pour moi.

InformationsquelleAutor Rolf Hendriks

Swift 3

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

InformationsquelleAutor anoop4real

Swift 4

super.init(nibName:String(describing:MyClass.self), bundle: nil)

InformationsquelleAutor DMagaro

Vous devez vous connecter pour publier un commentaire.