remove - strip_tags php ejemplo

Inicializador de clase estático en PHP

Question

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 una función init y romper su flujo si ya se ejecutó una vez (usando una var estática $initialized ). El problema es que necesito llamarlo a cada una de las funciones de la clase.

Answer 1

En realidad, utilizo 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 ...

Answer 2

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 )

Answer 3

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

Answer 4

Si no le gusta public inicializador estático public , 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'');
?>

Answer 5

// 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.