Table of Contents
Zend_View is a class for working with the "view" portion of
the model-view-controller pattern. That is, it exists to
help keep the view script separate from the model and
controller scripts. It provides a system of helpers, output
filters, and variable escaping.
Zend_View is template system agnostic; you may use
PHP as your template language, or create instances of other
template systems and manipulate them within your view
Zend_View happens in two major steps:
1. Your controller script creates an instance of
Zend_View and assigns variables to that instance.
2. The controller tells the
Zend_View to render a particular
view, thereby handing control over the view script, which
generates the view output.
As a simple example, let us say your controller has a list of book data that it wants to have rendered by a view. The controller script might look something like this:
// use a model to get the data for book authors and titles.
$data = array(
'author' => 'Hernando de Soto',
'title' => 'The Mystery of Capitalism'
'author' => 'Henry Hazlitt',
'title' => 'Economics in One Lesson'
'author' => 'Milton Friedman',
'title' => 'Free to Choose'
// now assign the book data to a Zend_View instance
$view = new Zend_View();
$view->books = $data;
// and render a view script called "booklist.php"
Now we need the associated view script, "booklist.php".
This is a PHP script like any other, with one exception: it
executes inside the scope of the
Zend_View instance, which
means that references to $this point to the
instance properties and methods. (Variables assigned to the
instance by the controller are public properties of the
Zend_View instance). Thus, a very basic view script could
look like this:
if ($this->books): ?>
<!-- A table of some books. -->
<?php foreach ($this->books as $key => $val): ?>
<td><?php echo $this->escape($val['author']) ?></td>
<td><?php echo $this->escape($val['title']) ?></td>
<?php endforeach; ?>
<?php else: ?>
<p>There are no books to display.</p>
Note how we use the "escape()" method to apply output escaping to variables.
Zend_View has several options that may be set to
configure the behaviour of your view scripts.
basePath: indicate a base path from which to set the script, helper, and filter path. It assumes a directory structure of:
This may be set via
addBasePath(), or the basePath
option to the constructor.
encoding: indicate the character encoding to use
htmlspecialchars(), and other operations. Defaults
to UTF-8. May be set via
setEncoding() or the encoding
option to the constructor.
escape: indicate a callback to be used by
escape(). May be set via
setEscape() or the escape option
to the constructor.
filter: indicate a filter to use after rendering
a view script. May be set via
addFilter(), or the filter option
to the constructor.
Zend_View to emit
notices and warnings when uninitialized view variables are
accessed. This may be set by calling
strictVars(true) or passing the
strictVars option to the constructor.
In our examples, we make use of PHP long tags: <?php. We also favor the use of alternate syntax for control structures. These are convenient shorthands to use when writing view scripts, as they make the constructs more terse, keep statements on single lines, and eliminate the need to hunt for brackets within HTML.
In previous versions, we often recommended using short tags (<?
and <?=), as they make the view scripts slightly less verbose.
However, the default for the
short_open_tag setting is typically off in production or on shared
hosts -- making their use not terribly portable. If you use template
XML in view scripts, short open tags will cause the templates to fail
validation. Finally, if you use short tags when
off, the view scripts will either cause errors or simply echo PHP
code back to the viewer.
If, despite these warnings, you wish to use short tags but they are disabled, you have two options:
Turn on short tags in your
php_value "short_open_tag" "on"
This will only be possible if you are allowed to create and
.htaccess files. This directive can
also be added to your
Enable an optional stream wrapper to convert short tags to long tags on the fly:
Zend_View_Stream as a stream
wrapper for view scripts, and will ensure that your code
continues to work as if short tags were enabled.
|View Stream Wrapper Degrades Performance|
Usage of the stream wrapper will degrade performance of your application, though actual benchmarks are unavailable to quantify the amount of degradation. We recommend that you either enable short tags, convert your scripts to use full tags, or have a good partial and/or full page content caching strategy in place.
Typically, you'll only ever need to call on
render(), or one of the methods for setting/adding
filter, helper, and script paths. However, if you wish to extend
Zend_View yourself, or need access to some of its
internals, a number of accessors exist:
getVars() will return all assigned variables.
clearVars() will clear all assigned variables;
useful when you wish to re-use a view object, but want to
control what variables are available.
getScriptPath($script) will retrieve the
resolved path to a given view script.
getScriptPaths() will retrieve all registered
getHelperPath($helper) will retrieve the
resolved path to the named helper class.
getHelperPaths() will retrieve all registered
getFilterPath($filter) will retrieve the
resolved path to the named filter class.
getFilterPaths() will retrieve all registered