Przykładem może być kontroler CommentController zawierający akcję listAction(), którą chcesz wywołać aby pobrać dla obecnego żądania listę komentarzy:

<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: <?php echo $this->escape($this->from) ?></li>
    <li>Subject: <?php echo $this->escape($this->subject) ?></li>
</ul>

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

<?php echo $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:

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

And the following "model":

$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>
<?php echo $this->partialLoop('partialLoop.phtml', $model) ?>
</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:

<?php echo $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><?php echo $datum->title ?></h2>
    <p><?php echo $datum->content ?></p>
</div>
<?php endforeach; ?>
<?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><?php echo $datum->title ?></h2>
    <p><?php echo $datum->content ?></p>
</div>
 <?php endforeach; ?>
<?php $this->placeholder('foo')->captureEnd() ?>

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

Możesz określić typ dokumentu w dowolnej chwili. Jednak helpery których działania zależy od typu dokumentu mogą sprawdzić ten typ tylko pod warunkiem że go wcześniej określisz, więc najlepiej będzie jak określisz typ dokumentu w pliku uruchamiającym:

$doctypeHelper = new Zend_View_Helper_Doctype();
$doctypeHelper->doctype('XHTML1_STRICT');

        

I teraz wyświetl definicję typu dokumentu w swoim skrypcie layoutu:

<?php echo $this->doctype() ?>

        

Jeśli potrzebujesz sprawdzić typ dokumentu, możesz to zrobić wywołując metodę getDoctype() obiektu, który jest zwracany po wywołaniu helpera.

$doctype = $view->doctype()->getDoctype();

        

Najczęściej będzie potrzebował sprawdzić czy dany typ dokumentu jest typem XHTML czy nie; do tego wystarczy metoda isXhtml():

if ($view->doctype()->isXhtml()) {
    // zrób coś w inny sposób
}

        

Możesz użyć helpera headLink w dowolnym momencie. Najczęściej będziesz określał globalne łącza w pliku layoutu, a łącza specyficzne dla aplikacji w skryptach widoków. W skrypcie layoutu wyświetlisz na koniec wszystkie łącza w sekcji <head>.

<?php // ustawianie łącz w skrypcie widoku:
$this->headLink()->appendStylesheet('/styles/basic.css')
                 ->headLink(array('rel' => 'favicon',
                                  'href' => '/img/favicon.ico'),
                                  'PREPEND')
                 ->prependStylesheet('/styles/moz.css', 'screen', true);
?>
<?php // generowaie łącz: ?>
<?= $this->headLink() ?>

        

Możesz określić nowy znacznik meta w dowolnej chwili. Najczęściej będziesz określał zasady buforowania po stronie klienta oraz dane SEO.

Przykładowo, jeśli chcesz określić słowa kluczowe SEO, powinieneś utworzyć znacznik meta o nazwie 'keywords', a jego zawartością powinny być słowa kluczowe, które chcesz połączyć z daną stroną:

// ustawienie słów kluczowych
$this->headMeta()->appendName('keywords', 'framework php productivity');

        

Jeśli chcesz ustalić zasady buforowania po stronie klienta, powinieneś ustawić znaczniki http-equiv:

// zablokowanie buforowania po stronie klienta
$this->headMeta()->appendHttpEquiv('expires',
                                   'Wed, 26 Feb 1997 08:21:57 GMT')
                 ->appendHttpEquiv('pragma', 'no-cache')
                 ->appendHttpEquiv('Cache-Control', 'no-cache');

        

Innym popularnym przykładem użycia znaczników meta jest ustawienie typu zawartości, zestawu znaków oraz języka:

// ustawienie typu zawartości i zestawu znaków
$this->headMeta()->appendHttpEquiv('Content-Type',
                                   'text/html; charset=UTF-8')
                 ->appendHttpEquiv('Content-Language', 'en-US');

        

Ostatnim przykład pokazuje jak można w łatwy sposób wyświetlić komunikat bezpośrednio przez przekierowaniem używając znacznika "meta refresh":

// ustawienie czasu odświeżenia strony na 3 sekundy z nowym adresem URL:
$this->headMeta()->appendHttpEquiv('Refresh',
                                   '3;URL=http://www.some.org/some.html');

        

Jeśli jesteś gotowy na wyświetlenie znaczników meta w layoucie, po prostu wyświetl 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 themselves.

// 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:

// Putting scripts in order

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

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

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

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

<?php echo $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 = '<?php echo $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:

// 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:

// 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:

<?php echo $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: <?php echo $this->bgColor ?>;
}
<?php $this->headStyle()->captureEnd() ?>

The following assumptions are made:

Możesz określić tytuł w dowolnym momencie. Najczęściej będzie tak, że ustawisz segmenty dla poszczególnych części aplikacji: strony, kontrolera, akcji i prawdopodobnie zasobu.

// ustawienie nazwy kontrolera oraz akcji jako segmentów tytułu:
$request = Zend_Controller_Front::getInstance()->getRequest();
$this->headTitle($request->getActionName())
     ->headTitle($request->getControllerName());

// ustawienie nazwy strony w tytule; najczęściej skryptu layoutu:
$this->headTitle('Zend Framework');

// ustawienie odgranicznika dla segmentów
$this->headTitle()->setSeparator(' / ');

        

Kiedy jesteś juz gotowy aby wyświetlić tytuł, możesz to zrobić w swoim pliku layoutu:

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

Dołączanie plików Flash do twojej strony jest bardzo łatwe. Jedynym wymaganym argumentem jest adres URI pliku.

<?php echo $this->htmlFlash('/path/to/flash.swf'); ?>

        

Wyświetli to następujący kod HTML:

<object data="/path/to/flash.swf"
        type="application/x-shockwave-flash"
        classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
        codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab">
</object>

        

Pierwszy argument w helperze jest zawsze wymagany. Określa on adres URL zasobu, który chcesz dołączyć do dokumentu (X)HTML. Drugi argument jest wymagany tylko w helperze htmlObject. Inne helpery posiadają poprawną domyślną wartość dla tego argumentu. Trzeci argument jest używany do przekazywania atrybutów do obiektu elementu. Akceptuje on tablicę par klucz-wartość. Przykładem mogą być atrybuty classid oraz codebase. Czwarty argument przyjmuje także tylko tablice elementów w postaci klucz-wartość i używa ich do elementów <param>. Ostatni argument umożliwia przekazanie dodatkowej zawartości do obiektu. Zobacz przykład używający wszystkich argumentów.

echo $this->htmlObject(
    '/path/to/file.ext',
    'mime/type',
    array(
        'attr1' => 'aval1',
        'attr2' => 'aval2'
    ),
    array(
        'param1' => 'pval1',
        'param2' => 'pval2'
    ),
    'some content'
);

/*
Spowoduje to wyświetlenie:

<object data="/path/to/file.ext" type="mime/type"
    attr1="aval1" attr2="aval2">
    <param name="param1" value="pval1" />
    <param name="param2" value="pval2" />
    some content
</object>
*/

        

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.

// our example adapter
$adapter = new Zend_Translate(
    array(
        'adapter' => 'array',
        'content' => array('simple' => 'einfach'),
        'locale'  => '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.

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

// our example adapter
$adapter = new Zend_Translate(
    array(
        'adapter' => 'array',
        'content' => array('simple' => 'einfach'),
        'locale'  => '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.

// 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.

// 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.

// 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'

// 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');

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

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

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

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

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