Obtenir le nom (chaîne de caractères) d'un type générique dans Swift

J'ai une classe générique de type T et j'aimerais avoir le nom du type qui est passé dans la classe lorsqu'il est instancié. Ici est un exemple.

class MyClass<T> {
    func genericName() -> String {
        //Return the name of T.
    }
}

J'ai été en regardant autour de heures et je n'arrive pas à trouver de toute façon de le faire. Quelqu'un a déjà essayé ce encore?

Toute aide est grandement appréciée.

Grâce

  • Cela dépend de ce que tu veux dire par "nom". Vous pouvez obtenir le nom de la fonction Objective-C vraiment facilement, par l'impression de l'objet de classe. Cependant, pour une classe définie dans Swift, ce nom peut être déformés. Si vous avez besoin d'avoir une certaine idée de ce que c'est, alors cela devrait être suffisant.
InformationsquelleAutor Rob | 2014-08-25
  1. 12

    Un pur moyen rapide d'y parvenir est pas possible.

    Une solution possible est:

    class MyClass<T: AnyObject> {
    func genericName() -> String {
        let fullName: String = NSStringFromClass(T.self)
        let range = fullName.rangeOfString(".", options: .BackwardsSearch)
        if let range = range {
            return fullName.substringFromIndex(range.endIndex)
        } else {
            return fullName
        }
    }
}

    Les limites repose sur le fait qu'il fonctionne avec des classes seulement.

    Si c'est le type générique:

    class TestClass {}

    NSStringFromClass() renvoie le nom complet (y compris l'espace de noms):

    //Prints something like "__lldb_expr_186.TestClass" in playground
NSStringFromClass(TestClass.self)

    C'est pourquoi la touche func recherche la dernière occurrence de la . caractère.

    Testé comme suit:

    var x = MyClass<TestClass>()
x.genericName() // Prints "TestClass"

    Mise à JOUR de Swift 3.0

    func genericName() -> String {
    let fullName: String = NSStringFromClass(T.self)
    let range = fullName.range(of: ".")
    if let range = range {
        return fullName.substring(from: range.upperBound)
    }
    return fullName
}
    • Je vous remercie pour votre réponse. J'ai essayé votre idée. Malheureusement, la plupart des types que je vais mettre dans le générique ne sont pas conformes à AnyObject. Il y a une chance que T pourrait également être un protocole.
    • Dans ce cas, je crains que vous devez attendre pour une meilleure introspection soutien à swift. J'ai des problèmes d'atteindre une chose simple comme se le nom d'un protocole à l'exécution, à l'aide de la pure swift
    InformationsquelleAutor Antonio
  2. 24

    Vous pouvez retourner n'importe quel types de nom par l'aide de la chaîne d'interpolation:

    class MyClass<T> {
    func genericName() -> String {
        return "\(T.self)"
    }
}

    Vous pouvez l'essayer dans une aire de jeu et il fonctionne comme prévu:

    var someClass = MyClass<String>()
someClass.genericName() // Returns "Swift.String"
    • Merci! Vous pouvez également écrire Chaîne(T. auto).
    • Cela semble être le meilleur moyen d'extraire le nom du Type. Court et doux!
    InformationsquelleAutor Bradley Hilton
  3. 15

    String(describing: T.self) dans Swift 3+

    var genericTypeName: String {
    return String(describing: T.self)
}

    Dans le type générique, le nom de type T par la conversion de T.self ou type(of: T.self) à un String. J'ai trouvé que type(of:) n'était pas nécessaire, mais il vaut la peine d'être conscient de depuis dans d'autres cas, il supprime d'autres détails sur le Type.

    L'exemple suivant illustre obtenir le nom du type générique T au sein d'une structure et d'une classe. Il comprend le code pour obtenir le nom du type contenant.

    Exemple, y compris la classe et struct

    struct GenericStruct<T> {
var value: T
var genericTypeName: String {
return String(describing: T.self)
}
var genericTypeDescription: String {
return "Generic Type T: '\(genericTypeName)'"
}
var typeDescription: String {
//type(of:) is necessary here to exclude the struct's properties from the string
        return "Type: '\(type(of: self))'"
}
}
class GenericClass<T> {
var value: T
var genericTypeName: String {
return String(describing: T.self)
}
var genericTypeDescription: String {
return "Generic Type T: '\(genericTypeName)'"
}
var typeDescription: String {
let typeName = String(describing: self)
return "Type: '\(typeName)'"
}
init(value: T) {
self.value = value
}
}
enum TestEnum {
case value1
case value2
case value3
}
let intGenericStruct: GenericStruct<Int> = GenericStruct(value: 1)
print(intGenericStruct.typeDescription)
print(intGenericStruct.genericTypeDescription)
let enumGenericStruct: GenericStruct<TestEnum> = GenericStruct(value: .value2)
print(enumGenericStruct.typeDescription)
print(enumGenericStruct.genericTypeDescription)
let intGenericClass: GenericClass<Int> = GenericClass(value: 1)
print(intGenericClass.typeDescription)
print(intGenericClass.genericTypeDescription)
let enumGenericClass: GenericClass<TestEnum> = GenericClass(value: .value2)
print(enumGenericClass.typeDescription)
print(enumGenericClass.genericTypeDescription)

    Sortie De La Console

    /*
Type: 'GenericStruct<Int>'
Generic Type T: 'Int'
Type: 'GenericStruct<TestEnum>'
Generic Type T: 'TestEnum'
Type: 'GenericClass<Swift.Int>'
Generic Type T: 'Int'
Type: 'GenericClass<TestEnum>'
Generic Type T: 'TestEnum'
*/
    InformationsquelleAutor Mobile Dan
  4. 1

    C'est possible si votre paramètre de type implémente une commune protocole de nommage.

    Dans l'exemple ci-dessous le protocole Named assure que le type générique met en œuvre la name des propriétés de la classe.

    Notez que cela fonctionne avec les deux classes et types de valeur puisque celle-ci peut également être étendue à se conformer à des protocoles, comme illustré à la Int ci-dessous.

    protocol Named {
class var name: String { get }
}
class MyClass<T: Named> {
func genericName() -> String {
return T.name
}
}
extension Int: Named {
static var name: String { return "I am an Int" }
}
class Foo: Named {
class var name: String { return "I am a Foo" }
}
enum Drink: Named {
static var name: String { return "I am a Drink" }
}
MyClass<Int>().genericName()  //I am an Int
MyClass<Foo>().genericName()  //I am a Foo
MyClass<Drink>().genericName()  // I am a Drink
    • C'est une bonne affaire, mais vous devez mentionner que c'est assez limitée - par exemple, pas de paramètres génériques pour les types génériques, et vous ne pouvez pas fournir au public des extensions internes types, ne peut pas mélanger et assortir les spécificateurs d'accès, et ne peut pas étendre les protocoles de cette façon, etc.
    InformationsquelleAutor augustzf
  5. 1

    Une autre solution qui pourrait aider quelqu'un:

    Aire de jeux

    import Foundation
class ClassType<T> {
static func name () -> String
{
return "\(T.self)".componentsSeparatedByString(".").last!
}
}
class MyClass {
}
func testClassName(){
let className = ClassType<MyClass>.name()
print(className)
}
testClassName()
    InformationsquelleAutor brduca