Pues esta mañana me desperté ocioso a las 4 de la mañana y me he puesto a hacer un codiguito que trata el tema con el que siempre he tenido problemas. El ciclo de vida de objetos y el uso de clases.
En el ejemplo lo que hago básicamente es cargar 3 clases en un archivo index.php y y creo 3 archivos que usan estas 3 clases desde el index.php. De esta forma al ser cargados todos los archivos de forma relativa al index.php el ciclo de vida de los objetos debe estar vigente. Hoy me parece una chorrada abrumadora. Pero debo reconocer aunque me parezca patético que esto me ha bloqueado mucho durante mucho tiempo.
Ya que ultimamente juego con el Patrón Singleton lo he incluido (cargado) en el archivo indice y he retomado la misma instancia desde el mismo fichero index.php y también por si acaso desde otro archivo que haya pasado algun include/require que otro... para estar seguros que nada falla...
Crear los archivos en un mismo directorio y ejecutar el index.php esto creo lo hará mas claro... Mmmm... Ah... tambien el que esté ocioso le invito a prolongar el ejemplo rizando el rizo... freestyle!
Un saludo ;)
Clase: a.php
Código PHP:
<?php
class A {
private $a;
function __construct() {
echo "Class A: Loaded";
}
function setA($a) {
$this->a = $a;
echo $this->a;
}
}
?> Código PHP:
<?php
class B {
private $b;
function __construct() {
echo "Class B: Loaded";
}
function setB($b) {
$this->b = $b;
echo $this->b;
}
}
?> Código PHP:
<?php
class C {
private $c;
function __construct() {
echo "Class C: Loaded";
}
function setC($c) {
$this->c = $c;
echo $this->c;
}
}
?> Código PHP:
<?php
$a->setA('<br />Seteada la variable \'a\' en \'index1.php\' usando la clase \'a.php\'');
include 'index2.php';
?> Código PHP:
<?php
$b->setB('<br />Seteada la variable \'b\' en \'index2.php\' usando la clase \'b.php\'');
include 'index3.php';
?> Código PHP:
<?php
$c->setC('<br />Seteada la variable \'c\' en \'index3.php\' usando la clase \'c.php\' <br />---------------------------------------<br />');
$instance3 = Singleton::getInstance(); var_dump($instance3);
?> Código PHP:
<?php
class Singleton {
static private $instance;
private function __construct() {}
static function getInstance() {
if (!isset(self::$instance)) {
$c = __CLASS__;
self::$instance = new $c;
}
return self::$instance;
}
}
?> Código PHP:
<?php
/* *
*
* 0. La clase es cargada al ser instanciada gracias al método mágico __autoload.
* 0.1. Creamos la instancia '$instance1' y vemos que var_dump devuelve el indentificador '#1'
* 0.2. Creamos una instancia con otro nombre para enfatizar que es algo nuevo... esta vez '$instance2' y vemos que var_dump devuelve el indentificador '#1' de nuevo.
* 0.3. El patrón lo que ha hecho ha sido volver a utilizar la instancia '#1', por que esta ya habia sido llamada, de esta manera nos aseguramos utilizar siempre la misma instancia.
* 0.4. En el archivo 'index3.php' creo otra instancia llamada 'instance3' y como explico en el punto3 aunque la clase haya sido cargada en este mismo archivo la instancia funciona por los includes correlativos.
* Objetivo del punto 0: Demostrar que el patrón singleton reutiliza la instancía que creó anteriormente al instanciar la clase.
*
* */
$instance1 = Singleton::getInstance(); var_dump($instance1); echo "<br />";
$instance2 = Singleton::getInstance(); var_dump($instance2); echo "<br />---------------------------------------<br />";
/* *
*
* 1. Creamos una clase '__autoload' para la carga de las librerias/clases 'Singleton', 'a', 'b', y 'c'.
*
* */
function __autoload($class) {
require_once $class.".php";
}
/* *
*
* 2. Instanciamos las librerias/clases 'a', 'b', y 'c'.
*
* */
$a = new A(); echo "<br />";
$b = new B(); echo "<br />";
$c = new C(); echo "<br />---------------------------------------";
/* *
* 3. Cargaremos el archivo 'index1.php' que usará la clase 'a' instanciada en el archivo 'index.php' como '$a'.
* 3.1. El archivo 'index1.php' a su vez cargará el archivo 'index2.php' que usará la clase 'b' instanciada en el archivo 'index.php' como '$b'.
* 3.2. El archivo 'index2.php' a su vez cargará el archivo 'index3.php' que usará la clase 'c' instanciada en el archivo 'index.php' como '$c'.
*
* Objetivo del punto 3: Demostrar que una vez hemos cargado e instanciado una clase en un archivo determinado este podrá ser usado por los subsiguientes archivos que sean cargados dentro del ambito del primero ya que su carga ha sido correlativa, el index3 dentro del index2, el index2 dentro del index1 y el index1 a su vez dentro del archivo index donde se cargaron las clases por primera vez.
*
* */
require_once 'index1.php';
?> 
