Completando dinámicamente una variable estática en PHP

Question

Tengo dos valores estáticos: "tipo" y "tipoID". El tipo es legible y constante, y el ID de tipo necesita buscarse desde la base de datos, según el valor del tipo. Necesito que la búsqueda se realice una vez, cuando la definición de clase se carga por primera vez

Para ilustrar, aquí hay un código que no funciona porque no puede llamar funciones en el espacio de declaración.

MyClass extends BaseClass { 
    protected static $type = "communities"; 
    protected static $typeID = MyClass::lookupTypeID(self::$type); 
} 

¿Hay un método mágico que se llama exactamente una vez cuando se carga la definición de la clase? Si hay algo obvio, me lo estoy perdiendo.

Answer 1

descaradamente sacó de los comentarios de la palabra clave estática del manual de PHP:

Because php does not have a static constructor and you may want to initialize static class vars, there is one easy way, just call your own function directly after the class definition. 

for example. 

<?php 
function Demonstration() 
{ 
    return 'This is the result of demonstration()'; 
} 

class MyStaticClass 
{ 
    //public static $MyStaticVar = Demonstration(); //!!! FAILS: syntax error 
    public static $MyStaticVar = null; 

    public static function MyStaticInit() 
    { 
     //this is the static constructor 
     //because in a function, everything is allowed, including initializing using other functions 

     self::$MyStaticVar = Demonstration(); 
    } 
} MyStaticClass::MyStaticInit(); //Call the static constructor 

echo MyStaticClass::$MyStaticVar; 
//This is the result of demonstration() 
?> 

Answer 2

Tal cosa que normalmente se llama un "constructor estático", pero PHP carece de tales cosas. Es posible que desee considerar una de las soluciones sugeridas en los comentarios del manual de PHP, p. http://www.php.net/manual/en/language.oop5.static.php#95217

Answer 3

Simple y sin necesidad de magia, no olvide que siempre puede definir una variable como nula y probar que es nula (haciendo la llamada db solo entonces). Entonces es sólo una cuestión si se quiere que eso suceda cuando la clase se construye o se incluyó (include_once etc ...)

MyClass extends BaseClass { 
    protected static $type = "communities"; 
    protected static $typeID = null; 

    public function __construct(){ 
     if(is_null(self::$typeID)){ 
      self::lookupTypeID(self::$type); 
     } 
    } 

    public static lookupTypeID($type){ 
     self::$typeID = //result of database query 
    } 
} 

o

MyClass::lookupTypeID(); //call static function when class file is included (global space) 

MyClass extends BaseClass { 
    protected static $type = "communities"; 
    protected static $typeID = null; 

    public function __construct(){ 

    } 

    public static lookupTypeID($type=null){ 
     if(is_null($type)){ 
      $type = self::$type; 
     } 
     self::$typeID = //result of database query (SELECT somefield FROM sometable WHERE type=$type) etc.. 
    } 
} 

un constructor estático es más como un método de fábrica

if(!function_exists(build_myclass)){ 
    function build_myclass(){ 
     return MyClass::build(); 
    } 
} 

MyClass extends BaseClass { 
    protected static $type = "communities"; 
    protected static $typeID = null; 

    public function __construct(){ 

    } 

    public static function build(){ 
     return new self(); //goes to __construct(); 
    } 

} 

$class = new MyClass(); //or 
$class = MyClass::build(); //or 
$class = build_myclass();