1. Examples
    Ruby  Objective-C  C++  Object Pascal  Java  PHP  Perl  Meta-Object Protocol  Python  ActionScript (as3)  Meta-Type introspection 

2. See also

3. References

4. External links

In computing, type introspection is the ability of a program to examine the type or properties of an object at runtime. Some programming languages possess this capability.

Introspection should not be confused with reflection, which goes a step further and is the ability for a program to manipulate the values, meta-data, properties and/or functions of an object at runtime. Some programming languages - e.g. Java, Python and Go - also possess that capability.

Examples

Ruby

Type introspection is a core feature of Ruby. In Ruby, the Object class (ancestor of every class) provides Object#instance_of? and Object#kind_of? methods for checking the instance's class. The latter returns true when the particular instance the message was sent to is an instance of a descendant of the class in question. For example, consider the following example code (you can immediately try this with the Interactive Ruby Shell):

$ irb

irb(main):001:0> A=Class.new

=> A

irb(main):002:0> B=Class.new A

=> B

irb(main):003:0> a=A.new

=> #

irb(main):004:0> b=B.new

=> #

irb(main):005:0> a.instance_of? A

=> true

irb(main):006:0> b.instance_of? A

=> false

irb(main):007:0> b.kind_of? A

=> true

In the example above, the Class class is used as any other class in Ruby. Two classes are created, A and B, the former is being a superclass of the latter, then one instance of each class is checked. The last expression gives true because A is a superclass of the class of b.

Further, you can directly ask for the class of any object, and "compare" them (code below assumes having executed the code above):

irb(main):008:0> A.instance_of? Class

=> true

irb(main):009:0> a.class

=> A

irb(main):010:0> a.class.class

=> Class

irb(main):011:0> A > B

=> true

irb(main):012:0> B <= A

=> true

Objective-C

In Objective-C, for example, both the generic Object and NSObject (in Cocoa/OpenStep) provide the method isMemberOfClass: which returns true if the argument to the method is an instance of the specified class. The method isKindOfClass: analogously returns true if the argument inherits from the specified class.

For example, say we have an Apple and Orange class inheriting from Fruit.

Now, in the eat method we can write

    if ([sth isKindOfClass:[Fruit class]]) {        // we're actually eating a Fruit, so continue        if ([sth isMemberOfClass:[Apple class]]) {            eatApple(sth);        } else if([sth isMemberOfClass:[Orange class]]) {            eatOrange(sth);        } else {            error();        }    } else {        error();    }

}

Now, when eat is called with a generic object (an id), the function will behave correctly depending on the type of the generic object.

C++

C++ supports type introspection via the run-time type information (RTTI) typeid and dynamic_cast keywords.

The dynamic_cast expression can be used to determine whether a particular object is of a particular derived class. For instance:

Person* p = dynamic_cast(obj);

if (p != nullptr) {

}

The typeid operator retrieves a std::type_info object describing the most derived type of an object:

if (typeid(Person) == typeid(*obj)) {

}

Object Pascal

Type introspection has been a part of Object Pascal since the original release of Delphi, which uses RTTI heavily for visual form design. In Object Pascal, all classes descend from the base TObject class, which implements basic RTTI functionality. Every class's name can be referenced in code for RTTI purposes; the class name identifier is implemented as a pointer to the class's metadata, which can be declared and used as a variable of type TClass.

The language includes an is operator, to determine if an object is or descends from a given class, an as operator, providing a type-checked typecast, and several TObject methods. More deeper introspection (enumerating fields and methods) are traditionally only supported for objects declared in the $M+ (a pragma) state, typically TPersistent, and only for symbols defined in the published section. Delphi 2010 increased this to nearly all symbols.

procedure Form1.MyButtonOnClick(Sender: TObject);

var

   aButton: TButton;   SenderClass: TClass;

begin

   SenderClass := Sender.ClassType; //returns Sender's class pointer   if sender is TButton then   begin      aButton := sender as TButton;      EditBox.Text := aButton.Caption; //Property that the button has but generic objects don't   end   else begin      EditBox.Text := Sender.ClassName; //returns the name of Sender's class as a string   end;

end;

Java

The simplest example of type introspection in Java is the instanceof^[1] operator. The instanceof operator determines whether a particular object belongs to a particular class (or a subclass of that class, or a class that implements that interface). For instance:

if (obj instanceof Person) {

    Person p = (Person)obj;    p.walk();

}

The java.lang.Class^[2] class is the basis of more advanced introspection.

For instance, if it is desirable to determine the actual class of an object (rather than whether it is a member of a particular class), Object.getClass() and Class.getName() can be used:

System.out.println(obj.getClass().getName());

PHP

In PHP introspection can be done using instanceof operator. For instance:

if ($obj instanceof Person) {

}

Perl

Introspection can be achieved using the ref and isa functions in Perl.

We can introspect the following classes and their corresponding instances:

package Animal;

sub new {

    my $class = shift;    return bless {}, $class;

}

package Dog;

use base 'Animal';

package main;

my $animal = Animal->new();

my $dog = Dog->new();

using:

print "This is an Animal.\" if ref $animal eq 'Animal';

print "Dog is an Animal.\" if $dog->isa('Animal');

Meta-Object Protocol

Much more powerful introspection in Perl can be achieved using the Moose object system^[3] and the Class::MOP meta-object protocol,^[4] for example this is how you can check if a given object does a role X:

if ($object->meta->does_role("X")) {

}

This is how you can list fully qualified names of all of the methods that can be invoked on the object, together with the classes in which they were defined:

for my $method ($object->meta->get_all_methods) {

}

Python

The most common method of introspection in Python is using the dir function to detail the attributes of an object. For example:

class Foo(object):

    def __init__(self, val):        self.x = val    def bar(self):        return self.x

...

>>> dir(Foo(5))

['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__',

'__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__',

'__repr__', '__setattr__', '__str__', '__weakref__', 'bar', 'x']

Also, the built-in functions type and isinstance can be used to determine what an object is while hasattr can determine what an object does. For example:

>>> a = Foo(10)

>>> b = Bar(11)

>>> type(a)

• Sultans Of String
• Sultans of Tadjoura
• Sultans of Tadjourah
• Sultans of the Ottoman Empire
• Sultan Sooud Al-Qassemi
• Sultans Trail
• Sultans trail
• Sultan Suleiman
• Sultan Syarif Abdurrahman Stadium
• Sultan Syarif Kasim II
• Sultan Syarif Kasim II Int'l Airport
• Sultan Syarif Kasim II State Islamic University
• Sultan Syarif Qasim II International Airport
• Sultan Tamihi
• Sultan (Telugu film)
• Sultante of Khandesh
• Sultan the film
• Sultan Tikhaev
• Sultan Tit
• Sultanu
• Sultan ul Madaris
• Sultanu'l-Wa'izin Shirazi
• Sultan us-Selatin
• Sultan Yazidis
• Sultan Yusef ben Hassan