Rheinwerk Computing

17.6 HTML_Template_IT

Besprochene Version: 1.1	Lizenz: PHP-Lizenz
Klassendatei(en): HTML/Template/IT.php

HTML_Template_IT (IT steht für Integrated Template) ist ein recht einfach gehaltenes, bodenständiges Template-System, das aber doch ein wenig gewöhnungsbedürftig ist. Wie bei allen Template-Systemen ist auch hier eine Trennung zwischen der Datei mit der eigentlichen Programmierlogik und dem Layout, sprich dem Template, vorgesehen.

Ein Template besteht in diesem Fall aus normalen HTML-Befehlen, die in Blöcken zusammengefasst werden. Diese selbst definierbaren Blöcke stellen logische Strukturen dar, die dann mithilfe des Pakets angesprungen und ausgewertet werden können. Des Weiteren kennt das Paket frei definierbare Platzhalter. Diese werden während der Verarbeitung durch entsprechende Inhalte ersetzt, so dass sich eine komplette, darstellbare HTML-Seite ergibt.

Sowohl die Namen der Blöcke als auch die der Platzhalter dürfen aus den Buchstaben von A bis Z (in Groß- und Kleinschrift) sowie den Ziffern von 0–9, dem Binde- und dem Unterstrich bestehen. Andere Sonderzeichen wie deutsche Umlaute oder Leerzeichen sind nicht zulässig.

Ein Block wird immer von einem öffnenden und einem schließenden Tag eingerahmt. Diese Tags erinnern stark an HTML-Kommentare. Im folgenden Beispiel sehen Sie einen Block namens Feld, der HTML-Code und den Platzhalter daten enthält.

<!-- BEGIN Feld --> 
   <td> 
      {daten} 
   </td> 
<!-- END Feld -->

Der Block wird also mit  eingeleitet und mit  beendet. Der Bezeichner, sprich der Name des Blocks, muss in beiden Fällen identisch sein, und die Schreibweise von BEGIN und END ist fest vorgeschrieben. Blöcke können durchaus ineinander verschachtelt werden. Hierbei gilt dasselbe Prinzip wie bei HTML-Tags, nämlich dass diese Blöcke sich nicht überlappen dürfen.

Die Namen der Platzhalter sind jeweils in geschweifte Klammern einzuschließen, damit das System sie erkennen kann.

Ein solches Template könnte beispielsweise so aussehen:

<html> 
   <!-- BEGIN HEAD --> 
      <head> 
         <title>{TITLE}</title> 
      </head> 
   <!-- END HEAD --> 
   <!-- BEGIN BODY --> 
      <body> 
         <!-- BEGIN BILDER --> 
            Bild Nr. {BILD}: <img src="{BILD}.gif"><br /> 
         <!-- END BILDER --> 
         <p>{COPYRIGHT}</p> 
      </body> 
   <!-- END BODY --> 
</html>

Listing 17.7 Beispiel-Template

Wie Sie sehen, besteht es aus drei Blöcken. Bereiche, in denen sich reiner HTML-Code befindet, der nicht verarbeitet werden muss, müssen nicht in Blöcke verpackt werden. Zwar wäre es nicht nötig gewesen, den Kopf und den Körper der Datei in eigene Bereiche aufzugliedern, aber ich persönlich empfinde diese Aufteilung als strukturierter.

Um dieses Template zu verarbeiten, muss es natürlich erst von der Template-Engine geladen werden. Ist das erfolgt, können die einzelnen Blöcke selektiert und verarbeitet werden. Verarbeiten heißt, dass die Platzhalter durch die korrekten Inhalte ersetzt werden und der Block danach geparst wird. Hierbei werden die Blöcke üblicherweise von außen nach innen abgearbeitet, wobei es durchaus möglich ist, einen Block mehrfach anzuspringen und zu verarbeiten.

require_once ('HTML/Template/IT.php'); 
 
// Neues Objekt ableiten 
$tpl = new HTML_Template_IT('./templates'); 
 
// Template laden 
$res=$tpl->loadTemplatefile('page.html.tpl', true, true); 
// Ist dabei ein Fehler aufgetreten? 
if (true === PEAR::isError($res)) 
{ 
   die ($res->getMessage()); 
} 
 
// Block HEAD selektieren 
$res=$tpl->setCurrentBlock('HEAD'); 
if (true === PEAR::isError($res)) 
{ 
   die ($res->getMessage()); 
} 
// Platzhalter TITLE ersetzen 
$tpl->setVariable('TITLE', 'Bild&uuml;bersicht') ; 
// Block parsen 
$erg=$tpl->parseCurrentBlock(); 
 
// Block BODY selektieren 
$res=$tpl->setCurrentBlock('BODY'); 
if (true === PEAR::isError($res)) 
{ 
   die ($res->getMessage()); 
} 
 
// Bilder sollen in einer Schleife eingefuegt werden 
for ($nr=1; $nr <= 3; $nr+=1) 
{ 
   // Block BILDER selektieren 
   $res=$tpl->setCurrentBlock('BILDER'); 
   if (true === PEAR::isError($res)) 
   { 
      die ($res->getMessage()); 
   } 
   // Variable(n) ersetzen 
   $tpl->setVariable('BILD', $nr) ; 
   // Block parsen 
   $tpl->parseCurrentBlock(); 
} 
 
// Variable im Block BODY ersetzen 
$tpl->setVariable('COPYRIGHT', 'Alle Rechte gesichert') ; 
// Block BODY parsen 
$tpl->parseCurrentBlock(); 
 
// fertige Seite ausgeben 
$tpl->show();

Listing 17.8 Script zum Verarbeiten des Templates

Der Konstruktor benötigt zwar keine Parameter, aber Sie können ihm den Pfad zu dem Unterverzeichnis übergeben, in dem sich die Templates befinden. Diesen Pfad an das Objekt zu übergeben vereinfacht die Arbeit ein wenig. Um den Pfad später zu setzen oder nachträglich zu ändern, können Sie die Methode setRoot() nutzen und ihr den Pfad übergeben.

Das Laden des Templates übernimmt loadTemplatefile() für Sie. Natürlich müssen Sie ihr den Namen der Datei, die verwendet werden soll, mit auf den Weg geben. Die beiden booleschen Werte, die Sie in diesem Beispiel noch finden, sind optional. Sie legen fest, ob unbekannte Variablen bzw. leere Blöcke entfernt werden sollen. Übergeben Sie ein true, was auch der Vorgabewert ist, werden sie entfernt. Bei einem false bleiben sie erhalten, was insbesondere für die Fehlersuche sehr hilfreich sein kann.

Um die einzelnen Blöcke abzuarbeiten, müssen diese erst mit setCurrentBlock() selektiert werden. Das Selektieren eines solchen Blocks hat den großen Vorteil, dass diese Blöcke in einer Schleife mehrfach abgearbeitet werden können. Sie sollten allerdings nicht auf die Idee kommen, Platzhalter in unterschiedlichen Blöcken gleich zu benennen. Auch wenn sie in unterschiedlichen Blöcken liegen, kann es durchaus zu Nebeneffekten kommen, da Template-Variablen als global anzusehen sind.

Die einzelnen Platzhalter werden dann jeweils durch einen Aufruf von setVariable() durch den entsprechenden Inhalt substituiert. Genauer gesagt, ersetzt sie die Platzhalter noch nicht sofort. Sie merkt nur vor, welche Platzhalter durch was zu ersetzen sind. Nachdem in dem gewünschten Block die Variablen ersetzt wurden, müssen Sie die Methode parseCurrentBlock() aufrufen, die dann wirklich die Ersetzungen vornimmt und die generierten Daten abspeichert. Nachdem die einzelnen Schritte durchlaufen wurden, können Sie das Template mit der Methode show() direkt an den Browser senden, wo dann dieser Code ankommt:

<html> 
      <head> 
         <title>Bild&uuml;bersicht</title> 
      </head> 
      <body> 
            Bild Nr. 1: <img src="1.gif"><br /> 
            Bild Nr. 2: <img src="2.gif"><br /> 
            Bild Nr. 3: <img src="3.gif"><br /> 
         <p>Alle Rechte gesichert</p> 
      </body> 
</html>

In vielen Fällen ist es nicht notwendig, das Template bei jedem Aufruf der Seite auszuwerten. Da kann es hilfreich sein, die Daten in einer Datei zu speichern und nur dann, wenn es wirklich notwendig ist, das Template neu zu rendern. Um die Daten aber in einer Datei ablegen zu können, müssen Sie in der Lage sein, sie in einer Variable abzulegen, ohne sie direkt an den Browser zu senden. Dafür ist die Methode get() vorgesehen, die Ihnen die gerenderten Daten zurückliefert, so dass Sie diese in einer Datei oder einer Datenbank ablegen können.

Die meisten Methoden dieser Klasse liefern im Fall eines Fehlers einen PEAR_Error zurück, wie Sie schon dem Listing entnehmen konnten. Primär handelt es sich hierbei um Methoden, bei denen vermutet werden kann, dass ein Fehlschlag dieser Methode ein ernst zu nehmendes Problem darstellt. So kann setCurrentBlock() ein Fehler-Objekt zurückliefern, wenn es den Block z. B. nicht geben sollte.

Möchten Sie eine Template-Engine verwenden, die die generierten Daten cachen kann, sollten Sie vielleicht einen Blick auf HTML_Template_Sigma werfen. Sigma ist kompatibel mit IT, legt die gerenderten Daten aber in einem Cache ab. Allerdings können Sie bei Sigma nicht definieren, wie lange die berechneten Seiten gültig sein sollen. Sie werden erst dann neu generiert, wenn das Template sich ändert.

Bei der Arbeit mit Templates ist es häufig sinnvoll, Teile des Templates in andere Dateien auszulagern, so dass sie mehrfach genutzt werden können. Insbesondere Elemente wie die Navigation oder der Kopf einer Seite, die eventuell auf allen Seiten identisch sind, bieten sich dafür an.

Hierzu können Sie zwei Vorgehensweisen nutzen. Zum einen können Sie die einzubindende Datei mit der Seite einbinden, die das Templete auswertet. Dazu können Sie natürlich Funktionen nutzen, die PHP Ihnen zur Verfügung stellt, oder die Methode getFile(), die im Paket definiert ist. Sie liest die gesamte Datei ein und liefert sie zurück, so dass sie in einer Variablen abgelegt werden kann. Um diese Datei dann an einer Stelle in das Template zu integrieren, sollten Sie einen Platzhalter vorsehen, dem Sie den Inhalt zuweisen können.

Die andere – und, wie ich finde, elegantere – Variante ist es, die gewünschte Datei direkt über das Template einzubinden. Hierzu ist in der Template-Syntax der Befehl

<!-- INCLUDE dateiname.tpl -->

vorgesehen, der eine externe Datei, in diesem Beispiel dateiname.tpl, lädt und an der Stelle, an der sich der Befehl befindet, einbindet.

Das Paket kennt noch einige Methoden, mit denen Sie beispielsweise die vorhandenen Blöcke und Variablen auflisten können. Diese können hilfreich sein, wenn Sie mit variablen Templates (die z. B. selbst von PHP generiert werden) arbeiten. Da das aber nicht ganz so oft vorkommt, werde ich darauf nicht eingehen.