So initialisieren Sie statische Variablen

Ich habe diesen Code:

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

Was mir folgenden Fehler gibt:

Analysefehler: Syntaxfehler, unerwartetes '(', Erwarten ')' in /home/user/Sites/site/registration/inc/registration.class.inc in Zeile 19

Also, ich denke ich mache etwas falsch ... aber wie kann ich das machen, wenn nicht so? Wenn ich das Mktime-Zeug mit regulären Strings ändere, funktioniert es. Also ich weiß , dass ich es tun kann irgendwie ähnlich ..

Hat jemand ein paar Hinweise?

PHP kann nicht triviale Ausdrücke in Initialisierern nicht analysieren.

Ich ziehe es vor, dies zu umgehen, indem ich Code direkt nach der Definition der Klasse hinzufüge:

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

oder

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

PHP 5.6 kann jetzt einige Ausdrücke verarbeiten.

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

Wenn Sie die Kontrolle über das Laden von Klassen haben, können Sie von dort aus eine statische Initialisierung durchführen.

Beispiel:

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

Gehen Sie in Ihrem Klassenlader wie folgt vor:

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

Eine schwerere Lösung wäre die Verwendung einer Schnittstelle mit ReflectionClass:

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

Gehen Sie in Ihrem Klassenlader wie folgt vor:

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

Anstatt einen Weg zu finden, um statische Variablen zum Laufen zu bringen, ziehe ich es vor, einfach eine Getter-Funktion zu erstellen. Auch hilfreich, wenn Sie Arrays benötigen, die zu einer bestimmten Klasse gehören und viel einfacher zu implementieren sind.

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

Wo immer Sie die Liste benötigen, rufen Sie einfach die Getter-Methode auf. Beispielsweise:

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

Ich benutze eine Kombination aus der Antwort von Tjeerd Visser und 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() ]]
    }
}

Eine noch bessere Lösung besteht darin, die statischen Methoden abzuschaffen und das Singleton-Muster zu verwenden. Dann führen Sie einfach die komplizierte Initialisierung im Konstruktor durch. Oder machen Sie es zu einem "Service" und verwenden Sie DI, um es in eine Klasse zu injizieren, die es benötigt.

Das ist zu komplex, um es in der Definition festzulegen. Sie können die Definition jedoch auf null setzen und sie dann im Konstruktor überprüfen. Wenn sie nicht geändert wurde, setzen Sie sie:

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

In diesem Teil des Codes können keine Funktionsaufrufe durchgeführt werden. Wenn Sie eine Methode vom Typ init () erstellen, die vor jedem anderen Code ausgeführt wird, können Sie die Variable dann füllen.

In PHP 7.0.1 konnte ich Folgendes definieren:

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

Und dann benutze es so:

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

Der beste Weg ist, einen Accessor wie folgt zu erstellen:

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

dann kannst du static :: db () machen; oder self :: db (); von überall.

Hier ist ein hoffentlich hilfreicher Zeiger in einem Codebeispiel. Beachten Sie, dass die Initialisierungsfunktion nur einmal aufgerufen wird.

Auch, wenn Sie invertieren die Anrufe an StaticClass::initializeStStateArr()und $st = new StaticClass()Sie erhalten das gleiche Ergebnis.

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

Welche Ausbeuten:

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