¿Cuál es la diferencia entre los diferentes métodos * get helper * en Magento?

Question

He visto varios enfoques para obtener un particular helper, y espero que alguien pueda explicar los pros/contras de cada enfoque. Por ejemplo, en template/checkout/cart/sidebar/default.phtml, verá $this->helper('checkout') y Mage::helper('checkout'). ¿Hay una buena razón para estos dos métodos diferentes en la misma plantilla?

A continuación se presentan las diferentes maneras de conseguir un ayudante que pude encontrar en Magento:

abstract class Mage_Core_Block_Abstract extends Varien_Object 
{ 
… 
    /** 
    * Return block helper 
    * 
    * @param string $type 
    * @return Mage_Core_Block_Abstract 
    */ 
    public function getHelper($type) 
    { 
     return $this->getLayout()->getBlockSingleton($type); 
    } 

    /** 
    * Returns helper object 
    * 
    * @param string $name 
    * @return Mage_Core_Block_Abstract 
    */ 
    public function helper($name) 
    { 
     if ($this->getLayout()) { 
      return $this->getLayout()->helper($name); 
     } 
     return Mage::helper($name); 
    } 
… 
} 

class Mage_Core_Model_Layout extends Varien_Simplexml_Config 
{ 
… 
    /** 
    * Enter description here... 
    * 
    * @param string $type 
    * @return Mage_Core_Helper_Abstract 
    */ 
    public function getBlockSingleton($type) 
    { 
     if (!isset($this->_helpers[$type])) { 
      $className = Mage::getConfig()->getBlockClassName($type); 
      if (!$className) { 
       Mage::throwException(Mage::helper('core')->__('Invalid block type: %s', $type)); 
      } 

      $helper = new $className(); 
      if ($helper) { 
       if ($helper instanceof Mage_Core_Block_Abstract) { 
        $helper->setLayout($this); 
       } 
       $this->_helpers[$type] = $helper; 
      } 
     } 
     return $this->_helpers[$type]; 
    } 

    /** 
    * Retrieve helper object 
    * 
    * @param string $name 
    * @return Mage_Core_Helper_Abstract 
    */ 
    public function helper($name) 
    { 
     $helper = Mage::helper($name); 
     if (!$helper) { 
      return false; 
     } 
     return $helper->setLayout($this); 
    } 
… 
} 

Answer 1

Mage_Core_Block_Abstract::getHelper()

El método Mage_Core_Model_Layout::getBlockSingleton() no devuelve un objeto ayudante Magento, sino más bien una instancia del bloque de tipo de objeto Magento.
Creo que esto es código heredado, como el método Mage::getBlockSingleton() está en desuso.

En ambos casos, se crea una instancia de bloque a partir de una identificación de clase de Magento.

El método getBlockSingleton() almacena la instancia en la propiedad del objeto $_helpers diseño, el método createBlock() lo almacenará en la propiedad $_blocks.

Solo los bloques de la matriz $_blocks se pueden referenciar (y sobrescribir) utilizando XML de diseño.

El método getBlockSingleton() es útil si desea una instancia de una clase de bloque específica, y desea asegurarse de no crear una nueva instancia del bloque si ya existe.
Para conseguir (casi) el mismo efecto con las instancias creadas a través de createBlock() que necesitaría el siguiente código:

public function alternativeGetBlockSingleton($classId) 
{ 
    foreach (Mage::app()->getLayout()->getAllBlocks() as $block) 
    { 
     if ($block->getType() == $classId) 
     { 
      return $block; 
     } 
    } 
    return $this->createBlock($classId); 
} 

Mage_Core_Block_Abstract::helper()

El método Mage_Core_Block_Abstract::helper() devuelve una instancia de lo que en Magento es comúnmente referido como un ayudante.
La única diferencia al llamar directamente al Mage::helper($name) es que el objeto de disposición se establece como una propiedad en la instancia auxiliar.

Uno podría argumentar que el uso de $this->helper() en archivos de plantilla es más limpio entonces Mage::helper(), porque es reduce el número de referencias codificadas (y por tanto la dependencia) a la clase Mage, pero en caso de Magento que el argumento es inútil, ya que cada módulo es muy dependiente de Mage y algunas de las clases Mage_Core de todos modos.

En la práctica probablemente no haya una razón funcional para preferir uno sobre el otro, excepto que Mage::helper() es mucho más común y conocido, será menos confuso para otros desarrolladores leer el código, lo que lo hace más fácil de mantener.

Por otro lado, Magento tiene que ver con la elección y con muchas formas de realizar una determinada tarea.