php - metodo - Cómo inicializar variables estáticas

self php

Question

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, creo que estoy haciendo algo mal ... pero, ¿cómo puedo hacer esto si no es así? Si cambio las cosas mktime con cadenas regulares, funciona. Así que sé que puedo hacerlo así.

Alguien tiene algunos consejos?

Answer 1

Aquí hay un indicador de ayuda útil, en un ejemplo de código. Observe cómo la función de inicialización solo se llama una vez.

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

Answer 2

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

Answer 3

En lugar de encontrar una manera de hacer funcionar las variables estáticas, prefiero simplemente crear una función getter. También es útil si necesita matrices que pertenezcan a una clase específica y mucho más sencillas 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...
}

Answer 4

Eso es demasiado complejo para establecer en la definición. Sin embargo, puede establecer la definición en nula y, a continuación, en el constructor, verificarla y, si no se ha modificado, configurarla:

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

Answer 5

La mejor manera es crear un accesorio 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.

Answer 6

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

Answer 7

PHP no puede analizar expresiones no triviales en inicializadores.

Prefiero solucionar 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.

Answer 8

Si tiene control sobre la carga de clases, puede realizar la 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() }

Answer 9

Utilizo una combinación de Tjeerd Visser''s y la respuesta 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 utilizar el patrón Singleton. Entonces simplemente 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.