Compilazione dinamica di una variabile statica in PHP

Question

Ho due valori statici: "tipo" e "tipoID". Il tipo è leggibile e costante dall'uomo e typeID deve essere controllato dal database, in base al valore del tipo. Ho bisogno che la ricerca avvenga una volta, quando viene caricata la definizione della classe

Per illustrare, ecco un codice che non funziona perché non è possibile chiamare le funzioni nello spazio di dichiarazione.

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

Esiste un metodo magico che viene chiamato una sola volta quando la definizione della classe viene caricata? Se c'è qualcosa di ovvio mi manca.

Answer 1

spudoratamente tirato dai commenti di parole chiave statiche del manuale di 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

Una cosa del genere sarebbe normalmente chiamato "costruttore statico", ma PHP manca queste cose. Potresti considerare uno dei suggerimenti proposti nei commenti del manuale PHP, ad es. http://www.php.net/manual/en/language.oop5.static.php#95217

Answer 3

Semplice e senza bisogno di magia, non dimenticare che puoi sempre definire una variabile come null e verificare che sia null (facendo solo la chiamata db). Poi è solo una questione se si vuole che questo accada quando la classe è costruito o incluso (include_once ecc ...)

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 costruttore statico è più simile a un metodo factory

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();