¿Cómo obtener instancia de una clase específica en PHP?

Question

tengo que comprobar si existeuna instancia de class_A, y si hay sí existe, obtener esa instancia.

¿Cómo hacerlo en PHP?

Como siempre, creo que un ejemplo simple es el mejor.

Ahora mi problema se ha convertido en:

$ins = new class_A(); 

Cómo almacenar la instancia en una variable miembro estática de class_A cuando instanciar?

Será mejor si la instancia se puede almacenar al llamar al __construct(). Diga, debería funcionar sin limitaciones en la forma en que se crea una instancia.

Answer 1

Lo que ha descrito es esencialmente el patrón singleton. Por favor, see this question por buenas razones por las que es posible que no desee hacer esto.

Si realmente quiere hacerlo, se podría implementar algo como esto:

class a { 
    public static $instance; 
    public function __construct() { 
     self::$instance = $this; 
    } 

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

$a = a::get(); 

Answer 2

if ($object instanceof class_A)

Ver PHP manual: Classes and objects

Answer 3

Debe implementar el patrón Singleton. http://www.developertutorials.com/tutorials/php/php-singleton-design-pattern-050729/page1.html

Answer 4

Creo que lo que quiere es la Registry Pattern

Answer 5

Para ampliar la respuesta Pikrass, que, básicamente, tendrá que hacer algo como esto:

class class_A { 
    private static $instance = false; 

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

    return self::$instance; 
    } 

    // actual class implementation goes here 
} 


// where you need to use the instance: 
$mySingleton = class_A::getInstance(); 
// do something with $mySingleton 

Answer 6

El patrón Singleton, con un PHP example from Wikipedia que yo' he añadido un método "checkExists" para que parezca que desea verificar la existencia de la clase sin crearla necesariamente si no sale:

final class Singleton 
{ 
    protected static $_instance; 

    protected function __construct() # we don't permit an explicit call of the constructor! (like $v = new Singleton()) 
    { } 

    protected function __clone() # we don't permit cloning the singleton (like $x = clone $v) 
    { } 

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

    public static function checkExists() 
    { 
     return self::$_instance; 
    } 
} 

if(Singleton::checkExists()) 
    $instance = Singleton::getInstance(); 

Answer 7

Tal vez usted quiere algo así como

for (get_defined_vars() as $key=>$value) 
{ 
    if ($value instanceof class_A) 
    return $value; 
} 

EDIT: Tras la lectura adicional, usted tiene que saltar a través de algunos aros para obtener referencias a objetos. Por lo tanto, es posible que desee return $$key; en lugar de return $value;. O algunos otros trucos para obtener una referencia al objeto.

Answer 8

Recuerde que al usar un singleton, básicamente está creando un gran global variable. Si tiene estado que cambia, su código puede volverse impredecible. Entonces, ten cuidado.

Answer 9

Lo que usted pide es imposible (Bueno, quizás no en un sentido técnico, pero muy poco práctico). Sugiere que tiene un malentendido más profundo sobre el propósito de los objetos y las clases.

Answer 10

Si la sustitución de la Instrucion de instancias singleton en sus archivos es un problema que puede convertirse en un comportamiento constante impulsado: las constantes son tales para toda la duración de la secuencia de comandos, por lo que en el caso de una instancia cuyo requisito sea único (para toda la duración de la secuencia de comandos), el método de construcción puede vincularse adecuadamente con la existencia/valor de una constante.

 
class superObject { 
    public function __construct() { 
     if (defined('SUPER_OBJECT')) { 
      trigger_error('Super object '.__CLASS__.' already instantiated', E_USER_ERROR); 
        // ...or just do whatever you want to do in case of instances overlap 
     } else { 
      define('SUPER_OBJECT', true); 
     } 
    // the rest of your construct method 
    // ... 
    } 
} 

Answer 11

El código de abajo tiene una calidad que promueve la eficiencia de almacenamiento en caché:

class Object { 

    public $instance_variable; 
    public $last_added_global_variable; 

    public function __construct(){ 
    //we are saving the global variable before this one so that 
    //we can be confident that we will always get the correct value 
    $this->last_added_global_variable = $this->get_last_variable_added()[count($array_of_global_variables)-1]; 
    } 

    //runs everytime a function is called in this class 
    public function __call(){ 
    //remember, this is skipped whenever the variable name is saved 
    if(!$this->instance_variable){ 
     for($i=0; $i=count($this->get_last_variable_added()); $i++){ 
     if($this->last_added_global_variable == get_last_variable_added()[$i]){ 
      $this->instance_variable = get_last_variable_added()[$i+1]; 
     } 
     } 
    } 
    } 

    private function get_last_variable_added(){ 
    $array_of_global_variables = array(); 

    foreach($GLOBALS as $g=>$v){ 
     array_push($array_of_global_variables, $g); 
    } 

    //return last added global variable 
    return $array_of_global_variables; 
    } 

} 

Aunque aparece costosa, es insignificante.

Puede notar que encontrar la última variable añadida a través de un bucle de variable global es imposible mientras todavía está en la función de construcción.