Manuel PHP

Les classes et les objets (PHP 5)
PHP Manual

Réflexion

Introduction

PHP 5 introduit API de réflexion complète qui permet de faire du reverse-engineering sur les classes, les interfaces, les fonctions et les méthodes tout comme les extensions. L'API de réflexion permet également d'obtenir les commentaires de la documentation pour les fonctions, les classes et les méthodes.

L'API de réflexion est une extension orientée objet du Moteur Zend, constituée des classes suivantes :

  1. <?php
  2. class Reflection { }  
  3. interface Reflector { }  
  4. class ReflectionException extends Exception { }  
  5. class ReflectionFunction extends ReflectionFunctionAbstract implements Reflector { }  
  6. class ReflectionParameter implements Reflector { }  
  7. class ReflectionMethod extends ReflectionFunctionAbstract implements Reflector { }  
  8. class ReflectionClass implements Reflector { }  
  9. class ReflectionObject extends ReflectionClass { }  
  10. class ReflectionProperty implements Reflector { }  
  11. class ReflectionExtension implements Reflector { }  
  12. ?> 

Note: Pour plus de détails sur ces classes, lisez les chapitres suivants.

Si nous exécutons le code de l'exemple ci-dessous :

Exemple #1 Utilisation basique de l'API de réflexion

  1. <?php
  2. Reflection::export(new ReflectionClass('Exception'));  
  3. ?> 

L'exemple ci-dessus va afficher :

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 [ <optional> $message ] Parameter #1 [ <optional> $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 ] { } } }

Reflector

Reflector est une interface implémentée par toutes les classes exportables de réflection.

  1. <?php
  2. interface Reflector  
  3. { 
  4.    public string __toString() 
  5.    public static string export()  
  6. }  
  7. ?> 

ReflectionException

ReflectionException étend le standard Exception et est lancé par l'API Reflection. Aucune méthode spécifique ni de propriété ne sont introduites.

ReflectionFunction

La classe ReflectionFunction vous permet de faire du reverse-engineering sur les fonctions.

  1. <?php
  2. class ReflectionFunction extends ReflectionFunctionAbstract implements Reflector  
  3. { 
  4.    final private __clone() 
  5.    public void __construct(string name) 
  6.    public string __toString() 
  7.    public static string export(string name, bool return) 
  8.    public string getName() 
  9.    public bool isInternal() 
  10.    public bool isDisabled() 
  11.    public mixed getClosure() /* Depuis PHP 5.3.0 */ 
  12.    public bool isUserDefined() 
  13.    public string getFileName() 
  14.    public int getStartLine() 
  15.    public int getEndLine() 
  16.    public string getDocComment() 
  17.    public array getStaticVariables() 
  18.    public mixed invoke([mixed args [, ...]]) 
  19.    public mixed invokeArgs(array args) 
  20.    public bool returnsReference() 
  21.    public ReflectionParameter[] getParameters() 
  22.    public int getNumberOfParameters() 
  23.    public int getNumberOfRequiredParameters()  
  24. }  
  25. ?> 

La classe parent ReflectionFunctionAbstract a les mêmes méthodes, exceptée invoke(), invokeArgs(), export() et isDisabled().

Note: getNumberOfParameters() et getNumberOfRequiredParameters() ont été ajoutés en PHP 5.0.3, tandis que invokeArgs() a été ajouté en PHP 5.1.0.

Pour connaître le fonctionnement d'une fonction, vous devez tout d'abord créer une instance de la classe ReflectionFunction. Ainsi, vous pouvez appeler n'importe quelle méthode de cette instance.

Exemple #2 Utilisation de la classe ReflectionFunction

  1. <?php
  2. /**
  3. * Un simple compteur
  4. *
  5. * @return   int
  6. */  
  7. function counter()  
  8. { 
  9.    static $c = 0; 
  10.    return $c++;  
  11. }  
  12.  
  13. // Création d'une instance de la classe ReflectionFunction
  14. $func = new ReflectionFunction('counter');  
  15.  
  16. // Affichage d'informations basiques
  17. printf( 
  18.    "===> The %s function '%s'\n". 
  19.    "    declared in %s\n". 
  20.    "    lines %d to %d\n", 
  21.    $func->isInternal() ? 'internal' : 'user-defined', 
  22.    $func->getName(), 
  23.    $func->getFileName(), 
  24.    $func->getStartLine(), 
  25.    $func->getEndline()  
  26. );  
  27.  
  28. // Affichage du commentaire de la documentation
  29. printf("---> Documentation:\n %s\n", var_export($func->getDocComment(), 1));  
  30.  
  31. // Affichage des variables statiques si elles existent
  32. if ($statics = $func->getStaticVariables())  
  33. { 
  34.    printf("---> Variables statiques : %s\n", var_export($statics, 1));  
  35. }  
  36.  
  37. // Appel de la fonction
  38. printf("---> Invocation des résultats dans : ");  
  39. var_dump($func->invoke());  
  40.  
  41.  
  42. // vous pouvez préférer utiliser la méthode export()
  43. echo "\nRésultat de ReflectionFunction::export() :\n";  
  44. echo ReflectionFunction::export('counter');  
  45. ?> 

Note: La méthode invoke() accepte un nombre variable d'arguments, tout comme la fonction call_user_func().

ReflectionParameter

La classe ReflectionParameter récupère les informations concernant les paramètres des fonctions ou des méthodes.

  1. <?php
  2. class ReflectionParameter implements Reflector  
  3. { 
  4.    final private __clone() 
  5.    public void __construct(string function, string parameter) 
  6.    public string __toString() 
  7.    public static string export(mixed function, mixed parameter, bool return) 
  8.    public string getName() 
  9.    public bool isPassedByReference() 
  10.    public ReflectionClass getDeclaringClass() 
  11.    public ReflectionClass getClass() 
  12.    public bool isArray() 
  13.    public bool allowsNull() 
  14.    public bool isPassedByReference() 
  15.    public bool isOptional() 
  16.    public bool isDefaultValueAvailable() 
  17.    public mixed getDefaultValue() 
  18.    public int getPosition()  
  19. }  
  20. ?> 

Note: getDefaultValue(), isDefaultValueAvailable() et isOptional() ont été ajoutés en PHP 5.0.3, tandis que isArray() a été ajoutée en PHP 5.1.0. getDeclaringFunction() et getPosition() ont été ajoutés en PHP 5.2.3.

Pour connaître le fonctionnement des paramètres d'une fonction, vous devez tout d'abord créer une instance de la classe ReflectionFunction ou ReflectionMethod et, ainsi, utiliser leurs méthodes getparameters() pour récupérer un tableau de paramètres.

Exemple #3 Utilisation de la classe ReflectionParameter

  1. <?php
  2. function foo($a, $b, $c) { }  
  3. function bar(Exception $a, &$b, $c) { }  
  4. function baz(ReflectionFunction $a, $b = 1, $c = null) { }  
  5. function abc() { }  
  6.  
  7. // Création d'une instance de la classe ReflectionFunction avec le
  8. // paramètre fourni en ligne de commande.
  9. $reflect = new ReflectionFunction($argv[1]);  
  10.  
  11. echo $reflect;  
  12.  
  13. foreach ($reflect->getParameters() as $i => $param) { 
  14.    printf( 
  15.       "-- Paramètre #%d : %s {\n". 
  16.       " Classe : %s\n". 
  17.       " Autorise NULL : %s\n". 
  18.       " Passé par référence : %s\n". 
  19.       " Est optionnel ?: %s\n". 
  20.       "}\n", 
  21.       $i, // $param->getPosition() peut être utilisé depuis PHP 5.2.3
  22.       $param->getName(), 
  23.       var_export($param->getClass(), 1), 
  24.       var_export($param->allowsNull(), 1), 
  25.       var_export($param->isPassedByReference(), 1), 
  26.       $param->isOptional() ? 'oui' : 'non' 
  27.    );  
  28. }  
  29. ?> 

ReflectionClass

La classe ReflectionClass vous permet de faire du reverse-engineering sur des classes et des interfaces.

  1. <?php
  2. class ReflectionClass implements Reflector  
  3. { 
  4.    final private __clone() 
  5.    public void __construct(string name) 
  6.    public string __toString() 
  7.    public static string export(mixed class, bool return) 
  8.    public string getName() 
  9.    public bool isInternal() 
  10.    public bool isUserDefined() 
  11.    public bool isInstantiable() 
  12.    public bool hasConstant(string name) 
  13.    public bool hasMethod(string name) 
  14.    public bool hasProperty(string name) 
  15.    public string getFileName() 
  16.    public int getStartLine() 
  17.    public int getEndLine() 
  18.    public string getDocComment() 
  19.    public ReflectionMethod getConstructor() 
  20.    public ReflectionMethod getMethod(string name) 
  21.    public ReflectionMethod[] getMethods() 
  22.    public ReflectionProperty getProperty(string name) 
  23.    public ReflectionProperty[] getProperties() 
  24.    public array getConstants() 
  25.    public mixed getConstant(string name) 
  26.    public ReflectionClass[] getInterfaces() 
  27.    public bool isInterface() 
  28.    public bool isAbstract() 
  29.    public bool isFinal() 
  30.    public int getModifiers() 
  31.    public bool isInstance(stdclass object) 
  32.    public stdclass newInstance(mixed args) 
  33.    public stdclass newInstanceArgs(array args) 
  34.    public ReflectionClass getParentClass() 
  35.    public bool isSubclassOf(ReflectionClass class) 
  36.    public array getStaticProperties() 
  37.    public mixed getStaticPropertyValue(string name [, mixed default]) 
  38.    public void setStaticPropertyValue(string name, mixed value) 
  39.    public array getDefaultProperties() 
  40.    public bool isIterateable() 
  41.    public bool implementsInterface(string name) 
  42.    public ReflectionExtension getExtension() 
  43.    public string getExtensionName()  
  44. }  
  45. ?> 

Note: hasConstant(), hasMethod(), hasProperty(), getStaticPropertyValue() et setStaticPropertyValue() ont été ajoutées en PHP 5.1.0, tandis que newInstanceArgs() a été ajoutée dans PHP 5.1.3.

Pour connaître le fonctionnement d'une classe, vous devez d'abord créer une instance de la classe ReflectionClass. Vous pourrez donc appeler n'importe quelle méthode sur cette instance.

Exemple #4 Utilisation de la classe ReflectionClass

  1. <?php
  2. interface Linearisable  
  3. { 
  4.    // ...
  5. }  
  6.  
  7. class Object  
  8. { 
  9.    // ...
  10. }  
  11.  
  12. /**
  13. * Une classe compteur
  14. */  
  15. class Compteur extends Object implements Linearisable  
  16. { 
  17.    const START = 0; 
  18.    private static $c = Compteur::START; 
  19.  
  20.    /**
  21.     * Invocation du compteur
  22.     *
  23.     * @access public
  24.     * @return int
  25.     */ 
  26.    public function count() { 
  27.       return self::$c++; 
  28.    }  
  29. }  
  30.  
  31. // Création d'une instance de la classe ReflectionClass
  32. $class = new ReflectionClass('Compteur');  
  33.  
  34. // Affichage d'informations basiques
  35. printf( 
  36.    "===> La %s%s%s %s '%s' [extension de %s]\n". 
  37.    "    déclarée dans %s\n". 
  38.    "    lignes %d à %d\n". 
  39.    "    a le modificateur %d [%s]\n", 
  40.    $class->isInternal() ? 'internal' : 'user-defined', 
  41.    $class->isAbstract() ? ' abstract' : '', 
  42.    $class->isFinal() ? ' final' : '', 
  43.    $class->isInterface() ? 'interface' : 'class', 
  44.    $class->getName(), 
  45.    var_export($class->getParentClass(), 1), 
  46.    $class->getFileName(), 
  47.    $class->getStartLine(), 
  48.    $class->getEndline(), 
  49.    $class->getModifiers(), 
  50.    implode(' ', Reflection::getModifierNames($class->getModifiers()))  
  51. );  
  52.  
  53. // Affichage du commentaire de la documentation
  54. printf("---> Documentation:\n %s\n", var_export($class->getDocComment(), 1));  
  55.  
  56. // Affichage de l'interface qui implémente cette classe
  57. printf("---> Implémenté :\n %s\n", var_export($class->getInterfaces(), 1));  
  58.  
  59. // Affichage des constantes de la classe
  60. printf("---> Constantes : %s\n", var_export($class->getConstants(), 1));  
  61.  
  62. // Affichage des propriétés de la classe
  63. printf("---> Properties: %s\n", var_export($class->getProperties(), 1));  
  64.  
  65. // Affichage des méthodes de la classe
  66. printf("---> Méthodes : %s\n", var_export($class->getMethods(), 1));  
  67.  
  68. // Si cette classe est instanciable, création d'une instance
  69. if ($class->isInstantiable()) { 
  70.    $counter = $class->newInstance(); 
  71.  
  72.    echo '---> $counter est uneinstance ? '; 
  73.    echo $class->isInstance($counter) ? 'oui' : 'non'; 
  74.  
  75.    echo "\n---> Le nouvel objet Object() est une instance ? "; 
  76.    echo $class->isInstance(new Object()) ? 'oui' : 'non';  
  77. }  
  78. ?> 

Note: La méthode newinstance() accepte un nombre variable d'arguments, tout comme la fonction call_user_func().

Note: $class = new ReflectionClass('Foo'); $class->isInstance($arg) est équivalent à $arg instanceof Foo ou is_a($arg, 'Foo').

ReflectionObject

La classe ReflectionObject vous permet de retrouver les objets.

  1. <?php
  2. class ReflectionObject extends ReflectionClass  
  3. { 
  4.    final private __clone() 
  5.    public void __construct(mixed object) 
  6.    public string __toString() 
  7.    public static string export(mixed object, bool return)  
  8. }  
  9. ?> 

ReflectionMethod

La classe ReflectionMethod vous permet de faire du reverse-engineering sur les méthodes des classes.

  1. <?php
  2. class ReflectionMethod extends ReflectionFunctionAbstract implements Reflector  
  3. { 
  4.    public void __construct(mixed class, string name) 
  5.    public string __toString() 
  6.    public static string export(mixed class, string name, bool return) 
  7.    public mixed invoke(stdclass object [, mixed args [, ...]]) 
  8.    public mixed invokeArgs(stdclass object, array args) 
  9.    public bool isFinal() 
  10.    public bool isAbstract() 
  11.    public bool isPublic() 
  12.    public bool isPrivate() 
  13.    public bool isProtected() 
  14.    public bool isStatic() 
  15.    public bool isConstructor() 
  16.    public bool isDestructor() 
  17.    public int getModifiers() 
  18.    public mixed getClosure() /* Depuis PHP 5.3.0 */ 
  19.    public ReflectionClass getDeclaringClass() 
  20.  
  21.    // Inherited from ReflectionFunctionAbstract
  22.    final private __clone() 
  23.    public string getName() 
  24.    public bool isInternal() 
  25.    public bool isUserDefined() 
  26.    public string getFileName() 
  27.    public int getStartLine() 
  28.    public int getEndLine() 
  29.    public string getDocComment() 
  30.    public array getStaticVariables() 
  31.    public bool returnsReference() 
  32.    public ReflectionParameter[] getParameters() 
  33.    public int getNumberOfParameters() 
  34.    public int getNumberOfRequiredParameters()  
  35. }  
  36. ?> 

Pour connaître le fonctionnement d'une méthode, vous devez d'abord créer une instance de la classe ReflectionMethod. Vous pourrez ainsi appeler n'importe quelle méthode de cette instance.

Exemple #5 Utilisation de la classe ReflectionMethod

  1. <?php
  2. class Compteur  
  3. { 
  4.    private static $c = 0; 
  5.  
  6.    /**
  7.     * Incrémentation d'un compteur
  8.     *
  9.     * @final
  10.     * @static
  11.     * @access public
  12.     * @return int
  13.     */ 
  14.    final public static function increment() 
  15.    { 
  16.       return self::$c; 
  17.    }  
  18. }  
  19.  
  20. // Création d'une instance de la classe ReflectionMethod
  21. $method = new ReflectionMethod('Compteur', 'increment');  
  22.  
  23. // Affichage d'informations basiques
  24. printf( 
  25.    "===> La méthode %s%s%s%s%s%s%s '%s' (qui est %s)\n". 
  26.    "    déclaré dans %s\n". 
  27.    "    lignes %d à %d\n". 
  28.    "    a les modificateurs %d[%s]\n", 
  29.    $method->isInternal() ? 'internal' : 'user-defined', 
  30.    $method->isAbstract() ? ' abstract' : '', 
  31.    $method->isFinal() ? ' final' : '', 
  32.    $method->isPublic() ? ' public' : '', 
  33.    $method->isPrivate() ? ' private' : '', 
  34.    $method->isProtected() ? ' protected' : '', 
  35.    $method->isStatic() ? ' static' : '', 
  36.    $method->getName(), 
  37.    $method->isConstructor() ? 'the constructor' : 'a regular method', 
  38.    $method->getFileName(), 
  39.    $method->getStartLine(), 
  40.    $method->getEndline(), 
  41.    $method->getModifiers(), 
  42.    implode(' ', Reflection::getModifierNames($method->getModifiers()))  
  43. );  
  44.  
  45. // Affichage du commentaire de la documentation
  46. printf("---> Documentation:\n %s\n", var_export($method->getDocComment(), 1));  
  47.  
  48. // Affichage des variables statiques si elles existent
  49. if ($statics= $method->getStaticVariables()) { 
  50.    printf("---> Variales statiques : %s\n", var_export($statics, 1));  
  51. }  
  52.  
  53. // Invocation de la méthode
  54. printf("---> Résultat de l'invocation dans : ");  
  55. var_dump($method->invoke(NULL));  
  56. ?> 

Exemple #6 Obtention d'une clôture en utilisant la classe ReflectionMethod

  1. <?php
  2.  
  3. class Exemple { 
  4.    static function printer () { 
  5.       echo "Bonjour le Monde!\n"; 
  6.    }  
  7. }  
  8.  
  9. $class = new ReflectionClass('Exemple');  
  10. $method = $class->getMethod('printer');  
  11. $closure = $method->getClosure(); /* Depuis PHP 5.3.0 */  
  12. $closure(); // Bonjour le Monde!
  13.  
  14. ?> 

Note: Invoquer des méthodes privées, protégées ou abstraites provoquera une exception jetée par la méthode invoke().

Note: Pour les méthodes statiques comme vu précédemment, vous devez passer NULL comme premier argument à la fonction invoke(). Pour les méthodes non-statiques, passez une instance de la classe.

ReflectionProperty

La classe ReflectionProperty vous permet de faire du reverse-engineering sur les propriétés des classes.

  1. <?php
  2. class ReflectionProperty implements Reflector  
  3. { 
  4.    final private __clone() 
  5.    public void __construct(mixed class, string name) 
  6.    public string __toString() 
  7.    public static string export(mixed class, string name, bool return) 
  8.    public string getName() 
  9.    public bool isPublic() 
  10.    public bool isPrivate() 
  11.    public bool isProtected() 
  12.    public bool isStatic() 
  13.    public bool isDefault() 
  14.    public void setAccessible() /* Depuis PHP 5.3.0 */ 
  15.    public int getModifiers() 
  16.    public mixed getValue(stdclass object) 
  17.    public void setValue(stdclass object, mixed value) 
  18.    public ReflectionClass getDeclaringClass() 
  19.    public string getDocComment()  
  20. }  
  21. ?> 

Note: getDocComment() a été ajouté en PHP 5.1.0. setAccessible() a été ajouté en PHP 5.3.0.

Pour connaître le fonctionnement d'une propriété, vous devez d'abord créer une instance de la classe ReflectionProperty. Vous pourrez ainsi appeler n'importe quelle méthode de cette instance.

Exemple #7 Utilisation de la classe ReflectionProperty

  1. <?php
  2. class Chaine  
  3. { 
  4.    public $length = 5;  
  5. }  
  6.  
  7. // Création d'une instance de la classe ReflectionProperty
  8. $prop = new ReflectionProperty('Chaine', 'length');  
  9.  
  10. // Affichage d'informations basiques
  11. printf( 
  12.    "===> Les propriétés %s%s%s%s '%s' (qui a %s)\n". 
  13.    "    a les modificateurs %s\n", 
  14.    $prop->isPublic() ? ' public' : '', 
  15.    $prop->isPrivate() ? ' private' : '', 
  16.    $prop->isProtected() ? ' protected' : '', 
  17.    $prop->isStatic() ? ' static' : '', 
  18.    $prop->getName(), 
  19.    $prop->isDefault() ? 'déclaré au moment de la compilation' : 'créé au moment de l\'exécution', 
  20.    var_export(Reflection::getModifierNames($prop->getModifiers()), 1)  
  21. );  
  22.  
  23. // Création d'une instance de Chaine
  24. $obj= new Chaine();  
  25.  
  26. // Récupération de la valeur courante
  27. printf("---> La veleur est : ");  
  28. var_dump($prop->getValue($obj));  
  29.  
  30. // Modification de la valeur
  31. $prop->setValue($obj, 10);  
  32. printf("---> Définition de la valeur à 10, la nouvelle valeur est : ");  
  33. var_dump($prop->getValue($obj));  
  34.  
  35. // Affichage de l'objet
  36. var_dump($obj);  
  37. ?> 

Exemple #8 Obtenir la valeur d'une propriété privée et protégée en utilisant la classe ReflectionProperty

  1. <?php
  2.  
  3. class Foo { 
  4.    public $x = 1; 
  5.    protected $y = 2; 
  6.    private $z = 3;  
  7. }  
  8.  
  9. $obj = new Foo;  
  10.  
  11. $prop = new ReflectionProperty('Foo', 'y');  
  12. $prop->setAccessible(true); /* Depuis PHP 5.3.0 */  
  13. var_dump($prop->getValue($obj)); // int(2)
  14.  
  15. $prop = new ReflectionProperty('Foo', 'z');  
  16. $prop->setAccessible(true); /* Depuis PHP 5.3.0 */  
  17. var_dump($prop->getValue($obj)); // int(2)
  18.  
  19. ?> 

Note: Essayer de récupérer ou de définir les valeurs des propriétés d'une classe privée ou protégée produira une exception.

ReflectionExtension

La classe ReflectionExtension vous permet de faire du reverse-engineering sur les extensions. Vous pouvez connaître toutes les extensions chargées à l'exécution en utilisation la fonction get_loaded_extensions().

  1. <?php
  2. class ReflectionExtension implements Reflector { 
  3.    final private __clone() 
  4.    public void __construct(string name) 
  5.    public string __toString() 
  6.    public static string export(string name, bool return) 
  7.    public string getName() 
  8.    public string getVersion() 
  9.    public ReflectionFunction[] getFunctions() 
  10.    public array getConstants() 
  11.    public array getINIEntries() 
  12.    public ReflectionClass[] getClasses() 
  13.    public array getClassNames() 
  14.    public string info()  
  15. }  
  16. ?> 

Pour connaître le fonctionnement d'une extension, vous devez d'abord créer une instance de la classe ReflectionExtension. Vous pourrez ainsi appeler n'importe quelle méthode sur cette instance.

Exemple #9 Utilisation de la classe ReflectionExtension

  1. <?php
  2. // Création d'une instance de la classe ReflectionExtension
  3. $ext = new ReflectionExtension('standard');  
  4.  
  5. // Affichage d'informations basiques
  6. printf( 
  7.    "Nom      : %s\n". 
  8.    "Version    : %s\n". 
  9.    "Fonctions : [%d] %s\n". 
  10.    "Constantes : [%d] %s\n" . 
  11.    "Entrées INI : [%d] %s\n" . 
  12.    "Classes    : [%d] %s\n", 
  13.       $ext->getName(), 
  14.       $ext->getVersion() ? $ext->getVersion() : 'NO_VERSION', 
  15.       sizeof($ext->getFunctions()), 
  16.       var_export($ext->getFunctions(), 1), 
  17.  
  18.       sizeof($ext->getConstants()), 
  19.       var_export($ext->getConstants(), 1), 
  20.  
  21.       sizeof($ext->getINIEntries()), 
  22.       var_export($ext->getINIEntries(), 1), 
  23.  
  24.       sizeof($ext->getClassNames()), 
  25.       var_export($ext->getClassNames(), 1)  
  26. );  
  27. ?> 

Extension des classes de réflexion

Dans le cas où vous voudriez créer des versions spéciales des classes embarquées (par exemple pour créer du HTML colorisé lorsqu'il est exporté, pour avoir un accès facile aux variables des membres au lieu des méthodes ou pour avoir des méthodes utiles), vous devez étendre la classe.

Exemple #10 Extension des classes embarquées

  1. <?php
  2. /**
  3. * Ma classe Reflection_Method
  4. */  
  5. class My_Reflection_Method extends ReflectionMethod  
  6. {  
  7. public $visibility = array();  
  8.  
  9. public function __construct($o, $m)  
  10. { 
  11.    parent::__construct($o, $m); 
  12.    $this->visibility = Reflection::getModifierNames($this->getModifiers());  
  13. }  
  14. }  
  15.  
  16. /**
  17. * Démo classe #1
  18. *
  19. */  
  20. class T {  
  21. protected function x() {}  
  22. }  
  23.  
  24. /**
  25. * Démo classe #2
  26. *
  27. */  
  28. class U extends T {  
  29. function x() {}  
  30. }  
  31.  
  32. // Affichage des informations
  33. var_dump(new My_Reflection_Method('U', 'x'));  
  34. ?> 

Note: Attention : si vous écrasez le constructeur, n'oubliez pas d'appeler le constructeur parent avant d'insérer le moindre code. Sinon, votre code produira l'erreur suivante : Fatal error: Internal error: Failed to retrieve the reflection object

Les classes et les objets (PHP 5)
PHP Manual

Remonter Remonter
L'éditeur javascript - CSS - Gentoo - Tutoriaux PHP - Tutoriels PHP - Bretagne - php - Moto - Kit graphique