Comment ajouter une nouvelle méthode à un objet PHP en cours d'exécution ?

Question

Comment ajouter une nouvelle méthode à un objet "sur le pouce" ?

$moi = new stdClass;
$moi->doSomething = function () {
    echo 'J\'ai fait quelque chose';
};
$moi->doSomething();

//Erreur fatale : Appel à une méthode non définie stdClass::doSomething()

Answer 1

Vous pouvez utiliser __call pour cela :

class Foo
{
    public function __call($method, $args)
    {
        if (isset($this->$method)) {
            $func = $this->$method;
            return call_user_func_array($func, $args);
        }
    }
}

$foo = new Foo();
$foo->bar = function () { echo "Bonjour, cette fonction est ajoutée à l'exécution"; };
$foo->bar();

Answer 2

En utilisant simplement __call pour permettre l'ajout de nouvelles méthodes à l'exécution a pour inconvénient majeur que ces méthodes ne peuvent pas utiliser la référence d'instance $this. Tout fonctionne bien, tant que les méthodes ajoutées n'utilisent pas $this dans le code.

class AnObj extends stdClass
{
    public function __call($closure, $args)
    {
        return call_user_func_array($this->{$closure}, $args);
    }
}
$a=new AnObj();
$a->color = "red";
$a->sayhello = function(){ echo "hello!";};
$a->printmycolor = function(){ echo $this->color;};
$a->sayhello();//output: "hello!"
$a->printmycolor();//ERROR: Undefined variable $this

Pour résoudre ce problème, vous pouvez réécrire le modèle de cette manière

class AnObj extends stdClass
{
    public function __call($closure, $args)
    {
        return call_user_func_array($this->{$closure}->bindTo($this),$args);
    }

    public function __toString()
    {
        return call_user_func($this->{"__toString"}->bindTo($this));
    }
}

De cette façon, vous pouvez ajouter de nouvelles méthodes qui peuvent utiliser la référence d'instance

$a=new AnObj();
$a->color="red";
$a->sayhello = function(){ echo "hello!";};
$a->printmycolor = function(){ echo $this->color;};
$a->sayhello();//output: "hello!"
$a->printmycolor();//output: "red"

Answer 3

Mise à jour : L'approche présentée ici a un inconvénient majeur : la nouvelle fonction n'est pas un membre entièrement qualifié de la classe ; $this n'est pas présent dans la méthode lorsqu'elle est appelée de cette manière. Cela signifie que vous devriez passer l'objet à la fonction en tant que paramètre si vous souhaitez travailler avec des données ou des fonctions de l'instance de l'objet ! De plus, vous ne pourrez pas accéder aux membres private ou protected de la classe à partir de ces fonctions.

Bonne question et idée astucieuse d'utiliser les nouvelles fonctions anonymes !

De manière intéressante, cela fonctionne : Remplacez

$me->doSomething();    // Ne fonctionne pas

par call_user_func sur la fonction elle-même :

call_user_func($me->doSomething);    // Fonctionne !

ce qui ne fonctionne pas est la façon "correcte" :

call_user_func(array($me, "doSomething"));   // Ne fonctionne pas

si appelé de cette manière, PHP exige que la méthode soit déclarée dans la définition de la classe.

S'agit-il d'une question de visibilité private / public / protected ?

Mise à jour : Non. Il est impossible d'appeler la fonction de la manière habituelle même depuis l'intérieur de la classe, donc ce n'est pas une question de visibilité. Passer la fonction réelle à call_user_func() est la seule façon que je trouve pour que cela fonctionne.

Answer 4

Voici une classe simple qui permet de définir une fonction anonyme. C'est une classe optimisée de https://gist.github.com/nickunderscoremok/5857846

 $argument) {
                if ($argument instanceOf Closure) {
                    $this->{$property} = $argument;
                } else {
                    $this->{$property} = $argument;
                }
            }
        }
    }

    public function __call($method, $arguments) {
        if (isset($this->{$method}) && is_callable($this->{$method})) {
            return call_user_func_array($this->{$method}, $arguments);
        } else {
            throw new Exception("Erreur fatale : Appel à une méthode non définie dans stdObject::{$method}()");
        }
    }
}

$person = new stdObject(array(
    "name" => "nick",
    "age" => 23,
    "friends" => array("frank", "sally", "aaron"),
    "sayHi" => function() {
        return "Bonjour";
    }
));

$person->sayHi2 = function() {
    return "Bonjour 2";
};

$person->test = function() {
    return "test";
};

var_dump($person->name, $person->test(), $person->sayHi2());
?>

Answer 5

Il y a un post similaire sur stackoverflow qui clarifie que cela n'est réalisable qu'à travers la mise en œuvre de certains design patterns.

L'unique autre moyen est par l'utilisation de classkit, une extension php expérimentale. (aussi dans le post)

Oui, il est possible d'ajouter une méthode à une classe PHP après sa définition. Vous devez utiliser classkit, qui est une extension "expérimentale". Il semble que cette extension ne soit pas activée par défaut, donc cela dépend si vous pouvez compiler un binaire PHP personnalisé ou charger des DLL PHP si vous êtes sur Windows (par exemple Dreamhost autorise les binaires PHP personnalisés, et ils sont assez faciles à configurer).