Cómo inicializar variables estáticas

Question

tengo este código:

private static $dates = array(
    'start' => mktime(0, 0, 0, 7, 30, 2009), // Start date 
    'end' => mktime(0, 0, 0, 8, 2, 2009), // End date 
    'close' => mktime(23, 59, 59, 7, 20, 2009), // Date when registration closes 
    'early' => mktime(0, 0, 0, 3, 19, 2009), // Date when early bird discount ends 
); 

Lo que me da el siguiente error:

Parse error: syntax error, unexpected '(', expecting ')' in /home/user/Sites/site/registration/inc/registration.class.inc on line 19

lo tanto, supongo que estoy haciendo algo mal ... pero ¿cómo puedo hacer esto si no es así? Si cambio las cosas de mktime con cadenas normales, funciona. Entonces sé que puedo hacerlo tipo de así ..

¿Alguien tiene algunos indicadores?

Answer 1

PHP no puede analizar expresiones no triviales en inicializadores.

prefiero evitar esto mediante la adición de código justo después de la definición de la clase:

class Foo { 
    static $bar; 
} 
Foo::$bar = array(…); 

o

class Foo { 
    private static $bar; 
    static function init() 
    { 
    self::$bar = array(…); 
    } 
} 
Foo::init(); 

---

PHP 5.6 puede manejar algunas expresiones ahora.

Answer 2

No puede hacer llamadas a funciones en esta parte del código. Si haces un método de tipo init() que se ejecuta antes que cualquier otro código, entonces podrás poblar la variable.

Answer 3

Eso es demasiado complejo para establecer en la definición. Puede ajustar la definición a nulo, sin embargo, y luego en el constructor, comprobarlo, y si no se ha cambiado - configurarlo:

private static $dates = null; 
public function __construct() 
{ 
    if (is_null(self::$dates)) { // OR if (!is_array(self::$date)) 
     self::$dates = array(/* .... */); 
    } 
} 

Answer 4

Si tiene control sobre la carga de clases, puede hacer la inicialización estática desde allí.

Ejemplo:

class MyClass { public static function static_init() { } } 

en su cargador de clases, hacer lo siguiente:

include($path . $klass . PHP_EXT); 
if(method_exists($klass, 'static_init')) { $klass::staticInit() } 

Una solución de peso más pesado sería utilizar una interfaz con ReflectionClass:

interface StaticInit { public static function staticInit() { } } 
class MyClass implements StaticInit { public static function staticInit() { } } 

en su cargador de clases, haga lo siguiente:

$rc = new ReflectionClass($klass); 
if(in_array('StaticInit', $rc->getInterfaceNames())) { $klass::staticInit() } 

Answer 5

En lugar de encontrar la forma de hacer que las variables estáticas funcionen, prefiero simplemente crear una función getter. También es útil si necesita matrices que pertenecen a una clase específica, y mucho más simples de implementar.

class MyClass 
{ 
    public static function getTypeList() 
    { 
     return array(
      "type_a"=>"Type A", 
      "type_b"=>"Type B", 
      //... etc. 
     ); 
    } 
} 

Dondequiera que necesite la lista, simplemente llame al método getter. Por ejemplo:

if (array_key_exists($type, MyClass::getTypeList()) { 
    // do something important... 
} 

Answer 6

Aquí hay un puntero con suerte útil, en un ejemplo de código. Observe cómo la función de inicialización solo se llama una vez.

Además, si invierte las llamadas a StaticClass::initializeStStateArr() y $st = new StaticClass() obtendrá el mismo resultado.

$ cat static.php 
<?php 

class StaticClass { 

    public static $stStateArr = NULL; 

    public function __construct() { 
    if (!isset(self::$stStateArr)) { 
     self::initializeStStateArr(); 
    } 
    } 

    public static function initializeStStateArr() { 
    if (!isset(self::$stStateArr)) { 
     self::$stStateArr = array('CA' => 'California', 'CO' => 'Colorado',); 
     echo "In " . __FUNCTION__. "\n"; 
    } 
    } 

} 

print "Starting...\n"; 
StaticClass::initializeStStateArr(); 
$st = new StaticClass(); 

print_r (StaticClass::$stStateArr); 

que produce:

$ php static.php 
Starting... 
In initializeStStateArr 
Array 
(
    [CA] => California 
    [CO] => Colorado 
) 

Answer 7

mejor manera es crear un descriptor de acceso de esta manera:

/** 
* @var object $db : map to database connection. 
*/ 
public static $db= null; 

/** 
* db Function for initializing variable. 
* @return object 
*/ 
public static function db(){ 
if(!isset(static::$db)){ 
    static::$db= new \Helpers\MySQL(array(
    "hostname"=> "localhost", 
    "username"=> "root", 
    "password"=> "password", 
    "database"=> "db_name" 
    ) 
); 
} 
return static::$db; 
} 

entonces usted puede hacer estática :: db(); o self :: db(); de donde sea.

Answer 8

Uso una combinación de la respuesta de Tjeerd Visser y porneL.

class Something 
{ 
    private static $foo; 

    private static getFoo() 
    { 
     if ($foo === null) 
      $foo = [[ complicated initializer ]] 
     return $foo; 
    } 

    public static bar() 
    { 
     [[ do something with self::getFoo() ]] 
    } 
} 

Pero una solución aún mejor es eliminar los métodos estáticos y utilizar el patrón de Singleton. Luego, acaba de hacer la inicialización complicada en el constructor. O conviértalo en un "servicio" y usa DI para inyectarlo en cualquier clase que lo necesite.

Answer 9

En PHP 7.0.1, yo era capaz de definir esto:

public static $kIdsByActions = array(
    MyClass1::kAction => 0, 
    MyClass2::kAction => 1 
); 

y luego usarlo como esto:

MyClass::$kIdsByActions[$this->mAction];