Comment accéder à la constante définie dans la classe enfant à partir des fonctions de la classe parent?

Question

J'ai vu cet exemple de php.net:

<?php 
class MyClass { 

    const MY_CONST = "yonder"; 

    public function __construct() { 

      $c = get_class($this); 
      echo $c::MY_CONST; 
    } 
} 

class ChildClass extends MyClass { 

    const MY_CONST = "bar"; 
} 

$x = new ChildClass(); // prints 'bar' 
$y = new MyClass(); // prints 'yonder' 
?> 

Mais $ c :: MY_CONST n'est reconnu dans la version 5.3.0 ou ultérieure. La classe que j'écris peut être distribuée beaucoup.

Fondamentalement, j'ai défini une constante dans ChildClass et l'une des fonctions de MyClass (classe père) doit utiliser la constante. Une idée?

Answer 1

Comment l'utilisation static::MY_CONST?

Answer 2

Je ne pouvais pas à travailler avec const comme il imprime « yonderyonder » (ce qui est la chose au sujet des constantes, ils ne changent pas), mais il fonctionne très bien avec var:

<?php 
class MyClass { 

    var $MY_CONST = "yonder"; 

    public function __construct() { 

    echo $this->MY_CONST; 
    } 
} 

class ChildClass extends MyClass { 

    var $MY_CONST = "bar"; 
} 

$x = new ChildClass(); // prints 'bar' 
$y = new MyClass(); // prints 'yonder' 

?> 

Answer 3

Au lieu de

$c = get_class($this); 
echo $c::MY_CONST; 

pour ce faire,

$c = get_class($this); 
echo constant($c . '::MY_CONST'); 

Answer 4

Si vous avez besoin d'accéder à des constantes, des propriétés, des méthodes de classes ou objets que vous peut utiliser reflection, il fournit beaucoup plus de détails sur la structure de l'objet.
exemple:

class MainClass 
{ 
    const name = 'Primary'; 

    public $foo = 'Foo Variable'; 
} 
class ExtendedClass extends MainClass 
{ 
    const name = 'Extended'; 
} 

/** 
* From Class Name 
*/ 

//get reflection of main class 
$mainReflection = new ReflectionClass('MainClass'); 

if($mainReflection->hasConstant('name')) 
    var_dump($mainReflection->getConstant('name'));//Primary 

//get reflection of extended class 
$extendedReflection = new ReflectionClass('ExtendedClass'); 

if($extendedReflection->hasConstant('name')) 
    var_dump($extendedReflection->getConstant('name'));//Extended 

/** 
* From Objects 
*/ 
$main = new MainClass(); 
$extended = new ExtendedClass(); 

//get reflection of main class 
$mainReflection = new ReflectionObject($main); 

if($mainReflection->hasConstant('name')) 
    var_dump($mainReflection->getConstant('name'));//Primary 

//get reflection of extended class 
$extendedReflection = new ReflectionObject($extended); 

if($extendedReflection->hasConstant('name')) 
    var_dump($extendedReflection->getConstant('name'));//Extended 

Answer 5

Depuis PHP 5.3:

Utilisez static::MY_CONST

---

Plus de détails sur static

Dans ce cas the keyword static est une référence à la classe effectivement appelé.

Cela illustre la différence entre static $var, static::$var et self::$var:

class Base { 
    const VALUE = 'base'; 

    static function testSelf() { 
     // Output is always 'base', because `self::` is always class Base 
     return self::VALUE; 
    } 

    static function testStatic() { 
     // Output is variable: `static::` is a reference to the called class. 
     return static::VALUE; 
    } 
} 

class Child extends Base { 
    const VALUE = 'child'; 
} 

echo Base::testStatic(); // output: base 
echo Base::testSelf(); // output: base 

echo Child::testStatic(); // output: child 
echo Child::testSelf(); // output: base 

Notez également que le mot-clé static a 2 significations très différentes:

class StaticDemo { 
    static function demo() { 
     // Type 1: `static` defines a static variable. 
     static $Var = 'bar'; 

     // Type 2: `static::` is a reference to the called class. 
     return static::VALUE; 
    } 
}