¿Cómo acceder a la constante definida en la clase hija desde las funciones de clase primaria?

Question

vi este ejemplo 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' 
?> 

Pero $ c :: MY_CONST se reconoce solamente en la versión 5.3.0 o posterior. La clase que estoy escribiendo se puede distribuir mucho.

Básicamente, he definido una constante en ChildClass y una de las funciones en MyClass (clase padre) necesita usar la constante. ¿Alguna idea?

Answer 1

Cómo sobre el uso static::MY_CONST?

Answer 2

no pude conseguir que funcione con const medida que se imprime "yonderyonder" (que es lo que pasa con las constantes, que no cambian), pero funciona bien con 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

En lugar de

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

Haga esto

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

Answer 4

Si necesita acceder a las constantes, propiedades, métodos de clases o objetos de puede usar reflection, proporciona muchos más detalles sobre la estructura del objeto.
ejemplo:

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

a partir de PHP 5.3:

Uso static::MY_CONST

---

Más detalles sobre static

En este caso the keyword static es una referencia a la clase llama en realidad.

Esto ilustra la diferencia entre static $var, static::$var y 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 

También tenga en cuenta que la palabra clave static tiene 2 significados muy diferentes:

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; 
    } 
}