Statik değişkenler nasıl başlatılır

Bu kod var:

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

Bu da bana şu hatayı veriyor:

Ayrıştırma hatası: sözdizimi hatası, 19. satırdaki /home/user/Sites/site/registration/inc/registration.class.inc dosyasında beklenmeyen '(', '' bekleniyor ')

Yani, sanırım yanlış bir şey yapıyorum ... ama böyle değilse nasıl yapabilirim? Ben mktime şeyler düzenli dizeleri ile değiştirmek, çalışır. Ben bunu yapabilirim, biliyorum Yani bir çeşit böyle ..

Kimsenin işaretçileri var mı?

PHP, başlatıcılarda önemsiz olmayan ifadeleri ayrıştıramaz.

Sınıf tanımından hemen sonra kod ekleyerek bu soruna geçici bir çözüm tercih ederim:

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

veya

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

PHP 5.6 şimdi bazı ifadeleri işleyebilir.

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

Sınıf yüklemesi üzerinde kontrolünüz varsa, oradan statik başlatma yapabilirsiniz.

Misal:

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

sınıf yükleyicinizde aşağıdakileri yapın:

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

Daha ağır bir çözüm, ReflectionClass ile bir arayüz kullanmak olacaktır:

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

sınıf yükleyicinizde aşağıdakileri yapın:

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

Statik değişkenleri çalıştırmanın bir yolunu bulmak yerine, sadece bir alıcı işlevi oluşturmayı tercih ederim. Ayrıca belirli bir sınıfa ait dizilere ihtiyacınız varsa ve uygulanması çok daha basitse yararlıdır.

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

Listeye ihtiyacınız olduğunda, getter yöntemini çağırmanız yeterlidir. Örneğin:

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

Tjeerd Visser'in ve porneL'in cevabının bir kombinasyonunu kullanıyorum.

class Something
{
    private static $foo;

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

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

Ancak daha da iyi bir çözüm, statik yöntemleri ortadan kaldırmak ve Singleton desenini kullanmaktır. Sonra sadece yapıcıda karmaşık başlatmayı yaparsınız. Ya da bir "hizmet" yapın ve DI'yi ihtiyacı olan herhangi bir sınıfa yerleştirmek için kullanın.

Tanımda belirtilemeyecek kadar karmaşık. Tanımı null olarak ayarlayabilirsiniz ve sonra yapıcıda, denetleyin ve değiştirilmediyse ayarlayın - ayarlayın:

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

Kodun bu bölümünde işlev çağrısı yapamazsınız. Diğer kodlardan önce yürütülecek bir init () türü yöntemi yaparsanız, değişkeni daha sonra doldurabilirsiniz.

PHP 7.0.1'de bunu tanımlayabildim:

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

Ve sonra böyle kullanın:

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

en iyi yolu böyle bir erişimci oluşturmaktır:

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

o zaman static :: db (); veya self :: db (); herhangi bir yerden.

İşte bir kod örneğinde umut verici bir yardımcı işaretçi. Başlatıcı işlevinin nasıl yalnızca bir kez çağrıldığına dikkat edin.

Ayrıca, aramaları tersine eğer StaticClass::initializeStStateArr()ve $st = new StaticClass()aynı sonucu elde edersiniz.

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

Hangi verim:

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