zend framework "$this"

Question

I am new into the Zend framework, and I have a basic question.

Assume I am working with the layout.phtml or with the index.phtml of any script.

When I am using "$this->" to what instance am I referring to?

I read in a book the following: "$this is available within the template file, and it is the gateway to Zend_View’s functionality".

Does it mean that I can access any method, of any class that lies in any file inside the library/Zend/View/Helpers directory?

Excuse me if this question is silly and/or simple enough.

Thank you

Answer 1

$this-> In a view template is a reference to the Zend_view object you create in your controller.

Try var_dump($this) or print_r($this) (echo out a <pre> before the print_r for nicer formatting) in the template. Var dump might help you figure out what is going on a little better.

Answer 2

When you use $this from within a .phtml file you are refering to an instance of Zend_View. This object is setup for you by your controller object which is an instance of Zend_Controller_Action.

Zend_Controller_action ensures that your view object has access to any view helpers that it needs. So, yes, you do have access to any helpers in the library/Zend/View/Helpers directory through the $this variable.

You also have access to any helpers that you write yourself and place in the application/views/helpers directory through $this. See the manual about writing your own view helpers. Once you start, you'll use them all the time as this is a very simple and powerful method of keeping your code DRY.

Incidentally, you also have direct access in the same way to any filters you place in the application/views/filters directory as you can see from the docblock for initView() in Zend/Controller/Action.php.

/**
 * Initialize View object
 *
 * Initializes $view if not otherwise a Zend_View_Interface.
 *
 * If $view is not otherwise set, instantiates a new Zend_View
 * object, using the 'views' subdirectory at the same level as the
 * controller directory for the current module as the base directory.
 * It uses this to set the following:
 * - script path = views/scripts/
 * - helper path = views/helpers/
 * - filter path = views/filters/
 *
 * @return Zend_View_Interface
 * @throws Zend_Controller_Exception if base view directory does not exist
 */
public function initView()

The whole process from request to response in Zend Framework is quite complicated. There are some diagrams available here and here if you are interested.

Zend Framework is very powerful and is easy to use once you have overcome the learning curve which is quite steep. It is worth persevering though as you eventually 'get it' and produce better code faster as a result. I struggled with the documentation and the API, but found that the best documentation is the code. I now have the code for any component of ZF that I am using open in a seperate netbeans window for ease of reference.

Good luck wth ZF.

Answer 3

Typically you will assign some bit of data to the view object inside a controller action using something like:

$form = My_Form;
//assign My_Form to the view object
$this->view->form = $form;

in your view script you would normally access that data using something like:

//this bit of code would display your whole form in the view script
//along with any layout information contained in your layout file
<?php echo $this->form ?>

also items can be assigned to the view object from the bootstrap and these items will be available to the layout or view scripts. Here is an example:

 protected function _initView() {
        //Initialize view
        $view = new Zend_View();
        //get doctype from application.ini
        $view->doctype(Zend_Registry::get('config')->resources->view->doctype);
        $view->headTitle('Our Home');
        //get content-type from application.ini
        $view->headMeta()->appendHttpEquiv('Content-Type',
                Zend_Registry::get('config')->resources->view->contentType);
        //add css files
        $view->headLink()->setStylesheet('/css/blueprint/screen.css');
        $view->headLink()->appendStylesheet('/css/blueprint/print.css', 'print');
        $view->headLink()->appendStylesheet('/css/master.css');
        $view->headLink()->appendStylesheet('/css/main.css');
        $view->headLink()->appendStylesheet('/css/nav.css');

        //add it to the view renderer
        $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper(
                        'ViewRenderer');
        $viewRenderer->setView($view);
        //Return it, so that it can be stored by the bootstrap
        return $view;

now this data is access inside of a layout.phtml in this manner:

<?php echo $this->doctype() . "\n"; ?>
<html>
    <head>
        <?php echo $this->headMeta() . "\n" ?>
        <?php echo $this->headLink() . "\n" ?>
        <!--[if lt IE 8]>
          <link rel="stylesheet" href="/css/blueprint/ie.css" type="text/css" media="screen, projection" />
        <![endif] -->
    </head>

now for completeness here is the PHP manual version of $this:

Within class methods the properties, constants, and methods may be accessed by using the form $this->property (where property is the name of the property) unless the access is to a static property within the context of a static class method, in which case it is accessed using the form self::$property. See Static Keyword for more information.

The pseudo-variable $this is available inside any class method when that method is called from within an object context. $this is a reference to the calling object (usually the object to which the method belongs, but possibly another object, if the method is called statically from the context of a secondary object).

This is not a complete explaination but I hope it get's you started.

Answer 4

As said $this in view is instance of Zend_View.

Please see the method render in Zend_View class

   public function render($name)
    {
        // find the script file name using the parent private method
        $this->_file = $this->_script($name);
        unset($name); // remove $name from local scope

        ob_start();
        $this->_run($this->_file);

        return $this->_filter(ob_get_clean()); // filter output
    }

Basically ZF action helper (ViewRnderer) creates an instance of Zend_View and calls the render method by passing the name of view file (index.phtml)

$view = new Zend_View(); $view->render('index.phtml');

As you can see output buffering is used ob_start in render method . Which loads the index.phtml file in context of Zend_View class hence $this can be used inside index.phtml as its code is part of the class.

Answer 5

In addition to the other answers, $this will help you to use the helpers you define in your project's application/view/helper directory. You can use all these helpers anywhere in the .phtml or the view files in your project by just binding them with zend_helper in the initializer.