Initialiseur de classe statique en PHP

Question

J'ai une classe d'aide avec quelques fonctions statiques. Toutes les fonctions de la classe nécessitent une fonction d'initialisation «lourde» pour s'exécuter une fois (comme s'il s'agissait d'un constructeur).

Existe-t-il une bonne pratique pour y parvenir?

La seule chose que je pensais était d'appeler une fonction init, et briser son flux si elle a déjà exécuté une fois (en utilisant un $initialized var statique). Le problème est que je dois l'appeler sur chacune des fonctions de la classe.

Answer 1

On dirait que vous seriez mieux servis par un singleton plutôt qu'un tas de méthodes statiques

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 
    } 
} 

Et puis, dans l'usage

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

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

Answer 2

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

Foo::init(); 

De cette façon, l'initialisation se produit lorsque le fichier de classe est inclus. Vous pouvez vous assurer que cela ne se produit que si nécessaire (et une seule fois) en utilisant le chargement automatique.

Answer 3

En fait, j'utiliser une méthode statique publique __init__() sur mes classes statiques qui nécessitent l'initialisation (ou au moins besoin d'exécuter du code). Ensuite, dans mon autochargeur, lorsqu'il charge une classe, il vérifie is_callable($class, '__init__'). Si c'est le cas, il appelle cette méthode. Rapide, simple et efficace ...

Answer 4

Remarque - la RFC proposant cette option est toujours à l'état de brouillon.

---

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

proposé pour 7.x PHP (voir https://wiki.php.net/rfc/static_class_constructor)

Answer 5

Si vous ne l'aimez pas public statique initialiseur, la réflexion peut être une solution de contournement.

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

?>