tipos - ¿Cómo puedo obtener el nombre de clase de una llamada estática en una clase PHP extendida?

self php

Question

Tengo dos clases: Action y MyAction . Este último se declara como:

class MyAction extends Action {/* some methods here */}

Todo lo que necesito es un método en la clase Action (solo en él, porque habrá muchas clases heredadas, y no quiero implementar este método en todas), que devolverá el nombre de clase de una llamada estática. Esto es de lo que estoy hablando:

Class Action {
function n(){/* something */}
}

Y cuando lo llamo:

MyAction::n(); // it should return "MyAction"

Pero cada declaración en la clase principal tiene acceso solo a la clase padre __CLASS__ variable, que tiene el valor "Acción".

¿Hay alguna manera posible de hacer esto?

Answer 1

Ahora (cuando 5.3 ha llegado) es bastante simple:

http://php.net/manual/en/function.get-called-class.php

Answer 2

Desde 5.5 puede usar class palabra clave class para la resolución del nombre de clase , que sería mucho más rápido que hacer llamadas a funciones. También funciona con interfaces.

// C extends B extends A
static::class // MyNamespace/ClassC when run in A
self::class // MyNamespace/ClassA when run in A
parent::class // MyNamespace/ClassB when run in C
MyClass::class // MyNamespace/MyClass

Answer 3

No es la solución ideal, pero funciona en PHP <5.3.0.

El código fue copiado de septuro.com

if(!function_exists(''get_called_class'')) {
class class_tools {
static $i = 0;
static $fl = null;
static function get_called_class() {
$bt = debug_backtrace();
if (self::$fl == $bt[2][''file''].$bt[2][''line'']) {
self::$i++;
} else {
self::$i = 0;
self::$fl = $bt[2][''file''].$bt[2][''line''];
}
$lines = file($bt[2][''file'']);
preg_match_all(''/([a-zA-Z0-9/_]+)::''.$bt[2][''function''].''/'',
$lines[$bt[2][''line'']-1],
$matches);
return $matches[1][self::$i];
}
}
function get_called_class() {
return class_tools::get_called_class();
}
}

Answer 4

No hay forma, en las versiones PHP disponibles, de hacer lo que quieras. La solución de Paul Dixon es la única. Quiero decir, el ejemplo del código, ya que la característica de enlaces estáticos tardíos de la que habla está disponible a partir de PHP 5.3, que está en versión beta.

Answer 5

__CLASS__ siempre devuelve el nombre de la clase en la que se usó, por lo que no es de mucha ayuda con un método estático. Si el método no es estático, simplemente puede usar get_class ($ this). p.ej

class Action {
public function n(){
echo get_class($this);
}
}
class MyAction extends Action {
}
$foo=new MyAction;
$foo->n(); //displays ''MyAction''

Enlaces estáticos tardíos, disponibles en PHP 5.3+

Ahora que se lanzó PHP 5.3, puede usar enlaces estáticos tardíos , que le permiten resolver la clase de destino para una llamada de método estático en tiempo de ejecución en lugar de cuando se define.

Si bien la característica no introduce una nueva constante mágica para indicarle el nombre de clase al que se llamó, sí proporciona una nueva función, get_called_class() que puede indicarle el nombre de la clase a la que se llamó un método estático. Aquí hay un ejemplo:

Class Action {
public static function n() {
return get_called_class();
}
}
class MyAction extends Action {
}
echo MyAction::n(); //displays MyAction

Answer 6

class MainSingleton {
private static $instances = array();
private static function get_called_class() {
$t = debug_backtrace();
return $t[count($t)-1]["class"];
}
public static function getInstance() {
$class = self::get_called_class();
if(!isset(self::$instances[$class]) ) {
self::$instances[$class] = new $class;
}
return self::$instances[$class];
}
}
class Singleton extends MainSingleton {
public static function getInstance()
{
return parent::getInstance();
}
protected function __construct() {
echo "A". PHP_EOL;
}
protected function __clone() {}
public function test() {
echo " * test called * ";
}
}
Singleton::getInstance()->test();
Singleton::getInstance()->test();