PHP5

As an example, you may have a CommentController with a listAction() method you wish to invoke in order to pull a list of comments for the current request:

<div id="sidebar right"> 
    <div class="item">
        <?= $this->action('list', 'comment', null, array('count' => 10)); ?> 
    </div>
</div>

Basic usage of partials is to render a template fragment in its own view scope. Consider the following partial script:

<?php // partial.phtml ?>
<ul>
    <li>From: <?= $this->escape($this->from) >?</li>
    <li>Subject: <?= $this->escape($this->subject) >?</li>
</ul>

You would then call it from your view script using the following:

<?= $this->partial('partial.phtml', array(
    'from' => 'Team Framework', 
    'subject' => 'view partials')); ?>

Which would then render:

<ul>
    <li>From: Team Framework</li>
    <li>Subject: view partials</li>
</ul>

Typically, you'll want to use partials in a loop, to render the same content fragment many times; this way you can put large blocks of repeated content or complex display logic into a single location. However this has a performance impact, as the partial helper needs to be invoked once for each iteration.

The PartialLoop view helper helps solve this issue. It allows you to pass an iterable item (array or object implementing Iterator) as the model. It then iterates over this, passing, the items to the partial script as the model. Items in the iterator may be any model the Partial view helper allows.

Let's assume the following partial view script:

<? // partialLoop.phtml ?>
    <dt><?= $this->key ?></dt>
    <dd><?= $this->value ?></dd>

And the following "model":

<?php
$model = array(
    array('key' => 'Mammal', 'value' => 'Camel'),
    array('key' => 'Bird', 'value' => 'Penguin'),
    array('key' => 'Reptile', 'value' => 'Asp'),
    array('key' => 'Fish', 'value' => 'Flounder'),
);
?>

In your view script, you could then invoke the PartialLoop helper:

<dl>
<?= $this->partialLoop('partialLoop.phtml', $model) ?>
</dl>

<dl></dl>
    <dt>Mammal</dt>
    <dd>Camel</dd>

    <dt>Bird</dt>
    <dd>Penguin</dd>

    <dt>Reptile</dt>
    <dd>Asp</dd>

    <dt>Fish</dt>
    <dd>Flounder</dd>

</dl>

Sometime a partial will exist in a different module. If you know the name of the module, you can pass it as the second argument to either partial() or partialLoop(), moving the $model argument to third position.

For instance, if there's a pager partial you wish to use that's in the 'list' module, you could grab it as follows:

<?= $this->partial('pager.phtml', 'list', $pagerData) ?>

In this way, you can re-use partials created specifically for other modules. That said, it's likely a better practice to put re-usable partials in shared view script paths.

Basic usage of placeholders is to persist view data. Each invocation of the Placeholder helper expects a placeholder name; the helper then returns a placeholder container object that you can either manipulate or simply echo out.

<?php $this->placeholder('foo')->set("Some text for later") ?>

<?php 
    echo $this->placeholder('foo'); 
    // outputs "Some text for later"
?>

Aggregating content via placeholders can be useful at times as well. For instance, your view script may have a variable array from which you wish to retrieve messages to display later; a later view script can then determine how those will be rendered.

The Placeholder view helper uses containers that extend ArrayObject, providing a rich featureset for manipulating arrays. In addition, it offers a variety of methods for formatting the content stored in the container:

<!-- first view script -->
<?php $this->placeholder('foo')->exchangeArray($this->data) ?>

<!-- later view script -->
<?php 
$this->placeholder('foo')->setPrefix("<ul>\n    <li>")
                         ->setSeparator("</li><li>\n") 
                         ->setIndent(4)
                         ->setPostfix("</li></ul>\n");
?>

<?php 
    echo $this->placeholder('foo'); 
    // outputs as unordered list with pretty indentation
?>

Because the Placeholder container objects extend ArrayObject, you can also assign content to a specific key in the container easily, instead of simply pushing it into the container. Keys may be accessed either as object properties or as array keys.

<?php $this->placeholder('foo')->bar = $this->data ?>
<?php echo $this->placeholder('foo')->bar ?>

<?php
$foo = $this->placeholder('foo');
echo $foo['bar'];
?>

Occasionally you may have content for a placeholder in a view script that is easiest to template; the Placeholder view helper allows you to capture arbitrary content for later rendering using the following API.

<!-- Default capture: append -->
<?php $this->placeholder('foo')->captureStart() 
foreach ($this->data as $datum): ?>
<div class="foo">
    <h2><?= $datum->title ?></h2>
    <p><?= $datum->content ?></p>
</div>
<?php $this->placeholder('foo')->captureEnd() ?>

<?php echo $this->placeholder('foo') ?>

<!-- Capture to key -->
<?php $this->placeholder('foo')->captureStart('SET', 'data') 
foreach ($this->data as $datum): ?>
<div class="foo">
    <h2><?= $datum->title ?></h2>
    <p><?= $datum->content ?></p>
</div>
<?php $this->placeholder('foo')->captureEnd() ?>

<?php echo $this->placeholder('foo')->data ?>

You may specify the doctype at any time. However, probably the simplest use case is to specify it and output it at the same time, at the top of your layout script:

<?= $this->doctype('XHTML1_STRICT') ?>

From this point forward, any helpers that depend on the doctype for their output will be doctype aware -- and the doctype will be present in your document.

If you need to know the doctype later, you can do so by calling getDoctype() on the object, which is returned by invoking the helper.

<?php
$doctype = $view->doctype()->getDoctype();
?>

Typically, you'll simply want to know if the doctype is XHTML or not; for this, the isXhtml() method will suffice:

<?php
if ($view->doctype()->isXhtml()) {
    // do something differently
}
?>

You may specify a headLink at any time. Typically, you will specify global links in your layout script, and application specific links in your application view scripts. In your layout script, in the <head> section, you will then echo the helper to output it.

<?php // setting links in a view script:
$this->headLink()->appendStylesheet('/styles/basic.css')
                 ->headLink(array('rel' => 'favicon', 'href' => '/img/favicon.ico'), 'PREPEND')
                 ->prependStylesheet('/styles/moz.css', 'screen', true);
?>
<?php // rendering the links: ?>
<?= $this->headLink() ?>

You may specify a new meta tag at any time. Typically, you will specify client-side caching rules or SEO keywords.

For instance, if you wish to specify SEO keywords, you'd be creating a meta name tag with the name 'keywords' and the content the keywords you wish to associate with your page:

<?php // setting meta keywords
$this->headMeta()->appendName('keywords', 'framework php productivity');
?>

If you wishedto set some client-side caching rules, you'd set http-equiv tags with the rules you wish to enforce:

<?php // disabling client-side cache
$this->headMeta()->appendHttpEquiv('expires', 'Wed, 26 Feb 1997 08:21:57 GMT')
                 ->appendHttpEquiv('pragma', 'no-cache')
                 ->appendHttpEquiv('Cache-Control', 'no-cache');
?>

Another popular use for meta tags is setting the content type, character set, and language:

<?php // setting content type and character set
$this->headMeta()->appendHttpEquiv('Content-Type', 'text/html; charset=UTF-8')
                 ->appendHttpEquiv('Content-Language', 'en-US');
?>

As a final example, an easy way to display a transitional message before a redirect is using a "meta refresh":

<?php // setting a meta refresh for 3 seconds to a new url:
$this->headMeta()->appendHttpEquiv('Refresh', '3;URL=http://www.some.org/some.html');
?>

When you're ready to place your meta tags in the layout, simply echo the helper:

<?= $this->headMeta() ?>

You may specify a new script tag at any time. As noted above, these may be links to outside resource files or scripts theselves.

<?php // adding scripts
$this->headScript()->appendFile('/js/prototype.js')
                   ->appendScript($onloadScript);
?>

Order is often important with client-side scripting; you may need to ensure that libraries are loaded in a specific order due to dependencies each have; use the various append, prepend, and offsetSet directives to aid in this task:

<?php // Putting scripts in order

// place at a particular offset to ensure loaded last
$this->headScript()->offsetSetScript(100, '/js/myfuncs.js');

// use scriptaculous effects (append uses next index, 101)
$this->headScript()->appendScript('/js/scriptaculous.js');

// but always have base prototype script load first:
$this->headScript()->prependScript('/js/prototype.js');
?>

When you're finally ready to output all scripts in your layout script, simply echo the helper:

<?= $this->headScript() ?>

Sometimes you need to generate client-side scripts programmatically. While you could use string concatenation, heredocs, and the like, often it's easier just to do so by creating the script and sprinkling in PHP tags. HeadScript lets you do just that, capturing it to the stack:

<?php $this->headScript()->captureStart() ?>
var action = '<?= $this->baseUrl ?>';
$('foo_form').action = action;
<?php $this->headScript()->captureEnd() ?>

The following assumptions are made:

You may specify a new style tag at any time:

<?php // adding styles
$this->headStyle()->appendStyle($styles);
?>

Order is very important with CSS; you may need to ensure that declarations are loaded in a specific order due to the order of the cascade; use the various append, prepend, and offsetSet directives to aid in this task:

<?php // Putting styles in order

// place at a particular offset:
$this->headStyle()->offsetSetStyle(100, $customStyles);

// place at end:
$this->headStyle()->appendStyle($finalStyles);

// place at beginning
$this->headStyle()->prependStyle($firstStyles);
?>

When you're finally ready to output all style declarations in your layout script, simply echo the helper:

<?= $this->headStyle() ?>

Sometimes you need to generate CSS style declarations programmatically. While you could use string concatenation, heredocs, and the like, often it's easier just to do so by creating the styles and sprinkling in PHP tags. HeadStyle lets you do just that, capturing it to the stack:

<?php $this->headStyle()->captureStart() ?>
body {
    background-color: <?= $this->bgColor ?>;
}
<?php $this->headStyle()->captureEnd() ?>

The following assumptions are made:

You may specify a title tag at any time. A typical usage would have you setting title segments for each level of depth in your application: site, controller, action, and potentially resource.

<?php 
// setting the controller and action name as title segments:
$request = Zend_Controller_Front::getInstance()->getRequest();
$this->headTitle($request->getActionName())
     ->headTitle($request->getControllerName());

// setting the site in the title; possibly in the layout script:
$this->headTitle('Zend Framework');

// setting a separator string for segments:
$this->headTitle()->setSeparator(' / ');
?>

When you're finally ready to render the title in your layout script, simply echo the helper:

<!-- renders <action> / <controller> / Zend Framework -->
<?= $this->headTitle() ?>

To use a registered instance just create an instance of Zend_Translate or Zend_Translate_Adapter and register it within Zend_Registry using Zend_Translate as its key.

<?php
// our example adapter
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');
Zend_Registry::set('Zend_Translate', $adapter);

// within your view
echo $this->translate('simple');
// this returns 'einfach'
?>

To use the fluent interface, create an instance of Zend_Translate or Zend_Translate_Adapter, call the helper without a parameter, and call the setTranslator() method.

<?php
// within your view
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');
$this->translate()->setTranslator($adapter)->translate('simple');
// this returns 'einfach'
?>

<?php
// our example adapter
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');

// initiate the adapter
$translate = new Zend_View_Helper_Translate($adapter);
print $translate->translate('simple'); // this returns 'einfach'
?>

You would use this way if you are not working with Zend_View and need to create translated output.

To use a single parameter just add it to the method.

<?php
// within your view
$date = "Monday";
$this->translate('Today is %1\$s', $date);
// could return 'Heute ist Monday'
?>

Or use a list of parameters and add it to the method.

<?php
// within your view
$date = "Monday";
$month = "April";
$time = "11:20:55";
$this->translate('Today is %1\$s in %2\$s. Actual time: %3\$s', $date, $month, $time);
// Could return 'Heute ist Monday in April. Aktuelle Zeit: 11:20:55'
?>

Or use an array of parameters and add it to the method.

<?php
// within your view
$date = array("Monday", "April", "11:20:55");
$this->translate('Today is %1\$s in %2\$s. Actual time: %3\$s', $date);
// Could return 'Heute ist Monday in April. Aktuelle Zeit: 11:20:55'
?>

<?php
// within your view
$date = array("Monday", "April", "11:20:55");
$this->translate('Today is %1\$s in %2\$s. Actual time: %3\$s', $date, 'it');
?>

<?php
// within your view
$date = array("Monday", "April", "11:20:55");
$this->setLocale('it')->translate('Today is %1\$s in %2\$s. Actual time: %3\$s', $date);
?>

<?php
// within your view
$date = array("Monday", "April", "11:20:55");

// returns 'de' as set default locale from our above examples
$this->getLocale();

$this->setLocale('it')->translate('Today is %1\$s in %2\$s. Actual time: %3\$s', $date);

// returns 'it' as new set default locale
$this->getLocale();
?>