Come inizializzare le variabili statiche

Ho questo codice:

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

Il che mi dà il seguente errore:

Errore di analisi: errore di sintassi, inatteso "(", in attesa ")" in /home/user/Sites/site/registration/inc/registration.class.inc alla riga 19

Quindi, immagino di fare qualcosa di sbagliato ... ma come posso farlo se non così? Se cambio le cose di mktime con stringhe regolari, funziona. Quindi so che posso farlo sorta di genere ..

Qualcuno ha dei suggerimenti?

PHP non può analizzare espressioni non banali negli inizializzatori.

Preferisco aggirare questo aggiungendo il codice subito dopo la definizione della classe:

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

o

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

PHP 5.6 ora può gestire alcune espressioni.

/* 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();
}

Se hai il controllo sul caricamento della classe, puoi eseguire l'inizializzazione statica da lì.

Esempio:

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

nel caricatore di classi, procedi come segue:

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

Una soluzione più pesante sarebbe quella di utilizzare un'interfaccia con ReflectionClass:

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

nel caricatore di classi, procedi come segue:

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

Invece di trovare un modo per far funzionare le variabili statiche, preferisco semplicemente creare una funzione getter. Utile anche se hai bisogno di array appartenenti a una classe specifica e molto più semplice da implementare.

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

Ovunque sia necessario l'elenco, è sufficiente chiamare il metodo getter. Per esempio:

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

Uso una combinazione della risposta di Tjeerd Visser e 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() ]]
    }
}

Ma una soluzione ancora migliore è eliminare i metodi statici e utilizzare il modello Singleton. Quindi esegui la complicata inizializzazione nel costruttore. Oppure rendilo un "servizio" e usa DI per iniettarlo in qualsiasi classe che ne abbia bisogno.

È troppo complesso per essere impostato nella definizione. È possibile impostare la definizione su null, quindi nel costruttore, controllarla e, se non è stata modificata, impostarla:

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

Non è possibile effettuare chiamate di funzione in questa parte del codice. Se crei un metodo di tipo init () che viene eseguito prima di qualsiasi altro codice, allora sarai in grado di popolare la variabile.

In PHP 7.0.1, sono stato in grado di definire questo:

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

E poi usalo in questo modo:

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

il modo migliore è creare un accessor come questo

/**
* @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;
}

allora puoi fare static :: db (); o self :: db (); da qualsiasi luogo.

Ecco un puntatore si spera utile, in un esempio di codice. Notare come la funzione di inizializzazione viene chiamata una sola volta.

Inoltre, se inverti le chiamate StaticClass::initializeStStateArr()e $st = new StaticClass()otterrai lo stesso risultato.

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

Che produce:

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