[SOLUCIONADO] PHP hardcodea __construct() y clone() .. por que ?

[Italico76]

Haciendo experimentos... acabo de caer en cuentas de porque perdi como 3 horas hoy tratando de crea un objeto como clase derivada en runtime pero desde el constructor y luego con clone() y siempre con resultados inesperados

Código PHP:

<?php
 
Class Foo
{
    public $bar="Bar";  
    
    public function __construct()
    {
        // aca no funciona, esta hardcodeada la devolucion a $this
        return new StdClass;
    }
    
    public function __clone()
    {
        // aca no funciona, esta hardcodeada la devolucion a $this
        return new StdClass;
    }
    
    // aca si
    public function getInstance()
    {       
        return new StdClass;
    }
    
}
 
$foo = new Foo;
var_dump ($foo);
var_dump(clone $foo);
var_dump ($foo->getInstance());
 

Arroja:

Foo Object
(
[bar] => Bar
)
Foo Object
(
[bar] => Bar
)
stdClass Object
(
)

Alguna idea de porque me quieren complicar la vida ?

[pateketrueke]

Un constructor jamás podrá devolver una instancia ajena.

Es decir, ¿para qué usas clases si piensas devolver un objeto que no representa a la clase?

[Italico76]

Iniciado por pateketrueke

Un constructor jamás podrá devolver una instancia ajena.

Es decir, ¿para qué usas clases si piensas devolver un objeto que no representa a la clase?

Bueno, necesito crear en runtime una clase derivada, esa parte la tengo facil con eval() pero luego quisiera devolverla de una vez o sea que el objeto creado sea una instancia de una clase derivada (especificamente porque quiero cambiarle la firma de "tipo" en runtime a la padre y eso no es posible)

Creo me devolvere sobre mis pasos.... y hare una clase estatica que cree los objetos que necesito, es mas económico y de todas formas no puedo ocupar ni el __construct() ni clone() asi que ni modo


Creeria que PHP podria tener en cuenta que estoy devolviendo un objeto y no sobre-escribir mi devolucion pero seguramente seria "transgiversar" el objetivo de un constructor... algo asi como lo que tu dices.

Gracias amigo

[pateketrueke]

Pues sí, ahí necesitas implementar el patrón Factory, y ni siquiera necesitas usar clases para eso.

Al final un método estático no es más que una función sin estado.

[hhs]

Creeria que PHP podria tener en cuenta que estoy devolviendo un objeto y no sobre-escribir mi devolucion pero seguramente seria "transgiversar" el objetivo de un constructor... algo asi como lo que tu dices.

Precisamente para eso es el polimorfismo y el principio de sustitución de liskov: para que puedas usar los objetos de forma intercambiable.

[NSD]

Tanto el constructor, como el destructor y clone, no retornan nada (void):
http://www.php.net/manual/es/language.oop5.decon.php
http://www.php.net/manual/es/languag...p#object.clone
new y clone son construcciones del lenguaje y los metodos respectivos no son mas que unos callbacks posteriores a la creacion/clonacion del objeto, php ya sabe lo que va a retornar antes de ejecutar el metodo, la prueba esta en que la variable $this esta disponible, y esta no es modificable en ningun momento, hacerlo produce un error fatal y bla bla bla.

__construct, __destruct y __clone no son como los metodos magicos (http://www.php.net/manual/es/language.oop5.magic.php) si bien el contenido de return es evaluado, la respuesta es void.

No obstante, puedes hacer esto como una alternativa para lograr un efecto similar:

Código PHP:

$foo = (new Foo)->getInstance();
 

[lolainas]

Esto podrías hacer:

Código PHP:

class Padre {
    
    function __construct() {
        return new DateTime;
    }
    
    function __clone() {
        return new DOMDocument;
    }
    
}
 
class Hijo extends Padre {
    
    function __construct() {
        var_dump(__METHOD__, parent::__construct());
    }
    
    function __clone() {
        var_dump(__METHOD__, parent::__clone());
    }
    
}
 
clone new Hijo;
 

Según parece, sólo podrías captar ese valor desde una clase hija, en la última hija ya nunca más podrías recuperar ese valor desde fuera.

[Italico76]

Ya, ...

Código PHP:

$this = new StdClass;
 

Lo anterior tampoco funciona, $this es una propiedad readonly que solo devuelve un puntero al espacio local.


En otros lenguajes como Javascritpt o Python se puede sobre-escribir una funcion / metodo / clase pero en PHP no, si se pudiera seria una salida pero como dice @pateketrueke para eso hay un patron que lo resuelve.


Curiosamente... esto tampoco funciona, no da error ni funciona:

Código PHP:

Class Bar
{ }
 
Class Foo
{
        
    public function __construct()
    {
        global $foo;
        $foo = new Bar;         
    }   
}
 
 
 
$foo = new Foo;
debug ($foo);
debug ($foo); // tampoco ahora :)
 

Esperaria que la segunda vez al menos fuera de tipo 'Bar' pero no... sigue siendo 'Foo object'

[NSD]

Código PHP:

Class Bar { }
 
Class Foo
{
        
    public function __construct()
    {
        global $foo;
        $foo = new Bar;         
    }   
}
 
 
 
$foo = new Foo;
debug ($foo);
debug ($foo); // tampoco ahora :)
 

Veamos lo que hace ese codigo:

1) $foo = new Foo;

es equivalente a:

1.a) $foo = (new Foo);

por lo tanto $foo sufre estos cambios:

1) $foo = undefined (que no esta seteada)
2) Primero se resuelve la llamada al constructor de Foo
2.a) Se declara a $foo como global, como no esta definida, se le asigna null.
2.b) $foo = null;
2.c) El constructor setea la variable global con una instancia de Bar
2.d) $foo = new Bar;
3) Ahora, se resulve la igualdad, como el constructor devuelve una instancia del objeto Foo, entonces
3.a) $foo = new Foo

Se entiende porque no funciona? la asignacion esta pisando la instancia de Bar que tu asignas manualmente.

Ahora, para esto hay alternativas, la primera:

Código PHP:

<?php
Class Bar { } 
Class Foo
{        
    public function __construct()
    {
        global $foo;
        var_dump($foo);
        $foo = new Bar; 
        var_dump($foo);        
    }   
}
new Foo;
var_dump($foo);  
 
//null
//object(Bar)[2]
//object(Bar)[2]
 

lo cual esta bien, perooooo, estas atado a la variable $foo, entonces, generalizando:

Código PHP:

<?php
Class Bar { } 
Class Foo
{        
    public function __construct(&$foo)
    {
        var_dump($foo);
        $foo = new Bar; 
        var_dump($foo);        
    }   
}
new Foo($foo);
var_dump($foo);  
 
//null
//object(Bar)[2]
//object(Bar)[2]
 

tienes un efecto similar

[Italico76]

@NSD : excelente analisis y resolucion del problema !

Que pesar que "new Foo($foo);" no sea una forma muy estandar de instanciar un objeto y por tanto no la veo para un proyecto donde terceros deban utilizar una clase con esta implementacion :-\

[NSD]

Que pesar que "new Foo($foo);" no sea una forma muy estandar de instanciar un objeto y por tanto no la veo para un proyecto donde terceros deban utilizar una clase

Desde el punto de vista practico, tienes toda la razon.
Desde el punto de vista teorico, estaria bueno hacer unos benchmarks y ver que es mas eficiente, si esta implementacion, la asignacion tradicional, o una factoria, como para dar un ultimo punto de vista al tema solo por curiosidad, mas alla de que lo que dices es totalmente razonable.

[hhs]

Buen análisis NSD.
No seria útil desde el punto de vista de diseño, ya que Foo tiene que conocer a Bar para crear la instancia y eso crea acoplamiento. Ademas de que estas violando el encapsulamiento al manejar la asignación fuera de la clase.
En cuanto a eficiencia no debe de haber mucha diferencia entre las tres opciones, con el valor agregado de que los patrones de creación son mas flexibles.

[NSD]

Por si les interesa, comparto los resultados de un benchmarck por los seis métodos, asignación directa, utilización de new con parámetro referenciado, factoría estática con return y factoría estática con parámetro referenciado, funcion comun con return, funcion comun con parametro referenciado.

El código esta aquí para que puedan replicar cómodamente la prueba: https://eval.in/157663

Y los resultados son estos:

$foo = new Bar(); 0.00042104721069335938
new Foo($foo); 0.00061511993408203125
$foo = Factory::getBar(); 0.00041198730468750000
Factory::setBar($foo); 0.00048804283142089844
$foo = getBar(); 0.00042486190795898438
setBar($foo); 0.00047302246093750000

No voy a hacer un análisis, como diría cierto reggaetonero "Los números hablan por si solos"

[NSD]

Revivo este tema ya que existe otra forma diferente de lograr el efecto buscado que no esta expuesta:

Código PHP:

<?php
    class foo
    {
    
    }
    
    $class = "foo";
    
    $foo = new $class;
    
    var_dump($foo); // object(foo)[1]
 

La pongo solo como curiosidad, la flexibilidad de PHP es muy grande.

[hhs]

viene documentada en el manual: http://www.php.net/manual/en/languag...oop5.basic.new

[NSD]

@hhs tienes razon, no me habia percatado, bueno entonces aca va otra opcion usando constantes:

Código PHP:

<?php
    define("actFoo", "foo");
    
    class foo
    {
    }     
    
    $foo = new ${${constant('actFoo')} = constant('actFoo')};
    
    var_dump($foo);
 

de todas las expuestas, es sin duda, la mas rebuscada.