Ein Viewskript kann verwendet werden, um ein separats Templateobjekt zu instanzieren und anzupassen, z.B. für eine PHPLIB-style Template. Das Viewskript für solch eine Aufgabe könnte so aussehen:

<?php
include_once 'template.inc';
$tpl = new Template();

if ($this->books) {
    $tpl->setFile(array(
        "booklist" => "booklist.tpl",
        "eachbook" => "eachbook.tpl",
    ));
    
    foreach ($this->books as $key => $val) {
        $tpl->set_var('author', $this->escape($val['author']);
        $tpl->set_var('title', $this->escape($val['title']);
        $tpl->parse("books", "eachbook", true);
    }
    
    $tpl->pparse("output", "booklist");
} else {
    $tpl->setFile("nobooks", "nobooks.tpl")
    $tpl->pparse("output", "nobooks");
}
?>

Dies wären die zugehörigen Template Dateien:

<!-- booklist.tpl -->
<table>
    <tr>
        <th>Autor</th>
        <th>Titel</th>
    </tr>
    {books}
</table>

<!-- eachbook.tpl -->
    <tr>
        <td>{author}</td>
        <td>{title}</td>
    </tr>

<!-- nobooks.tpl -->
<p>Es gibt keine Bücher zum Anzeigen.</p>

Manche finden es einfacher, ein Zend_View kompatibles Templatesystem zu verwenden. Zend_View_Interface definiert die minimale Schnittstelle, die zur Kompatibilität benötigt wird.

/**
 * Gebe das aktuelle Template Engine Objekt zurück
 */
public function getEngine();

/**
 * Setze den Pfad zu den Viewskripten / Templates
 */
public function setScriptPath($path);

/**
 * Überladungsmethoden zum Zuordnen von Templatevariablen als Objekteigenschaften
 */
public function __set($key, $value);
public function __get($key);
public function __isset($key);
public function __unset($key);

/**
 * Manuelle Zuweisung von Templatevariablen oder die Möglichkeit, mehrere Variablen in einem 
 * Durchgang zuzuordnen.
 */
public function assign($spec, $value = null);

/**
 * Alle zugewiesenen Templatevariablen zurücksetzen
 */
public function clearVars();

/**
 * Rendern des Templates mit dem Namen $name
 */
public function render($name);

Durch Verwendung dieses Interfaces ist es relativ einfach, das Templatesystem eines Dritten in eine Zend_View kompatible Klasse zu umhüllen. Als Beispiel folgt ein möglicher Wrapper für Smarty:

require_once 'Zend/View/Interface.php';
require_once 'Smarty.class.php';

class Zend_View_Smarty implements Zend_View_Interface
{
    /**
     * Smarty object
     * @var Smarty
     */
    protected $_smarty;

    /**
     * Constructor
     *
     * @param string $tmplPath
     * @param array $extraParams
     * @return void
     */
    public function __construct($tmplPath = null, $extraParams = array())
    {
        $this->_smarty = new Smarty;

        if (null !== $tmplPath) {
            $this->setScriptPath($tmplPath);
        }

        foreach ($extraParams as $key => $value) {
            $this->_smarty->$key = $value;
        }
    }

    /**
     * Gebe das aktuelle Template Engine Objekt zurück
     *
     * @return Smarty
     */
    public function getEngine()
    {
        return $this->_smarty;
    }

    /**
     * Setze den Pfad zu den Templates
     *
     * @param string $path Das Verzeichnis, das als Pfad gesetzt werden soll.
     * @return void
     */
    public function setScriptPath($path)
    {
        if (is_readable($path)) {
            $this->_smarty->template_dir = $path;
            return;
        }

        throw new Exception('Invalid path provided');
    }

    /**
     * Weise dem Template eine Variable zu
     *
     * @param string $key der Variablenname.
     * @param mixed $val der Variablenwert.
     * @return void
     */
    public function __set($key, $val)
    {
        $this->_smarty->assign($key, $val);
    }

    /**
     * Hole eine zugewiesene Variable
     *
     * @param string $key der Variablenname.
     * @return mixed der Variablenwert.
     */
    public function __get($key)
    {
        return $this->_smarty->get_template_vars($key);
    }

    /**
     * Erlaubt das Testen von empty() und isset()
     *
     * @param string $key
     * @return boolean
     */
    public function __isset($key)
    {
        return (null !== $this->_smarty->get_template_vars($key));
    }

    /**
     * Erlaubt das Zurücksetzen von Objekteigenschaften
     *
     * @param string $key
     * @return void
     */
    public function __unset($key)
    {
        $this->_smarty->clear_assign($key);
    }

    /**
     * Weise dem Template Variablen zu
     *
     * Erlaubt das Zuweisen eines bestimmten Wertes zu einem bestimmten Schlüssel, ODER die 
     * Übergabe eines Array mit Schlüssel => Wert Paaren zum Setzen in einem Rutsch.
     *
     * @see __set()
     * @param string|array $spec Die zu verwendene Zuweisungsstrategie (Schlüssel oder Array mit 
     * Schlüssel => Wert paaren)
     * @param mixed $value (Optional) Wenn ein Variablenname verwendet wurde, verwende dies als den
     * Wert.
     * @return void
     */
    public function assign($spec, $value = null)
    {
        if (is_array($spec)) {
            $this->_smarty->assign($spec);
            return;
        }

        $this->_smarty->assign($spec, $value);
    }

    /**
     * Setze alle zugewiesenen Variablen zurück.
     *
     * Setzt alle Variablen zurück, die Zend_View entweder durch {@link assign()} oder
     * Überladen von Eigenschaften ({@link __get()}/{@link __set()}) zugewiesen worden sind.
     *
     * @return void
     */
    public function clearVars()
    {
        $this->_smarty->clear_all_assign();
    }

    /**
     * Verarbeitet ein Template und gibt die Ausgabe zurück
     *
     * @param string $name Das zu verarbeitende Template
     * @return string Die Ausgabe.
     */
    public function render($name)
    {
        return $this->_smarty->fetch($name);
    }
}

In diesem Beispiel kannst du die Zend_View_Smarty anstelle von Zend_View instanzieren und es dann ungefähr wie Zend_View verwenden:

$view = new Zend_View_Smarty();
$view->setScriptPath('/path/to/templates');
$view->book = 'Zend PHP 5 Certification Study Guide';
$view->author = 'Davey Shafik and Ben Ramsey'
$rendered = $view->render('bookinfo.tpl');