Cómo inicializar variables estáticas

Tengo este codigo:

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:

Error de análisis: error de sintaxis, inesperado '(', esperando ')' en /home/user/Sites/site/registration/inc/registration.class.inc en la línea 19

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

Alguien tiene algunos consejos?

PHP no puede analizar expresiones no triviales en inicializadores.

Prefiero evitar esto agregando 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.

/* For Abstract classes */
abstract class Foo{
    private static function bar(){
        static $bar = null;
        if ($bar == null)
            bar = array(...);
        return $bar;
    }
    /* use where necessary */
    self::bar();
}

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

Ejemplo:

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

en su cargador de clases, haga lo siguiente:

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

Una solución más pesada 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() }

En lugar de encontrar una manera de hacer que funcionen las variables estáticas, 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 simple de implementar.

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

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

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

Utilizo una combinación de la respuesta de Tjeerd Visser y de 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 usar el patrón Singleton. Entonces solo haces la complicada inicialización en el constructor. O conviértalo en un "servicio" y use DI para inyectarlo en cualquier clase que lo necesite.

Eso es demasiado complejo para establecerlo en la definición. Sin embargo, puede establecer la definición como nula, y luego en el constructor, verificarla y, si no se ha cambiado, configúrela:

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

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

En PHP 7.0.1, pude definir esto:

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

Y luego úsalo así:

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

La mejor manera es crear un descriptor de acceso como este:

/**
* @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 puedes hacer static :: db (); o self :: db (); de donde sea.

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

Además, si invierte las llamadas 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);

Cuyos rendimientos :

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