Classes PHP: appel d'une fonction spécifique à chaque appel de méthode

Question

Je souhaite appeler une fonction à chaque appel de méthode en PHP.

Exemple:

$a = new a(); 
$a->function1(); 

cela fait 2 appels de fonction: basicFunction() puis function1()

même serait le cas pour les appels ultérieurs de méthode de cette classe. est-ce possible en PHP orienté objet?

Answer 1

Le plus simple serait de simplement appeler la méthode

public function function1 { 
    $this->basicFunction(); 
    // … 
} 

Ce que vous êtes est probablement après quelque chose comme Aspect Oriented Programming. Cependant, ce n'est pas commun en PHP. L'utilisation la plus notable est dans le Flow3 framework.

Pour d'autres approches plus communes utilisables avec PHP POO, un coup d'oeil à

• the Decorator pattern
• the Subject/Observer pattern
• Event Dispatcher pattern

Ceux-ci vous permettra d'ajouter un comportement arbitraire et contrôle de flux lors de l'exécution.

---

(méta) Sur un Sidenote, avons-nous vraiment besoin de quatre réponses suggérant d'utiliser __call? Je suggère que les différents OP examinent leurs réponses respectives, résolvent les minuscules différences et se mettent d'accord sur ce qui est le mieux. Les trois autres pourraient retirer leurs réponses alors.

Answer 2

Il n'y a rien de tel en PHP. Vous pouvez cependant, simuler ce comportement en utilisant la magic method __call():

class YourClass { 
    public function __call($method, $args){ 
     // do what you want to do everywhere (i.e. call your basicFunction) 
     return call_user_func_array(array($this, 'base'.ucfirst($method)), $args); 
    } 

    private baseSomeFunction() { 
     // ... 
    } 
} 

Utilisation:

$obj = new YourClass(); 
$obj->someFunction(); // this calls baseSomeFunction and executes the code 
         // in the __call() method 

Préfixer vos méthodes « magiques » avec quelque chose comme base veille à ce que personne ne peut appeler vos réceptions privées et limite cet accès seulement aux fonctions qui ont été préfixées. Vous devriez changer ce préfixe pour répondre à vos besoins.

Answer 3

Bien sûr, même si cela implique certains frais généraux. La méthode magique _call traitera des méthodes non existantes pour que vous puissiez faire:

class myClass { 
    public function __call($name, $arguments) { 

     $this->doSomething(); 
     $this->$name($arguments); 
    } 

    private function calledmethod() { ... } 

Et vous appelez:

$class->calledmethod(); 

Puisque la méthode calledmethod n'est pas publique, _call obtiendraient alors invoquaient exécuterait votre méthode de base, puis calledmethod.

Je me sens obligé de demander, POURQUOI avez-vous besoin de faire cela? Il y a probablement une solution plus élégante si vous décrivez le problème que vous essayez de résoudre.

Answer 4

vous devez utiliser le __call magic method Pour votre exemple:

class Foo{ 
    public function __call($method_name, $arguments){ 
     $this->basicFunction(); 
     return call_user_func_array(array($this, $method_name), $arguments); 
    } 


    private function basicFunction(){} 
    protected function function1(){} 
} 

Answer 5

Utilisez la fonction __call magique comme ceci:

class a { 
    private function function1() { ... } 
    public function __call($name, $args) { 
     /* do stuff */; 
     return call_user_func_array(array($this, $name), $args); 
    } 
} 

Notez cependant cela ne fonctionnera pas si function1() est appelée à partir à l'intérieur de la classe. Ensuite, vous devrez renommer function1() et l'appeler avec un nom différent. L'idée est que __call est appelée seulement si la fonction n'existe pas ou ne peut pas être vue.