Comment fonctionne la syntaxe de la méthode "public function direct() {}" en PHP?

Question

J'étudie Zend Framework pour le moment et suis tombé sur la syntaxe suivante.

class Zend_Controller_Action_Helper_Redirector extends Zend_Controller_Action_Helper_Abstract 
{ 
    /** 
    * Perform a redirect to an action/controller/module with params 
    * 
    * @param string $action 
    * @param string $controller 
    * @param string $module 
    * @param array $params 
    * @return void 
    */ 
    public function gotoSimple($action, $controller = null, $module = null, array $params = array()) 
    { 
     $this->setGotoSimple($action, $controller, $module, $params); 

     if ($this->getExit()) { 
      $this->redirectAndExit(); 
     } 
    } 

    /** 
    * direct(): Perform helper when called as 
    * $this->_helper->redirector($action, $controller, $module, $params) 
    * 
    * @param string $action 
    * @param string $controller 
    * @param string $module 
    * @param array $params 
    * @return void 
    */ 
    public function direct($action, $controller = null, $module = null, array $params = array()) 
    { 
     $this->gotoSimple($action, $controller, $module, $params); 
    } 
} 

Dans Zend Framework la méthode directe() dans cette classe peut être appelé en utilisant la syntaxe suivante:

$this->_helper->redirector('index','index'); 

Où redirecteur est un objet dans l'objet _helper, qui est à l'intérieur du (!) objet contrôleur, dans lequel nous appelons la méthode. Le sucre syntaxique est ici que vous pouvez simplement passer des paramètres à l'objet au lieu de la méthode que nous écrivions comme ceci:

$this->_helper->redirector->gotoSimple('index','index'); 

..which est bien beau ofcourse.

Voici ma question: cette méthode est-elle directe() dans OO PHP? Ou cette fonctionnalité est-elle intégrée dans Zend Framework? Je ne trouve aucune documentation à ce sujet.

Merci!

Answer 1

Il s'agit d'une fonctionnalité intégrée à Zend Framework.

La propriété $_helpers de l'instance du contrôleur contient une instance Action_HelperBroker. Cette instance implémente PHP's magic __call method. Lorsque vous appelez une méthode qui n'existe pas sur cette instance, elle essaie d'utiliser le nom de la méthode pour récupérer un assistant du même nom et appelle le direct() dessus (si possible). Voir le code ci-dessous.

De Zend_Controller_Action

/** 
* Helper Broker to assist in routing help requests to the proper object 
* 
* @var Zend_Controller_Action_HelperBroker 
*/ 
protected $_helper = null; 

De Zend_Controller_Action_HelperBroker

/** 
* Method overloading 
* 
* @param string $method 
* @param array $args 
* @return mixed 
* @throws Zend_Controller_Action_Exception if helper does not have a direct() method 
*/ 
public function __call($method, $args) 
{ 
    $helper = $this->getHelper($method); 
    if (!method_exists($helper, 'direct')) { 
     require_once 'Zend/Controller/Action/Exception.php'; 
     throw new Zend_Controller_Action_Exception('Helper "' . $method . '" does not support overloading via direct()'); 
    } 
    return call_user_func_array(array($helper, 'direct'), $args); 
} 

Le courtier Helper mettent également en œuvre la méthode __get magique, donc lorsque vous essayez d'accéder à une propriété qui n'existe pas, le courtier utilisera le nom de la propriété en tant qu'argument à getHelper()

/** 
* Retrieve helper by name as object property 
* 
* @param string $name 
* @return Zend_Controller_Action_Helper_Abstract 
*/ 
public function __get($name) 
{ 
    return $this->getHelper($name); 
} 

Veuillez noter que les méthodes magiques ne sont pas destinées à remplacer une API appropriée. Alors que vous pouvez les utiliser comme indiqué ci-dessus, appelez le plus verbeux

$this->_helper->getHelper('redirector')->gotoSimple('index','index'); 

est souvent l'alternative beaucoup plus rapide.