Cách khởi tạo biến tĩnh

Tôi có mã này:

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

Điều này cho tôi lỗi sau:

Lỗi phân tích cú pháp: lỗi cú pháp, không mong muốn '(', mong đợi ')' trong /home/user/Sites/site/registration/inc/registration. Class.inc trên dòng 19

Vì vậy, tôi đoán tôi đang làm gì đó sai ... nhưng làm thế nào tôi có thể làm điều này nếu không như thế? Nếu tôi thay đổi công cụ mktime bằng các chuỗi thông thường, nó sẽ hoạt động. Vì vậy, tôi biết rằng tôi có thể làm điều đó loại như thế ..

Bất cứ ai cũng có một số gợi ý?

PHP không thể phân tích các biểu thức không tầm thường trong các bộ khởi tạo.

Tôi thích giải quyết vấn đề này bằng cách thêm mã ngay sau khi định nghĩa lớp:

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

hoặc là

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

PHP 5.6 có thể xử lý một số biểu thức bây giờ.

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

Nếu bạn có quyền kiểm soát tải lớp, bạn có thể thực hiện khởi tạo tĩnh từ đó.

Thí dụ:

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

trong trình nạp lớp của bạn, hãy làm như sau:

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

Một giải pháp nặng hơn sẽ là sử dụng giao diện với ReflectionClass:

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

trong trình nạp lớp của bạn, hãy làm như sau:

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

Thay vì tìm cách để các biến tĩnh hoạt động, tôi thích chỉ đơn giản là tạo một hàm getter. Cũng hữu ích nếu bạn cần các mảng thuộc về một lớp cụ thể và đơn giản hơn rất nhiều để thực hiện.

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

Bất cứ nơi nào bạn cần danh sách, chỉ cần gọi phương thức getter. Ví dụ:

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

Tôi sử dụng kết hợp câu trả lời của Tjeerd Visser's và 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() ]]
    }
}

Nhưng một giải pháp thậm chí tốt hơn là loại bỏ các phương thức tĩnh và sử dụng mẫu Singleton. Sau đó, bạn chỉ cần thực hiện khởi tạo phức tạp trong hàm tạo. Hoặc biến nó thành một "dịch vụ" và sử dụng DI để đưa nó vào bất kỳ lớp nào cần nó.

Điều đó quá phức tạp để định nghĩa. Bạn có thể đặt định nghĩa thành null mặc dù, sau đó trong hàm tạo, kiểm tra nó và nếu nó không bị thay đổi - hãy đặt nó:

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

Bạn không thể thực hiện các cuộc gọi hàm trong phần này của mã. Nếu bạn thực hiện một phương thức kiểu init () được thực thi trước bất kỳ mã nào khác thì bạn sẽ có thể nhập biến đó.

Trong PHP 7.0.1, tôi đã có thể định nghĩa điều này:

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

Và sau đó sử dụng nó như thế này:

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

cách tốt nhất là tạo một trình truy cập như thế này:

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

sau đó bạn có thể làm static :: db (); hoặc tự :: db (); từ bất cứ đâu.

Đây là một con trỏ hy vọng hữu ích, trong một ví dụ mã. Lưu ý cách hàm khởi tạo chỉ được gọi một lần.

Ngoài ra, nếu bạn đảo ngược các cuộc gọi đến StaticClass::initializeStStateArr()và $st = new StaticClass()bạn sẽ nhận được kết quả tương tự.

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

Sản lượng nào:

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