Pregunta Inicializador de clase estático en PHP


Tengo una clase de ayuda con algunas funciones estáticas. Todas las funciones en la clase requieren una función de inicialización 'pesada' para ejecutarse una vez (como si fuera un constructor).

¿Hay una buena práctica para lograr esto?

Lo único que pensé fue llamar a un init función, y rompiendo su flujo si ya se ha ejecutado una vez (usando un $initialized var). El problema es que necesito llamarlo a cada una de las funciones de la clase.


73
2017-07-22 19:49


origen


Respuestas:


Parece que sería mejor atendido por un singleton en lugar de un montón de métodos estáticos

class Singleton
{
  /**
   * 
   * @var Singleton
   */
  private static $instance;

  private function __construct()
  {
    // Your "heavy" initialization stuff here
  }

  public static function getInstance()
  {
    if ( is_null( self::$instance ) )
    {
      self::$instance = new self();
    }
    return self::$instance;
  }

  public function someMethod1()
  {
    // whatever
  }

  public function someMethod2()
  {
    // whatever
  }
}

Y luego, en uso

// As opposed to this
Singleton::someMethod1();

// You'd do this
Singleton::getInstance()->someMethod1();

95
2017-07-22 19:56



// file Foo.php
class Foo
{
  static function init() { /* ... */ }
}

Foo::init();

De esta forma, la inicialización ocurre cuando se incluye el archivo de clase. Puede asegurarse de que esto solo suceda cuando sea necesario (y solo una vez) mediante la carga automática.


83
2017-07-22 19:58



En realidad, uso un método público estático __init__() en mis clases estáticas que requieren inicialización (o al menos necesitan ejecutar algún código). Luego, en mi autocargador, cuando carga una clase, comprueba is_callable($class, '__init__'). Si lo es, llama a ese método. Rápido, simple y efectivo ...


51
2017-07-22 20:29



Si no te gusta public inicializador estático, la reflexión puede ser una solución.

<?php

class LanguageUtility
{
    public static function initializeClass($class)
    {
        try
        {
            // Get a static method named 'initialize'. If not found,
            // ReflectionMethod() will throw a ReflectionException.
            $ref = new \ReflectionMethod($class, 'initialize');

            // The 'initialize' method is probably 'private'.
            // Make it accessible before calling 'invoke'.
            // Note that 'setAccessible' is not available
            // before PHP version 5.3.2.
            $ref->setAccessible(true);

            // Execute the 'initialize' method.
            $ref->invoke(null);
        }   
        catch (Exception $e)
        {
        }
    }
}

class MyClass
{
    private static function initialize()
    {
    }
}

LanguageUtility::initializeClass('MyClass');

?>

0
2018-01-15 20:44



Nota: el RFC que propone esto todavía está en el estado del borrador.


class Singleton
{
    private static function __static()
    {
        //...
    }
    //...
}

propuesto para PHP 7.x (ver https://wiki.php.net/rfc/static_class_constructor )


-5
2018-06-14 18:02