get the type/class of a property from its name in swift

Question

Lets say I have this class:

class Node {
    var value: String
    var children: [Node]?
}

If I have the name of one of its properties (for example "children") how can I get its type? (In this case [Node]?)

I imagine having a global function like below will solve my needs:

func typeOfPropertyWithName(name: String, ofClass: AnyClass) -> AnyClass? {
    //???
}

// Example usage:
var arrayOfNodesClass = typeOfPropertyWithName("children", Node.self)

Answer 1

Swift 2 (Note: Reflection changed):

import Foundation

enum PropertyTypes:String
{
    case OptionalInt = "Optional<Int>"
    case Int = "Int"
    case OptionalString = "Optional<String>"
    case String = "String"
    //...
}

extension NSObject{
    //returns the property type
    func getTypeOfProperty(name:String)->String?
    {
        let type: Mirror = Mirror(reflecting:self)

        for child in type.children {
            if child.label! == name
            {
                return String(child.value.dynamicType)
            }
        }
        return nil
    }

    //Property Type Comparison
    func propertyIsOfType(propertyName:String, type:PropertyTypes)->Bool
    {
        if getTypeOfProperty(propertyName) == type.rawValue
        {
            return true
        }

        return false
    }
}

custom class:

class Person : NSObject {
    var id:Int?
    var name : String?
    var email : String?
    var password : String?
    var child:Person?
}

get the type of the "child" property:

let person = Person()
let type = person.getTypeOfProperty("child")
print(type!) //-> Optional<Person>

property type checking:

print( person.propertyIsOfType("email", type: PropertyTypes.OptionalInt) ) //--> false
print( person.propertyIsOfType("email", type: PropertyTypes.OptionalString) //--> true

or

if person.propertyIsOfType("email", type: PropertyTypes.OptionalString)
{
    //true -> do something
}
else
{
    //false -> do something
}

Answer 2

Reflection is achieved in Swift using the global reflect() function. When passing an instance of some type to reflect() it returns a MirrorType, which has a range of properties allowing you to analyze your instance:

var value: Any { get }  
var valueType: Any.Type { get }
var objectIdentifier: ObjectIdentifier? { get }  
var count: Int { get }  
var summary: String { get }  
var quickLookObject: QuickLookObject? { get }  
var disposition: MirrorDisposition { get }    
subscript(i: Int) -> (String, MirrorType) { get }

Answer 3

This seems to work:

func getTypeOfVariableWithName(name: String, inInstance instance: Any) -> String? {
    let mirror = reflect(instance)
    var variableCollection = [String: MirrorType]()

    for item in 0..<mirror.count {
        variableCollection[mirror[item].0] = mirror[item].1
    }

    if let type = variableCollection[name] {
       let longName = _stdlib_getDemangledTypeName(type.value)
       let shortName = split(longName, { $0 == "."}).last
       
       return shortName ?? longName
    }

    return nil
}

Here's some example code on SwiftStub.

---

Edit:

The result for optional values is only "Optional".
The result for arrays is only "Array".
The result for dictionaries is only "Dictionary".

I'm not sure if it is possible to extract what kind of optional/array/dictionary it is. But I guess this would also be the case for custom data structures using generics.

Answer 4

Building on @PeterKreinz answer I needed to be able to check types of inherited properties as well so added a little to his above code:

extension NSObject {

    // Returns the property type
    func getTypeOfProperty (name: String) -> String? {

        var type: Mirror = Mirror(reflecting: self)

        for child in type.children {
            if child.label! == name {
                return String(child.value.dynamicType)
            }
        }
        while let parent = type.superclassMirror() {
            for child in parent.children {
                if child.label! == name {
                    return String(child.value.dynamicType)
                }
            }
            type = parent
        }
        return nil
    }

}

Hope this may help someone.

Swift 3 update:

// Extends NSObject to add a function which returns property type
extension NSObject {

    // Returns the property type
    func getTypeOfProperty (_ name: String) -> String? {

        var type: Mirror = Mirror(reflecting: self)

        for child in type.children {
            if child.label! == name {
                return String(describing: type(of: child.value))
            }
        }
        while let parent = type.superclassMirror {
            for child in parent.children {
                if child.label! == name {
                    return String(describing: type(of: child.value))
                }
            }
            type = parent
        }
        return nil
    }
}

Answer 5

The solution provided by @peter-kreinz using Swift's class Mirror works beautifully when you have an instance of a class, and want to know the types of the properties. However if you want to inspect the properties of a class without having an instance of it you might be interested in my solution.

I have a solution that finds the name and type of a property given any class that inherits from NSObject.

I wrote a lengthy explanation on StackOverflow here, and my project is available here on Github,

In short you can do something like this (but really check out the code Github):

public class func getTypesOfProperties(inClass clazz: NSObject.Type) -> Dictionary<String, Any>? {
    var count = UInt32()
    guard let properties = class_copyPropertyList(clazz, &count) else { return nil }
    var types: Dictionary<String, Any> = [:]
    for i in 0..<Int(count) {
        guard let property: objc_property_t = properties[i], let name = getNameOf(property: property) else { continue }
        let type = getTypeOf(property: property)
        types[name] = type
    }
    free(properties)
    return types
}