modificar un método/función en el tiempo de ejecución

Question

He estado buscando los métodos de reflexión php, lo que quiero hacer es inyectar algún código después de que se abra el método y antes de cualquier valor devuelto, por ejemplo quiero cambiar:

function foo($bar) 
{ 
    $foo = $bar ; 
    return $foo ; 
} 

e inyectar un poco de código en él como:

function foo($bar) 
{ 
    //some code here 
    $foo = $bar ; 
    //some code here 
    return $foo ; 
} 

posible?

Answer 1

Mire en anonymous functions. Si puede ejecutar PHP 5.3, puede ser más acorde con lo que intenta hacer.

Answer 2

Esto no es posible, al menos no en la forma que está buscando. Como sugirió el comentario, la reflexión es para obtener información sobre clases/funciones, no modificarlas.

Hay una extensión de PHP llamada Runkit que creo que proporciona este tipo de funcionalidad - http://www.php.net/manual/en/book.runkit.php, sin embargo, esto no se instalará de manera predeterminada en la gran mayoría de los hosts que existen.

Sin embargo, puede haber una forma diferente de hacerlo. Quizás si pudiera dar más información sobre lo que está intentando hacer y por qué no puede modificar la función en cuestión, es posible que podamos proporcionar algunos indicadores. P.ej. ¿Es la función que desea modificar una función central de PHP o código en una biblioteca de terceros que no desea editar?

Answer 3

Sólo una idea:

function foo($bar, $preprocess, $postprocess){ 

    //IF CONDITION($preprocess) 
    include('/mylogic/'.$preprocess.".php"); //do some preprocessing here? 
    $foo = $bar ; 
    //IF CONDITION($postprocess) 
    include('/mylogic/'.$postprocess.".php"); //process $foo here? 
    //FINALLY return 
    return $foo; 

} 

Answer 4

Bueno, una forma, sería hacer todo el método llama "virtual":

class Foo { 
    protected $overrides = array(); 

    public function __call($func, $args) { 
     $func = strtolower($func); 
     if (isset($this->overrides[$func])) { 
      // We have a override for this method, call it instead! 
      array_unshift($args, $this); //Add the object to the argument list as the first 
      return call_user_func_array($this->overrides[$func], $args); 
     } elseif (is_callable(array($this, '_' . $func))) { 
      // Call an "internal" version 
      return call_user_func_array(array($this, '_' . $func), $args); 
     } else { 
      throw new BadMethodCallException('Method '.$func.' Does Not Exist'); 
     } 
    } 

    public function addOverride($name, $callback) { 
     $this->overrides[strtolower($name)] = $callback; 
    } 

    public function _doSomething($foo) { 
     echo "Foo: ". $foo; 
    } 
} 

$foo = new Foo(); 

$foo->doSomething('test'); // Foo: test 

PHP 5.2:

$f = create_function('$obj, $str', 'echo "Bar: " . $obj->_doSomething($str) . " Baz";'); 

PHP 5.3:

$f = function($obj, $str) { 
    echo "Bar: " . $obj->_doSomething($str) . " Baz"; 
} 

Todo PHP:

$foo->addOverride('doSomething', $f); 

$foo->doSomething('test'); // Bar: Foo: test Baz 

Se pasa la instancia del objeto como el primer método para la "override". Nota: Este método "anulado" no tendrá acceso a ningún miembro protegido de la clase. Así que use getters (__get, __set). Se tendrá acceso a métodos protegidos, ya que la llamada real viene de __call() ...

Nota: Tendrá que modificar todos los métodos por defecto a un prefijo de declaración '_' para que esto funcione. .. (o puede elegir otra opción de prefijo, o puede simplemente delimitarlos todos protegidos) ...

Answer 5

Tal vez me esté perdiendo algo, pero ¿realmente quiere "inyectar" el código como dice? ¿Qué estás intentando lograr? Si simplemente quiere ejecutar un bloque de código cuando ocurre A, y otro cuando ocurre B, entonces todo lo que necesita es una lógica de programación simple, como una instrucción if().

¿Está realmente tratando de modificar una función en tiempo de ejecución? ¿O es solo un problema de lógica?

Sea más específico sobre lo que necesita hacer.

Answer 6

Puede agregar un autocargador especial antes del autocargador original, leer el archivo que cargaría su autocargador original, cambiar el contenido, guardar ese archivo en otro lugar (algunos dir de tmp por ejemplo) e incluir ese archivo modificado en lugar del original uno.

Answer 7

Yo quería hacer exactamente lo mismo, así que creé una clase de instrumentación genérica que reemplazaría la clase que estaba tratando de instrumentar y aprovechando la técnica de @ircmaxell que llamaría a la clase para instrumentarla.

<?php 

class GenericClassInstrumentor 
{ 
    private $instrumentedClass; 
    private $className; 

    public function __construct($instrumentedClass) 
    { 
     $this->instrumentedClass = $instrumentedClass; 
     $this->className = get_class($instrumentedClass); 
    } 

    public function __call($name, $arguments) 
    { 
     $start = microtime(true); 
     $result = call_user_func_array(array($this->instrumentedClass, $name), $arguments); 
     $end = microtime(true); 
     $duration = ($end - $start) * 1000; 

     // optionally log something here 
     return $result; 
    } 
} 

Supongamos que tenía una instancia de una clase como $myClass, que tenía la función foo en él, entonces usted haría algo como esto:

$myClass = new ClassWithFoo(); 
if ($instrumentationOn) { 
    $myClass = new GenericClassInstrumentor($myClass); 
} 

Calling $myClass->foo($bar) funcionaría de la misma (con el mismo advertencias como respuesta de @ircmaxell) si $instrumentationOn es true o false. Si es true simplemente haría las cosas extra de temporización.