valor - Extensiones variables de clases variables en PHP: ¿es posible?

request php

Question

¿Es posible algo como lo siguiente en PHP?

$blah = ''foo1'';
class foo2 extends $blah {
//...
}
class foo1 {
//...
}

Esto da un error.

Quiero establecer dinámicamente $ blah para que pueda extender cualquier clase que desee.

Editar: La razón por la que quiero hacer esto es porque quería usar una función de otra clase en una clase relacionada. Al final hubiera sido algo así como:

Final extends foo1 extends foo2 extends foo3 extends foo4 extends parent { ... }

Al final, decidí crear una instancia de la otra clase dentro de la clase y usarla. No son las mejores opciones porque ambos son 2 de las mismas clases, pero esto no se usará con tanta frecuencia, por lo que funcionará por el momento.

Answer 1

Estás asumiendo que php se ejecuta de arriba abajo, pero no funciona así:

<?php
foo(); # works
function foo(){
print "bar";
}

<?php
foo(); #dies
if( $i == 1 )
{
function foo(){
print "bar";
}
}

<?php
$i = 1;
if( $i == 1 )
{
function foo(){
print "bar";
}
}
foo(); #works

Ahora, aunque puedes crear clases de manera condicional:

<?php
class A { }
class B { }
if( false ){
class C extends B {
public static function bar(){
print "baz";
}
}
}
C::bar(); # dies

No puedes instanciar uno en tiempo de ejecución a partir de una variable:

<?php
class A { }
class B { }
$x = ''B'';
if( false ){
class C extends $x {
public static function bar(){
print "baz";
}
}
}
C::bar();
---> Parse error: syntax error, unexpected T_VARIABLE, expecting T_STRING in /tmp/eg.php on line 7

Hay una forma de hacerlo con Eval, pero realmente no quieres ir allí:

<?php
class A { }
class B { }
$x = ''B'';
if( true ){
$code =<<<EOF
class C extends $x {
public static function bar(){
print "baz";
}
}
EOF;
eval( $code );
}
C::bar();
$o = new C;
if ( $o instanceof $x )
{
print "WIN!/n";
}
--->barWIN!

Sin embargo, hay una pregunta más importante aquí:

¿Por qué demonios querrías extender una clase diferente en tiempo de ejecución?

Cualquiera que use su código querrá retenerlo y azotarlo por eso.

(Alternativamente, si te gustan los azotes, haz ese truco de eval)

Answer 2

No veo cómo esto sería particularmente útil, pero para responder a su pregunta ... no. No hay forma de hacerlo dinámicamente porque la clase generada debe crearse una instancia antes de que se evalúe la variable (si tiene sentido).

Para decirlo simplemente: la clase debe existir antes de que el código pueda ejecutarse correctamente.

Answer 3

Si no tiene demasiados valores para $ blah, puede extender cada uno en un archivo diferente y luego require_once "classes/foo_$blah.php"

De lo contrario, estás atascado con la solución eval() ... buena suerte con eso ... :)

Answer 4

deberías haber intentado $$

$blah = ''foo1'';
class foo2 extends $$blah {
//...
}
class foo1 {
//...
}

Answer 5

Probé algo con define y ladrando:

<?php
define("INHERIT",A);
class A{
public function bark(){
return "I''m A";
}
}
class B{
public function bark(){
return "I''m B";
}
}
class C extends INHERIT{}
//main?
$dog = new C();
echo $dog->bark();
?>

la salida es:

Error fatal: Clase ''INHERIT'' no encontrada en D: / sites / inherit.php en la línea 15

entonces la respuesta para "¿son posibles las extensiones de clase variable?" no es.

Answer 6

Sé que esta pregunta fue hecha hace mucho tiempo, pero la respuesta es relativamente simple.

Asumiendo que quieres extender la clase foo si existe la clase foo, o la barra de clase si no, usarías:

if(!class_exists(''foo'')) {
class foo extends bar {
function __construct() {
parent::__construct();
}
}
}
class myclass extends foo{
//YOUR CLASS HERE
}

Answer 7

<?php
class AAA
{
function go()
{
echo ''WORKS!'';
}
}
$a = ''AAA'';
use AAA as Eclass;
class BBB extends EClass
{
}
BBB::go();
?>

Answer 8

Supongo que esto es para facilitar el mantenimiento, ¿verdad? Extender una clase en tiempo de ejecución realmente es bastante loco.

class SuperClassOne { /* code */ }
class SuperClassTwo { /* code */ }
class IntermediateClass extends SuperClassOne { /* empty! */ }
class DescendantClassFoo extends IntermediateClass{ }
class DescendantClassBar extends IntermediateClass{ }
class DescendantClassBaz extends IntermediateClass{ }

Luego, cuando quiera cambiar todas sus clases DescendantClass* , solo tiene que cambiar lo que se extiende la Clase Intermedia:

class IntermediateClass extends SuperClassTwo { }

Answer 9

Usando la sobrecarga de PHP puedes lograr esto hasta cierto punto.

class variable_class {
public $orginalBaseClass;
public $orginalArgs;
public function __construct() {
// Get constructor parameters.
$this->orginalArgs = func_get_args();
// Get class name from args or 3rd party source.
$classname = ''stdClass'';
// Pass along args to new class.
$this->orginalBaseClass = new $classname($this->orginalArgs);
}
public function __call($name, $arguments) {
// Pass all method calls to the orginalBaseClass.
return call_user_func_array(array($this->orginalBaseClass, $name), $arguments);
}
}

Estoy usando este patrón dentro de un módulo de Drupal para captar datos de la memoria caché .