Отражение

<?php
Reflection::export(new ReflectionClass('Exception'));
?>

Class [ <internal> class Exception ] {

  - Constants [0] {
  }

  - Static properties [0] {
  }

  - Static methods [0] {
  }

  - Properties [6] {
    Property [ <default> protected $message ]
    Property [ <default> private $string ]
    Property [ <default> protected $code ]
    Property [ <default> protected $file ]
    Property [ <default> protected $line ]
    Property [ <default> private $trace ]
  }

  - Methods [9] {
    Method [ <internal> final private method __clone ] {
    }

    Method [ <internal> <ctor> public method __construct ] {

      - Parameters [2] {
        Parameter #0 [ <required> $message ]
        Parameter #1 [ <required> $code ]
      }
    }

    Method [ <internal> final public method getMessage ] {
    }

    Method [ <internal> final public method getCode ] {
    }

    Method [ <internal> final public method getFile ] {
    }

    Method [ <internal> final public method getLine ] {
    }

    Method [ <internal> final public method getTrace ] {
    }

    Method [ <internal> final public method getTraceAsString ] {
    }

    Method [ <internal> public method __toString ] {
    }
  }
}

<?php
/**
 * Прост брояч
 *
 * @return    int
 */
function counter() 
{
    static $c = 0;
    return $c++;
}

// Създаване на инстанция на класа Reflection_Function
$func = new ReflectionFunction('counter');

// Извеждане на основна информация
printf(
    "===> %s функция '%s'\n".
    "     декларирана в %s\n".
    "     на редове от %d до %d\n",
    $func->isInternal() ? 'Вътрешна' : 'Дефинирана от потребителя',
    $func->getName(),
    $func->getFileName(),
    $func->getStartLine(),
    $func->getEndline()
);

// Извеждане на документиращ коментар
printf("---> Документация:\n %s\n", var_export($func->getDocComment(), 1));

// Извеждане на статичните променливи, ако има такива
if ($statics = $func->getStaticVariables())
{
    printf("---> Статични променливи: %s\n", var_export($statics, 1));
}

// Извикване на функция
printf("---> Резултат от извикването: ");
var_dump($func->invoke());


// може да се използва метода export()
echo "\nReflectionFunction::export() резултат:\n";
echo ReflectionFunction::export('counter');
?>

<?php
function foo($a, $b, $c) { }
function bar(Exception $a, &$b, $c) { }
function baz(ReflectionFunction $a, $b = 1, $c = null) { }
function abc() { }

// Създаване на инстанция на Reflection_Function
// с параметри от командния ред
$reflect = new ReflectionFunction($argv[1]);

echo $reflect;

foreach ($reflect->getParameters() as $i => $param) {
    printf(
        "-- Параметър #%d: %s {\n".
        "   Клас: %s\n".
        "   Позволява NULL: %s\n".
        "   Предаден по адрес: %s\n".
        "   Опционален?: %s\n".
        "}\n",
        $i, 
        $param->getName(),
        var_export($param->getClass(), 1),
        var_export($param->allowsNull(), 1),
        var_export($param->isPassedByReference(), 1),
        $param->isOptional() ? 'да' : 'не'
    );
}
?>

<?php
interface Serializable
{
    // ...
}

class Object
{
    // ...
}

/**
 * Клас Counter
 */
class Counter extends Object implements Serializable 
{
    const START = 0;
    private static $c = Counter::START;

    /**
     * Извикване на брояча
     *
     * @access  public
     * @return  int
     */
    public function count() {
        return self::$c++;
    }
}

// Създаване на инстанция на класа ReflectionClass
$class = new ReflectionClass('Counter');

// Извеждане на основна информация
printf(
    "===> %s%s%s %s '%s' [наследява %s]\n" .
    "     деклариран в %s\n" .
    "     на редове от %d да %d\n" .
    "     притежава модификатори %d [%s]\n",
        $class->isInternal() ? 'Вътрешен' : 'Дефиниран от потребителя',
        $class->isAbstract() ? ' абстрактен' : '',
        $class->isFinal() ? ' финален' : '',
        $class->isInterface() ? ' интерфейс' : ' клас',
        $class->getName(),
        var_export($class->getParentClass(), 1),
        $class->getFileName(),
        $class->getStartLine(),
        $class->getEndline(),
        $class->getModifiers(),
        implode(' ', Reflection::getModifierNames($class->getModifiers()))
);

// Извеждане на документиращ коментар
printf("---> Документация:\n %s\n", var_export($class->getDocComment(), 1));

// Извежда интерфейсите реализирани от този клас
printf("---> Реализира:\n %s\n", var_export($class->getInterfaces(), 1));

// Извежда константите на класа
printf("---> Константи: %s\n", var_export($class->getConstants(), 1));

// Извежда свойствата на класа
printf("---> Свойства: %s\n", var_export($class->getProperties(), 1));

// Извежда методите на класа
printf("---> Методи: %s\n", var_export($class->getMethods(), 1));

// Ако класът може да се инстранциира, създава инстранция
if ($class->isInstantiable()) {
    $counter = $class->newInstance();

    echo '---> $counter е инстанция? '; 
    echo $class->isInstance($counter) ? 'да' : 'не';

    echo "\n---> new Object() е инстанция? ";
    echo $class->isInstance(new Object()) ? 'да' : 'не';
}
?>

<?php
class Counter
{
    private static $c = 0;

    /**
     * Увеличава брояча
     *
     * @final
     * @static
     * @access  public
     * @return  int
     */
    final public static function increment()
    {
        return ++self::$c;
    }
}

// Създаване на инстанция на класа ReflectionMethod
$method = new ReflectionMethod('Counter', 'increment');

// Извеждане на основна информация
printf(
    "===> %s%s%s%s%s%s%s метод '%s' (който е %s)\n" .
    "     деклариран в %s\n" .
    "     на редове от %d до %d\n" .
    "     притежава модификатори %d[%s]\n",
        $method->isInternal() ? 'Вътрешен' : 'Дефиниран от потребителя',
        $method->isAbstract() ? ' абстрактен' : '',
        $method->isFinal() ? ' финален' : '',
        $method->isPublic() ? ' public' : '',
        $method->isPrivate() ? ' private' : '',
        $method->isProtected() ? ' protected' : '',
        $method->isStatic() ? ' статичен' : '',
        $method->getName(),
        $method->isConstructor() ? 'конструктор' : 'нормален метод',
        $method->getFileName(),
        $method->getStartLine(),
        $method->getEndline(),
        $method->getModifiers(),
        implode(' ', Reflection::getModifierNames($method->getModifiers()))
);

// Извеждане на документиращ коментар
printf("---> Документация:\n %s\n", var_export($method->getDocComment(), 1));

// Извежда статичните променливи ако съществуват
if ($statics= $method->getStaticVariables()) {
    printf("---> Статични променливи: %s\n", var_export($statics, 1));
}

// Извиква метода
printf("---> Резултат от извикването: ");
var_dump($method->invoke(NULL));
?>

<?php
class String
{
    public $length  = 5;
}

// Създаване на инстанция на класа ReflectionProperty
$prop = new ReflectionProperty('String', 'length');

// Извеждане на основна информация
printf(
    "===> %s%s%s%s свойството '%s' (което беше %s)\n" .
    "     притежава модификатори %s\n",
        $prop->isPublic() ? ' public' : '',
        $prop->isPrivate() ? ' private' : '',
        $prop->isProtected() ? ' protected' : '',
        $prop->isStatic() ? ' статичен' : '',
        $prop->getName(),
        $prop->isDefault() ? 'декларирано по време на компилация' : 'създадено по време на стартиране',
        var_export(Reflection::getModifierNames($prop->getModifiers()), 1)
);

// Създаване на инстанция на String
$obj= new String();

// Връщане на текущата стойност
printf("---> Стойността е: ");
var_dump($prop->getValue($obj));

// Променяне на стойността
$prop->setValue($obj, 10);
printf("---> Установяване а стойността в 10, новата стойност е: ");
var_dump($prop->getValue($obj));

// Dump на обекта
var_dump($obj);
?>

<?php
// Създаване на инстанция на класа ReflectionProperty
$ext = new ReflectionExtension('standard');

// Извеждане на основна информация
printf(
    "Наименование  : %s\n" .
    "Версия        : %s\n" .
    "Функции       : [%d] %s\n" .
    "Константи     : [%d] %s\n" .
    "INI стойности : [%d] %s\n" .
    "Класове       : [%d] %s\n",
        $ext->getName(),
        $ext->getVersion() ? $ext->getVersion() : 'NO_VERSION',
        sizeof($ext->getFunctions()),
        var_export($ext->getFunctions(), 1),

        sizeof($ext->getConstants()),
        var_export($ext->getConstants(), 1),

        sizeof($ext->getINIEntries()),
        var_export($ext->getINIEntries(), 1),

        sizeof($ext->getClassNames()),
        var_export($ext->getClassNames(), 1)
);
?>

<?php
/**
 * Клас My_Reflection_Method
 */
class My_Reflection_Method extends ReflectionMethod
{
    public $visibility = array();

    public function __construct($o, $m)
    {
        parent::__construct($o, $m);
        $this->visibility= Reflection::getModifierNames($this->getModifiers());
    }
}

/**
 * Демонстрационен клас #1
 *
 */
class T {
    protected function x() {}
}

/**
 * Демонстрационен клас #2
 *
 */
class U extends T {
    function x() {}
}

// Извеждане на информацията
var_dump(new My_Reflection_Method('U', 'x'));
?>