PHP
downloads | documentation | faq | getting help | mailing lists | wiki | reporting bugs | php.net sites | links | conferences | my php.net

search for in the

Type Hinting> <Comparación de Objetos
Last updated: Fri, 22 Aug 2008

view this page in

Reflección

Introducción

PHP 5 viene con un API completa de reflexión que agrega la habilidad de hacer ingeniería inversa de clases, interfaces, funciones y métodos así como extensiones. Adicionalmente, el API de reflexión también ofrece formas de obtener los comentarios de los documentos para funciones, clases y métodos.

El API de reflexión es una extensión orientada a objetos para el compilador Zend, consistente de las siguientes clases:

<?php
class Reflection { }
interface 
Reflector { }
class 
ReflectionException extends Exception { }
class 
ReflectionFunction implements Reflector { }
class 
ReflectionParameter implements Reflector { }
class 
ReflectionMethod extends ReflectionFunction { }
class 
ReflectionClass implements Reflector { }
class 
ReflectionObject extends ReflectionClass { }
class 
ReflectionProperty implements Reflector { }
class 
ReflectionExtension implements Reflector { }
?>

Note: Para detalles de estas clases, de una mirada a los siguientes capítulos.

Si fuéramos a ejecutar el código en el siguiente ejemplo:

Example #1 Uso básico del API reflexión

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

El resultado del ejemplo seria:

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 ] {
    }
  }
}

ReflectionFunction

La clase ReflectionFunction te permite funciones de ingeniería inversa.

<?php
class ReflectionFunction implements Reflector
{
    final private 
__clone()
    public 
object __construct(string name)
    public 
string __toString()
    public static 
string export()
    public 
string getName()
    public 
bool isInternal()
    public 
bool isUserDefined()
    public 
string getFileName()
    public 
int getStartLine()
    public 
int getEndLine()
    public 
string getDocComment()
    public array 
getStaticVariables()
    public 
mixed invoke(mixedargs)
    public 
mixed invokeArgs(array args)
    public 
bool returnsReference()
    public 
ReflectionParameter[] getParameters()
    public 
int getNumberOfParameters()
    public 
int getNumberOfRequiredParameters()
}
?>

Note: invokeArgs() fue agregado en PHP 5.1.0.

Para entender directamente una función, primero tiene que crear una isntancia de la clase ReflectionFunction. Hasta entonces puede llamar cualquier de los métodos anteriores en esta instancia.

Example #2 Usando la clase ReflectionFunction

<?php
/**
 * A simple counter
 *
 * @return    int
 */
function counter() 
{
    static 
$c 0;
    return 
$c++;
}

// Create an instance of the Reflection_Function class
$func = new ReflectionFunction('counter');

// Print out basic information
printf(
    
"===> The %s function '%s'\n".
    
"     declared in %s\n".
    
"     lines %d to %d\n",
    
$func->isInternal() ? 'internal' 'user-defined',
    
$func->getName(),
    
$func->getFileName(),
    
$func->getStartLine(),
    
$func->getEndline()
);

// Print documentation comment
printf("---> Documentation:\n %s\n"var_export($func->getDocComment(), 1));

// Print static variables if existant
if ($statics $func->getStaticVariables())
{
    
printf("---> Static variables: %s\n"var_export($statics1));
}

// Invoke the function
printf("---> Invokation results in: ");
var_dump($func->invoke());


// you may prefer to use the export() method
echo "\nReflectionFunction::export() results:\n";
echo 
ReflectionFunction::export('counter');
?>

Note: El método invoke() acepta un número de variable de argumentos los cuales son pasados a la función tal y como se hace en call_user_func().

ReflectionParameter

La clase ReflectionParameter obtiene información acerca de los parámetros de una función o un método.

<?php
class ReflectionParameter implements Reflector
{
    final private 
__clone()
    public 
object __construct(string name)
    public 
string __toString()
    public static 
string export()
    public 
string getName()
    public 
bool isPassedByReference()
    public 
ReflectionClass getClass()
    public 
bool allowsNull()
    public 
bool isOptional()
    public 
bool isDefaultValueAvailable()
    public 
mixed getDefaultValue()
}
?>

Note: getDefaultValue(), isDefaultValueAvailable(), isOptional() fueron agregados en PHP 5.1.0.

Para entender los parámetros de la función, tendrá primero que crear una instancia de la clase ReflectionFunction o de la clase ReflectionMethod y entonces usar sus método getParameters() para obtener una matriz de parámetros.

Example #3 Usando la clase ReflectionParameter

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

// Create an instance of Reflection_Function with the
// parameter given from the command line.    
$reflect = new ReflectionFunction($argv[1]);

echo 
$reflect;

foreach (
$reflect->getParameters() as $i => $param) {
    
printf(
        
"-- Parameter #%d: %s {\n".
        
"   Class: %s\n".
        
"   Allows NULL: %s\n".
        
"   Passed to by reference: %s\n".
        
"   Is optional?: %s\n".
        
"}\n",
        
$i
        
$param->getName(),
        
var_export($param->getClass(), 1),
        
var_export($param->allowsNull(), 1),
        
var_export($param->isPassedByReference(), 1),
        
$param->isOptional() ? 'yes' 'no'
    
);
}
?>

ReflectionClass

La clase ReflectionClass te permite hacer ingeniería inversa de clases.

<?php
class ReflectionClass implements Reflector
{
    final private 
__clone()
    public 
object __construct(string name)
    public 
string __toString()
    public static 
string export()
    public 
string getName()
    public 
bool isInternal()
    public 
bool isUserDefined()
    public 
bool isInstantiable()
    public 
bool hasConstant(string name)
    public 
bool hasProperty(string name)
    public 
bool hasMethod(string name)
    public 
string getFileName()
    public 
int getStartLine()
    public 
int getEndLine()
    public 
string getDocComment()
    public 
ReflectionMethod getConstructor()
    public 
ReflectionMethod getMethod(string name)
    public 
ReflectionMethod[] getMethods()
    public 
ReflectionProperty getProperty(string name)
    public 
ReflectionProperty[] getProperties()
    public array 
getConstants()
    public 
mixed getConstant(string name)
    public 
ReflectionClass[] getInterfaces()
    public 
bool isInterface()
    public 
bool isAbstract()
    public 
bool isFinal()
    public 
int getModifiers()
    public 
bool isInstance(stdclass object)
    public 
stdclass newInstance(mixedargs)
    public 
ReflectionClass getParentClass()
    public 
bool isSubclassOf(ReflectionClass class)
    public array 
getStaticProperties()
    public array 
getDefaultProperties()
    public 
bool isIterateable()
    public 
bool implementsInterface(string name)
    public 
ReflectionExtension getExtension()
    public 
string getExtensionName()
}
?>

Note: hasConstant(), hasMethod(), hasProperty() fueron agregados en PHP 5.1.0.

Para entender una clase, primero tendrá que crear una instancia de la clase ReflectionClass. Entonces puede llamar cualquiera de los métodos anteriores en esta instancia.

Example #4 Usando la clase ReflectionClass

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

class 
Object
{
    
// ...
}

/**
 * A counter class
 */
class Counter extends Object implements Serializable 
{
    const 
START 0;
    private static 
$c Counter::START;

    
/**
     * Invoke counter
     *
     * @access  public
     * @return  int
     */
    
public function count() {
        return 
self::$c++;
    }
}

// Create an instance of the ReflectionClass class
$class = new ReflectionClass('Counter');

// Print out basic information
printf(
    
"===> The %s%s%s %s '%s' [extends %s]\n" .
    
"     declared in %s\n" .
    
"     lines %d to %d\n" .
    
"     having the modifiers %d [%s]\n",
        
$class->isInternal() ? 'internal' 'user-defined',
        
$class->isAbstract() ? ' abstract' '',
        
$class->isFinal() ? ' final' '',
        
$class->isInterface() ? 'interface' 'class',
        
$class->getName(),
        
var_export($class->getParentClass(), 1),
        
$class->getFileName(),
        
$class->getStartLine(),
        
$class->getEndline(),
        
$class->getModifiers(),
        
implode(' 'Reflection::getModifierNames($class->getModifiers()))
);

// Print documentation comment
printf("---> Documentation:\n %s\n"var_export($class->getDocComment(), 1));

// Print which interfaces are implemented by this class
printf("---> Implements:\n %s\n"var_export($class->getInterfaces(), 1));

// Print class constants
printf("---> Constants: %s\n"var_export($class->getConstants(), 1));

// Print class properties
printf("---> Properties: %s\n"var_export($class->getProperties(), 1));

// Print class methods
printf("---> Methods: %s\n"var_export($class->getMethods(), 1));

// If this class is instantiable, create an instance
if ($class->isInstantiable()) {
    
$counter $class->newInstance();

    echo 
'---> $counter is instance? '
    echo 
$class->isInstance($counter) ? 'yes' 'no';

    echo 
"\n---> new Object() is instance? ";
    echo 
$class->isInstance(new Object()) ? 'yes' 'no';
}
?>

Note: El método newInstance() acepta un número variable de argumentos los cuales son pasados a la función tal y como si se usara call_user_func().

Note: $class = new ReflectionClass('Foo'); $class->isInstance($arg) es equivalente a $arg instanceof Foo o is_a($arg, 'Foo').

ReflectionMethod

La clase ReflectionMethod te permite hacer ingenieria inversa de los métodos de la clase.

<?php
class ReflectionMethod extends ReflectionFunction
{
    public 
__construct(mixed class, string name)
    public 
string __toString()
    public static 
string export()
    public 
mixed invoke(stdclass objectmixedargs)
    public 
moxed invokeArgs(stdclass object, array args)
    public 
bool isFinal()
    public 
bool isAbstract()
    public 
bool isPublic()
    public 
bool isPrivate()
    public 
bool isProtected()
    public 
bool isStatic()
    public 
bool isConstructor()
    public 
bool isDestructor()
    public 
int getModifiers()
    public 
ReflectionClass getDeclaringClass()

    
// Inherited from ReflectionFunction
    
final private __clone()
    public 
string getName()
    public 
bool isInternal()
    public 
bool isUserDefined()
    public 
string getFileName()
    public 
int getStartLine()
    public 
int getEndLine()
    public 
string getDocComment()
    public array 
getStaticVariables()
    public 
bool returnsReference()
    public 
ReflectionParameter[] getParameters()
    public 
int getNumberOfParameters()
    public 
int getNumberOfRequiredParameters()
}
?>

Para entender los métodos, primero tendrá que crear una instancia de la clase ReflectionMethod. Puede entonces llamar cualquiera de los métodos anteriores en esta instancia.

Example #5 Usando la clase ReflectionMethod

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

    
/**
     * Increment counter
     *
     * @final
     * @static
     * @access  public
     * @return  int
     */
    
final public static function increment()
    {
        return ++
self::$c;
    }
}

// Create an instance of the Reflection_Method class
$method = new ReflectionMethod('Counter''increment');

// Print out basic information
printf(
    
"===> The %s%s%s%s%s%s%s method '%s' (which is %s)\n" .
    
"     declared in %s\n" .
    
"     lines %d to %d\n" .
    
"     having the modifiers %d[%s]\n",
        
$method->isInternal() ? 'internal' 'user-defined',
        
$method->isAbstract() ? ' abstract' '',
        
$method->isFinal() ? ' final' '',
        
$method->isPublic() ? ' public' '',
        
$method->isPrivate() ? ' private' '',
        
$method->isProtected() ? ' protected' '',
        
$method->isStatic() ? ' static' '',
        
$method->getName(),
        
$method->isConstructor() ? 'the constructor' 'a regular method',
        
$method->getFileName(),
        
$method->getStartLine(),
        
$method->getEndline(),
        
$method->getModifiers(),
        
implode(' 'Reflection::getModifierNames($method->getModifiers()))
);

// Print documentation comment
printf("---> Documentation:\n %s\n"var_export($method->getDocComment(), 1));

// Print static variables if existant
if ($statics$method->getStaticVariables()) {
    
printf("---> Static variables: %s\n"var_export($statics1));
}

// Invoke the method
printf("---> Invokation results in: ");
var_dump($method->invoke(NULL));
?>

Note: Tratar de invocar métodos private, protected o abstract resultará en una excepción siendo arrojada del método invoke().

Note: Para métodos static como se vió anteriormente, se debe a invoke() se debe pasar NULL como primer argumento. Para métodos no estáticos, se pasa una instancia de la clase.

ReflectionProperty

La clase ReflectionProperty te permite hacer ingeniería inversa a las propiedades de la clase.

<?php
class ReflectionProperty implements Reflector
{
    final private 
__clone()
    public 
__construct(mixed class, string name)
    public 
string __toString()
    public static 
string export()
    public 
string getName()
    public 
bool isPublic()
    public 
bool isPrivate()
    public 
bool isProtected()
    public 
bool isStatic()
    public 
bool isDefault()
    public 
int getModifiers()
    public 
mixed getValue(stdclass object)
    public 
void setValue(stdclass objectmixed value)
    public 
ReflectionClass getDeclaringClass()
}
?>

Para entender las propiedades, se debe primero crear una instancia de la clase ReflectionProperty. Y entonces puede llamar cualquiera de los métodos anteriores sobre esta instancia.

Example #6 Usando la clase ReflectionProperty

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

// Create an instance of the ReflectionProperty class
$prop = new ReflectionProperty('String''length');

// Print out basic information
printf(
    
"===> The%s%s%s%s property '%s' (which was %s)\n" .
    
"     having the modifiers %s\n",
        
$prop->isPublic() ? ' public' '',
        
$prop->isPrivate() ? ' private' '',
        
$prop->isProtected() ? ' protected' '',
        
$prop->isStatic() ? ' static' '',
        
$prop->getName(),
        
$prop->isDefault() ? 'declared at compile-time' 'created at run-time',
        
var_export(Reflection::getModifierNames($prop->getModifiers()), 1)
);

// Create an instance of String
$obj= new String();

// Get current value
printf("---> Value is: ");
var_dump($prop->getValue($obj));

// Change value
$prop->setValue($obj10);
printf("---> Setting value to 10, new value is: ");
var_dump($prop->getValue($obj));

// Dump object
var_dump($obj);
?>

Note: Trying to get or set private or protected class property's values will result in an exception being thrown.

ReflectionExtension

La clase ReflectionExtension te permite hacer ingeniería inversa a extensiones. Puede obtener todas las extensiones cargadas en tiempo de ejecución usando get_loaded_extensions().

<?php
class ReflectionExtension implements Reflector {
    final private 
__clone()
    public 
__construct(string name)
    public 
string __toString()
    public static 
string export()
    public 
string getName()
    public 
string getVersion()
    public 
ReflectionFunction[] getFunctions()
    public array 
getConstants()
    public array 
getINIEntries()
    public 
ReflectionClass[] getClasses()
    public array 
getClassNames()
}
?>

Para entender una extensión, primero se tiene que crear una instancia de la clase ReflectionExtension. Y entonces puede llamarse a cualquiera de los métodos mencionados arriba sobre esa instancia.

Example #7 Usando la clase ReflectionExtension

<?php
// Create an instance of the ReflectionProperty class
$ext = new ReflectionExtension('standard');

// Print out basic information
printf(
    
"Name        : %s\n" .
    
"Version     : %s\n" .
    
"Functions   : [%d] %s\n" .
    
"Constants   : [%d] %s\n" .
    
"INI entries : [%d] %s\n" .
    
"Classes     : [%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)
);
?>

Extendiendo las clases de reflexión

En caso de que se quiera crear una versión especializada de las clases integradas (es decir, para crear HTML con colores cuando se exporta, tener fácil acceso a las variables de los miembros en lugar de los métodos o tener métodos de utilería), se puede simplemente extenderlos.

Example #8 Extendiendo las clase integradas

<?php
/**
 * My Reflection_Method class
 */
class My_Reflection_Method extends ReflectionMethod
{
    public 
$visibility '';

    public function 
__construct($o$m)
    {
        
parent::__construct($o$m);
        
$this->visibilityReflection::getModifierNames($this->getModifiers());
    }
}

/**
 * Demo class #1
 *
 */
class {
    protected function 
x() {}
}

/**
 * Demo class #2
 *
 */
class extends {
    function 
x() {}
}

// Print out information
var_dump(new My_Reflection_Method('U''x'));
?>

Note: Precaución: Si se desea sobreescribir el constructor, recuerde llamar el constructor padre _antes_ que cualquier otro código que se inserte. El no hacerlo así resultará en: Fatal error: Internal error: Failed to retrieve the reflection object



Type Hinting> <Comparación de Objetos
Last updated: Fri, 22 Aug 2008
 
add a note add a note User Contributed Notes
Reflección
gromit at mailinator dot com
29-Jul-2008 11:37
Be aware that calling the method newInstanceArgs with an empty array will still call the constructor with no arguments. If the class has no constructor then it will generate an exception.

You need to check if a constructor exists before calling this method or use try and catch to act on the exception.
meecrob at k42b3 dot com
20-Jun-2008 01:47
When your class extends a parent class you maybe want the name
of them. Using getParentClass() is maybe a bit confusing. When
you want the name as string try the following.

<?php
$class
= new ReflectionClass('whatever');

$parent = (array) $class->getParentClass();

if(
array_key_exists('name', $parent))
{
   
# name of the parent class
   
$parent = parent['name'];
}
else
{
   
# no parent class avaible
   
$parent = false;
}
?>

When you turn getParentClass() to an array it will result either
array(0 => false) when no parent class exist or
array('name' => 'name of the parent class'). Tested on PHP 5.2.4
fgm at riff dot org
11-May-2008 10:44
The note about the signature of the ReflectionParameter constructor is actually incomplete, at least in 5.2.5: it is possible to use an integer for the second parameter, and the constructor will use it to return the n-th parameter.

This allows you to obtain proper ReflectionParameter objects even when documenting code from extensions which (strangely enough) define several parameters with the same name. The string-based constructor always returns the first parameter with the matching name, whereas the integer-based constructor correctly returns the n-th parameter.

So, in short, this works:
<?php
// supposing the extension defined something like:
// Some_Class::someMethod($a, $x, $y, $x, $y)
$p = new ReflectionParameter(array('Some_Class', 'someMethod'), 4);
// returns the last parameter, whereas
$p = new ReflectionParameter(array('Some_Class', 'someMethod'), 'y');
// always returns the first $y at position 2
?>
Niels Jaeckel
09-Apr-2008 12:32
I think there are still some limitations in the reflection abilities:

* ReflectionClass :: getConstants() returns an associative array with the constants and their values inside. I don't understand, why they don't use an object there, too (e.g. ReflectionConstant). The final effect is, that you aren't able to read out the DocComment of constants.

* There is no nice way to access the default values of properties. You can workaround a bit with get_class_vars(), but this just returns the values of public properties. No way to access protected or even private properties.

* PHP 5 has a nice feature called type hinting. This is completely omitted. You may ask, if a certain parameter is an array, but you won't get the denoted type hint.

Maybe this is, or will be extended. I hope so.

hth,
Niels
rob at endertech dot com
08-Apr-2008 01:34
PHP 5.3 will receive Java's setAccessible() functionality for accessing protected/privates.
Andrea Giammarchi
17-Feb-2008 04:41
I encountered a weird problem with ReflectionFunction, described in ticket 44139 of PHP Bugs.

If for some reason you need to call with invoke, or invokeArgs, a function like array_unshift (that accepts internally the array by reference) you could use this code to avoid the generated warning or fatal error.

<?php
function unshift(){
   
$ref        = new ReflectionFunction('array_unshift');
   
$arguments    = func_get_args();
    return       
$ref->invokeArgs(array_merge(array(&$this->arr), $arguments));
}
?>

I don't know about performances (you can create an array manually too, starting from array(&$this->something) and adding arguments). However, it seems to work correctly without problems, at least until the send by reference will be usable with one single value ...
krowork
31-Jan-2008 12:47
Like Will Mason said for the ReflectionMethod's constants, there is filter constants for ReflectionProperty too:

ReflectionProperty::IS_STATIC
ReflectionProperty::IS_PUBLIC
ReflectionProperty::IS_PROTECTED
ReflectionProperty::IS_PRIVATE

that can be used in the ReflectionClass' method getProperties:

$class=new ReflectionClass("Foo");
$class->getProperties(
  ReflectionProperty::IS_STATIC |
  ReflectionProperty::IS_PUBLIC );

this obtains the publics (static or not) and the statics (public or not): this exlude the non static private properties.
annonymous
04-Dec-2007 03:16
If you are getting

Fatal error: Trying to clone an uncloneable object of class ReflectionClass in …

Ensure that this is set.
zend.ze1_compatibility_mode=Off in php.ini

Thanks to anil who posted this on www.tecpages.com
Will Mason
03-Aug-2007 11:29
If you are looking for the long $filters for ReflectionClass::getMethods(), here they are. They took me a  long time to find. Found nothing in the docs, nor google. But of course, Reflection itself was the final solution, in the form of ReflectionExtension::export("Reflection").

<?php
//The missing long $filter values!!!
ReflectionMethod::IS_STATIC;
ReflectionMethod::IS_PUBLIC;
ReflectionMethod::IS_PROTECTED;
ReflectionMethod::IS_PRIVATE;
ReflectionMethod::IS_ABSTRACT;
ReflectionMethod::IS_FINAL;

//Use them like this
$R = new ReflectionClass("MyClass");
//print all public methods
foreach ($R->getMethods(ReflectionMethod::IS_PUBLIC) as $m)
    echo
$m->__toString();
?>
killgecNOFSPAM at gmail dot com
25-Jul-2007 03:53
Signature of constructor of ReflectionParameter correctly is:

public function __construct(array/string $function, string $name);

where $function is either a name of a global function, or a class/method name pair.
massimo at mmware dot it
18-Jul-2007 06:58
I found these limitations using class ReflectionParameter from ReflectionFunction with INTERNAL FUNCTIONS (eg print_r, str_replace, ... ) :

1. parameter names don't match with manual: (try example 19.35 with arg "call_user_func" )
2. some functions (eg PCRE function, preg_match etc) have EMPTY parameter names
3. calling getDefaultValue on Parameters will result in Exception "Cannot determine default value for internal functions"
thiago_mata at yahoo dot com dot br
06-Sep-2006 12:19
If you need to try to do something with the phpdoc or like the java notations in php4, you can create your own
'reflection functions'. This is a litle example of that.
<?php

/**
 * Comment used to start a phpdoc
 * @author Thiago Mata
 * @package notations
 */
define( 'START_DOC' , '/**' );

/**
 * Comment used to end a phpdoc
 * @author Thiago Mata
 * @package notations
 */
define( 'END_DOC' , '*/' );

/**
 * Comment used to indicate a tag of phpdoc
 * @author Thiago Mata
 * @package notations
 */
define( 'TAG_DOC' , '@' );

/**
 * This is a function maded in PHP4 to get the notations from some php file.
 * Can use comments with many lines
 *
 * @author Thiago Mata
 * @date 05/09/2006
 * @package notations
 * @param string $strFile
 * @copyright open source
 * @example <code> $arrNotations = getFileNotations( 'somefile.php' ); </code>
 */
function getFileNotations( $strFile )
{
   
$strText = file_get_contents( $strFile );
   
$arrText = explode( "\n" , $strText );
   
   
$arrNotations = array();
   
    for (
$intCount = 0 ; $intCount < count( $arrText ) ; ++$intCount )
    {
       
$strLine = $arrText[ $intCount ];
       
       
// inside the phpdoc //
       
if ( strpos( trim( $strLine ) , START_DOC ) === 0 )
        {
            ++
$intCount;
           
$strLine = $arrText[ $intCount ];
           
$arrNotation = array();
           
           
// while the phpdoc is not finished //
           
while ( ( strpos( trim( $strLine ) , END_DOC ) !== 0 ) and ( $intCount < count( $arrText ) ) )
            {
               
// removing the tag doc from the line //
               
$strLine = substr( $strLine , strpos( $strLine , TAG_DOC ) );
               
// get the name of the tag //
               
$strName = substr( $strLine , 0 , strpos( $strLine , ' ' ) );
               
// get the value of the tag //
               
$strLine = substr( $strLine , strpos( $strLine , ' ' ) + 1 );
               
                if (
strpos( trim( $strLine ) , '*' ) === 0 )
                {
                   
$strLine = substr( $strLine , strpos( $strLine , '*' ) + 1 );
                }
               
               
$strLine = trim( $strLine );
                if ( ! isset(
$arrNotation[ $strName ] ) )
                {
                   
$arrNotation[ $strName ] = '';
                }
                else
                {
                    if (
$strLine != '' )
                    {
                       
$arrNotation[ $strName ] .= "\n";
                    }
                }
               
$arrNotation[ $strName ] .= trim( $strLine );
                ++
$intCount;
               
$strLine = $arrText[ $intCount ];
            }
            if (
$intCount < count( $arrText ) )
            {
                do
                {
                    ++
$intCount;
                   
$strLine = $arrText[ $intCount ];
                }
                while (
$strLine == '' );
               
// adding the notation to the next command line //
               
$arrNotations[ trim( $arrText[ $intCount ] ) ] = $arrNotation;
               
$intCount--;
            }
        }
    }
    return(
$arrNotations );
}

print(
'<pre>' . "\n" );
var_export( getFileNotations( __FILE__ ) );
print(
'</pre>' . "\n" );
?>
<!-- OUTPUT
array (
  'define( \'START_DOC\' , \'/**\' );' =>
  array (
    '' => 'Comment used to start a phpdoc',
    '@author' => 'Thiago Mata',
    '@package' => 'notations',
  ),
  'define( \'END_DOC\' , \'*/\' );' =>
  array (
    '' => 'Comment used to end a phpdoc',
    '@author' => 'Thiago Mata',
    '@package' => 'notations',
  ),
  'define( \'TAG_DOC\' , \'@\' );' =>
  array (
    '' => 'Comment used to indicate a tag of phpdoc',
    '@author' => 'Thiago Mata',
    '@package' => 'notations',
  ),
  'function getFileNotations( $strFile )' =>
  array (
    '' => 'This is a function maded in PHP4 to get the notations from some php file.
Can use comments with many lines',
    '@author' => 'Thiago Mata',
    '@date' => '05/09/2006',
    '@package' => 'notations',
    '@param' => 'string $strFile',
    '@copyright' => 'open source',
    '@example' => '<code> $arrNotations = getFileNotations( \'somefile.php\' ); </code>',
  ),
)
-->
no dot prob at gmx dot net
02-Jun-2006 11:09
I have written a function which returns the value of a given DocComment tag.

Full example:

<?php

header
('Content-Type: text/plain');

class
Example
{
   
/**
     * This is my DocComment!
     *
     * @DocTag: prints Hello World!
     */
   
public function myMethod()
    {
        echo
'Hello World!';
    }
}

function
getDocComment($str, $tag = '')
{
    if (empty(
$tag))
    {
        return
$str;
    }

   
$matches = array();
   
preg_match("/".$tag.":(.*)(\\r\\n|\\r|\\n)/U", $str, $matches);

    if (isset(
$matches[1]))
    {
        return
trim($matches[1]);
    }

    return
'';
}

$method = new ReflectionMethod('Example', 'myMethod');

// will return Hello World!
echo getDocComment($method->getDocComment(), '@DocTag');

?>

Maybe you can add this functionality to the getDocComment methods of the reflection classes.
CodeDuck at gmx dot net
08-Feb-2006 06:07
Beware, the Reflection reflects only the information right after compile time based on the definitions, not based on runtime objects. Might be obvious, wasn't for me, until the app throws the exception at my head.

Example:

<?php

class A {
   
public $a = null;

    function
set() {
     
$this->foo = 'bar';
    }
}

$a = new A;
$a->set();

// works fine
$Reflection = new ReflectionProperty($a, 'a');

// throws exception
$Reflection = new ReflectionProperty($a, 'foo');

?>
walter dot huijbers at gmail dot com
28-Apr-2005 03:28
The wonderfull example code of russ collier works great until using it in combination with an interface or another abstract class, wich forces to define a function or variable in the loadable dynamic class, and the loaded class doesn't implement all the abstract functions. Ofcourse the class should not be used and an error should be reported, but the reported error is a Fatal error and is impossible to catch. This way it is impossible to, for example, generate an error message displaying the name of the file from wich the class is loaded.

Having dynamicly loadable classes with a forced interface can be very usefull when working on big projects or giving third parties the ability to provide new plugins. Considering this (imho) it would be nice to provide a clean error message to the writer of the plugin.

Please correct me if I'm wrong.
russ dot collier at gmail dot com
20-Oct-2004 06:40
Actually, aside from my inconsistent order of keywords in the 2 factory methods ;-) the Triangle::getInstance() method has 1 glaring flaw: it never actually sets the Triangle::$instance property. The correct way to implement a Singleton this way would be to replace Triangle::getInstance() with this:

<?php

  
static public function getInstance()
   {

       if (
null == self::$instance )
       {

           
self::$instance = new self