Einführung in PHP-Templatesysteme mit der Engine SMARTY

[steffenk]

Hier kommt ein Tutorial von Nico - viel Spass !

[Nico]

So, na dann lege ich mal los...

Diese Vorlesung wurde letztes Semester an der HTW Dresden gehalten und
ich denke, dass es hier auch der/dem einen oder andern etwas nützen könnte.

Der erste Teil bezieht sich auf die reine Anwendung von Templates in PHP.
Warum brauchen wir das und wie nutzen wir das, ect. ?
Im zweiten Teil, werden wir eine eigene Template-Klasse bauen,
da das "Suchen und Ersetzten" beim Scripten mit PHP oft eine herausragende Rolle spielt.

Gut, dann hier erstmal der Inhalt:

• Trennung Programmierung und Design
• 1.Template-Systeme
• 1.1.SMARTY
• 1.1.1. Was ist das?
• 1.1.2. Geschichte
• 1.1.3. Funktionsweise
• 1.1.4. Funktionen in SMARTY
• 1.1.4.1. Funktionen für Entwickler
• 1.1.4.2. Funktionen für Designer
• 1.1.5. Praktische Anwendung
• 2. Die eigene Template-Klasse
• 2.1. Theorie
• 2.2. Usecase- und Klassendiagramm
• 2.3. Funktion der Memberfunktionen
• 2.3.1. assign()
• 2.3.2. display()
• 2.3.3. setTemplateDir() und endlich der Konstruktor
• 2.3.4. parseFile($string)
• 2.3.4.1. Die PHP-Funktion preg_replace_callback()
• 2.3.5. replaceVar()
• 2.3.6. weitere Funktionen

viel Spaß

Hier schon mal ein Vorab-Link, da könnt Ihr Euch das Tutorial und die Praktikas
downloaden: Nico Lange -> Publikationen

[Nico]

Trennung Programmierung und Design

Bei der Arbeit mit PHP ist einigen mit Sicherheit aufgefallen, dass die
HTML-Tags mit dem PHP-Code gemischt werden, da PHP eine in HTML
eingebettete Scriptingsprache ist.
Dies ist nicht nur wenig förderlich für die Übersicht, sondern auch für eine
Arbeitsteilung völlig ungeeignet.

Welche Probleme treten auf?

• Bei einer Änderung des Layouts muss ein (teurer) Programmierer
  beschäftigt werden.
• Die Übersicht geht sehr schnell verloren.
• Standards können nur sehr schwer umgesetzt werden (Die Programmierer
  sind oft mit andern Dingen beschäftigt).

... und alles klar was hier passiert?

Da PHP-Projekte in den letzten Jahren immer größer wurden, haben sich
diese Probleme gehäuft, es wurden Lösungen gesucht…

…und gefunden.

1. Template-Systeme

Die Idee, dass man HTML-Tags in kleine Teile unterteilt und diesen immer
wieder in eine Datei lädt, war schon länger bekannt.
So hat(te) sich für eine ganze Zeit das „dreizeilige Design“ im Web
durchgesetzt. Dabei wurde der obere Teil einer Webseite (header) und der
untere Teil (footer) vom Inhaltsteil getrennt und konnte durch ein einfaches
include(); in die Dateien eingebunden werden.
Der Header und der Footer bleiben somit in der gesamten Seite immer gleich
und nur im Content-Bereich müssen noch Veränderungen vorgenommen
werden.

Damit kann man zwar die Anpassungsarbeiten bei einem Layoutwechsel ein
wenig minimieren, aber das Problem, dass die Programmierer bei geringen
Designänderungen Quellcodeanpassungen vornehmen müssen, ist noch nicht
gelöst.

Eine bessere Lösung musste her. Jetzt können wir ruhig einen Blick auf die
Zeitungsbranche werfen. Dort ist es Gang und Gebe, in einem vorgegebenen
Layout – der Vorlage - Texte zu setzten und Platzhalter für evtl. noch nicht
vorhandene Bilder einzufügen.

Warum sollte das bei Webseiten nicht funktionieren?


Was brauchen wir? Als Erstes eine Vorlage (Template). In dieser entwerfen
wir das Layout unserer Webseite. Ganz normal mit HTML-Tags, so wie wir es
gewöhnt sind und wie es vom Kunden gewünscht wird. An die Stelle der
dynamischen Texte und Bilder setzten wir allerdings Platzhalter wie beim
Zeitungsentwurf.

Da jetzt aber eine Vielzahl von Leuten die Templates nutzen möchten, sollten
wir uns auf einen Standard für die Platzhalter einigen. Folgende Notation
wäre denkbar:

{$Platzhalter}

Diesen Vorschlag mache ich nicht ohne Grund, wir werden im nächsten
Kapitel sehen, warum diese Auszeichnung so praktikabel ist.

Wenn wir diese Platzhalter nachfolgend ersetzen lassen würden, könnten wir
einzelne Texte sowie Bilder wiedergeben. Aber was ist mit einer
veränderlichen Menge von Beiträgen? Wie zum Beispiel der Auflistung von
mehreren Newsartikeln?

Wir brauchen also noch einfache Kontrollstrukturen. Nehmen wir foreach um
ein Array komplett zu durchlaufen:

{foreach $key var}

Außerdem noch schnell eine If-Abfrage, um Bedingungen abzufangen:

{if $var == true} 
... 
{else}  
...
{/if}

Schon steht uns alles zur Verfügung, was wir für eine sinnvolle Verarbeitung
und Ausgabe von Daten brauchen.

Nun haben wir die HTML-Datei, ohne Inhalte (wir haben ja die Platzhalter
hinein gesetzt). Dafür ist diese aber zumindest fast von der Programmierung
und den Daten getrennt.

Jetzt versuchen wir, die Platzhalter durch Daten zu ersetzten, oder besser,
erst einmal Daten für die Platzhalter zu erzeugen.

Dafür gibt es ein einfaches und sehr sinnvolles Konzept. Das PHP-Script wird
wie gewohnt geschrieben. Allerdings werden die Daten nicht ausgegeben
(echo), sondern in eine Liste geschrieben.

Wir haben nun eine PHP-Datei, in der alle gebrauchten Daten am Ende der
Ausführung in Variablen (der Liste) gespeichert sind. Die HTML-Datei mit den
Platzhaltern haben wir auch.
Wenn wir schon so weit sind, ist es sicherlich nicht mehr schwer, diese
beiden Dateien zusammenzufügen.

Es wird am Ende des Scripts einfach definiert, welche Template-Datei
aufgerufen wird. Dort werden dann alle Platzhalter ersetzt und die fertige
Datei zum Client geschickt.

Die Art und Weise, wie dieses Zusammenführen und die notwendige
Substitution erfolgt, wird im nachfolgenden Kapitel erläutert.

[Nico]

1.1. SMARTY

1.1.1. Was ist das?

Im Kapitel 1. wurde ausführlich erklärt, wie ein Templatesystem aus der
Benutzersicht (die Benutzer sind in diesem Fall wir, die Programmierer)
funktioniert.

Das eigentliche Ersetzen der Daten sollte dann anderen überlassen werden.

SMARTY stellt (als eines von vielen Systemen) Funktionen zur Verfügung, um
genau dieses Parsen - also das Suchen und Ersetzten der Platzhalter - zu
erledigen.

Im Weiteren stellt SMARTY eine Vielzahl von anderen Funktionen zur
Verfügung, welche nach und nach angeeignet und genutzt werden können.


Als besonderes Feature sollte hier noch kurz die Cachingfunktion erwähnt
werden, da dies in der SMARTY-Engine für eine enorm schnelle Abarbeitung
der Scripte sorgt.

1.1.2. Geschichte

Die Entwickler des Template-Systems begannen 1999 mit der Spezifikation
der Engine, welche dann in der Sprache „C“ programmiert wurde. Nachdem
technische Schwierigkeiten eine Implementierung von SMARTY in die Sprache
PHP verhinderten, entschlossen sich die Programmierer eine Klasse für PHP zu
schreiben und die Funktionalität auf diesem Weg zur Verfügung zu stellen.

Es entstand SmartTemplate™ (wurde nie veröffentlicht). Schon in dieser
Klasse waren alle bisher genannten Funktionen möglich.

Das gesamte Parsing wurde mit regulären Ausdrücken erledigt. Leider war der
Overhead sehr groß, da das Parsing zu jedem Aufruf einer Seite durchlaufen
werden musste.

Zur endgültigen Veröffentlichung wurde die Vorkompilierung der Dateien
eingeführt (Caching). Dabei werden die Template-Dateien vom SMARTY
gelesen und daraus neue Scripte - mit bereits ersetzten Platzhaltern -
generiert. Somit können immer wieder diese - neu genierierten - Dateien
aufgerufen werden. Das rechenaufwendige Parsen der Scripte entfällt.

Dabei versucht SMARTY immer, wenn keine gecachte Datei vorhanden ist,
diese zu erzeugen.

1.1.3. Funktionsweise
Hier möchte ich noch einmal genauer auf die Funktionsweise von Template-
Systemen eingehen. Betrachten wir dazu das Bild „Funktionsweise SMARTY-
Template“.



Funktionsweise SMARTY-Template

Wie wir sehen, wird vom Client die Datei „index.php“ aufgerufen. Das
wird wie gewohnt ausgeführt. Hier wurde es natürlich sehr gekürzt.

Man sieht, dass der String „Hello World“ nicht direkt mit echo()
zurückgegeben wird, sondern in einer Liste gespeichert wird.
Dann wird die *.tpl-Datei aufgerufen. Diese wird geparst und der Platzhalter
mit unserem Wert der Variable ersetzt.

Der fertige HTML-Code wird danach von der PHP-Datei an den User
zurückgegeben und angezeigt.

Ein weiterer Vorteil dieser Methode ist, dass der Nutzer nichts von dem
System, welches im Hintergrund läuft, bemerkt. Er soll ja nicht mitbekommen,
mit welcher Technik wir im Hintergrund arbeiten.

1.1.4. Funktionen in SMARTY

Die SMARTY-Engine bietet eine Menge Funktionen an, welche zum Entwickeln
von Anwendungen genutzt werden können.
Diese werden in Funktionen für Entwickler (Methoden der Klasse) und
Funktionen für Designer unterteilt.

Als Designer muss man beachten, dass auch Kontrollstrukturen als Funktionen
behandelt werden, im Weiteren werden die Funktionen meist zur
Datenmanipulation genutzt.

Neben den „globalen“ eingebauten Funktionen gibt es auch noch eine Menge
„Eigene Funktionen“, die komplexe Abläufe - wie zum Beispiel einen Counter -
zur Verfügung stellen (intern werden die eigenen Funktionen genau wie
Plugins behandelt).

Funktionen für die Entwickler sind die Memberfunktionen der Klasse. Sie
ermöglichen es uns, Nachrichten an das Objekt zu schicken.

1.1.4.1. Funktionen für Entwickler

Für Entwickler stehen in der Smarty-Klasse ca. 40 Methoden zur Verfügung.
Fast jede von diesen Funktionen hat mit dem internen Handling der Dateien
zu tun. So kann man zum Beispiel den gesamten Cache löschen
(clear_all_cache()) oder neue Funktionen zur Laufzeit laden (register_function()).

Im Folgenden möchte in nur kurz die wichtigsten und eigentlich immer
genutzten Methoden erläutern.
Für weitere Informationen verweise ich auf die Dokumentation von SMARTY
(http://smarty.php.net/manual/de ).

assign(string varName, mixed var)

Diese Funktion wird genutzt, um Variablenwerte in die Liste einzutragen,
welche dann dem Template übergeben werden.

$smarty->assign('myWorld', "Hallo World.");          
$smarty->assign('this_site', $_SERVER['PHP_SELF']);

display(string template[, string cache_id[ ,string compile_id]])

Gibt das Template aus. Hier muss eine vorhandene Template-Datei als
Parameter angegeben werden.

Die optionalen Parameter können die Cache-Id sowie Kompilierung-ID
übergeben werden. Dies wird in unseren ersten Anwendungen nicht
gebraucht. Für weitere Informationen bitte ich, in der Dokumentation
nachzulesen.

$smarty->display("index.tpl");

clear_cache(string template[, string cache_id[ ,string compile_id]])

löscht den Cache des angegebenen Templates. Dies wird genutzt, wenn bei
jedem Aufruf der Datei andere Ausgaben erwartet werden.

$smarty->clear_cache("index.tpl");

debugging = true;

Eine sehr nützliche Funktion – vor allem während der Entwicklungszeit – ist
das Debugging. Dabei wir bei jedem Aufruf der Seite ein Debug-Fenster mit
einer Vielzahl wichtiger Daten und Variablen ausgegeben.

Eigentlich ist dies keine Funktion, sondern nur eine Variable die gesetzt
werden muss:

$smarty->debuging = true;

1.1.4.2. Funktionen für Designer

Die meisten eingebauten Funktionen sind wie Kontrollstrukturen zu nutzen.
Wir haben folgende Abfragen zur Verfügung (Auszug):

- if-Abfrage

{if Wert} … {else} … {/if}

- foreach-Schleife

{foreach from="varName" item=name}
{name.wert}
{/foreach}

- include-Anweisung

{include file="template.tpl"}

Da diese Funktionen wie aus PHP bekannt genutzt werden, möchte ich hier
nicht genauer darauf eingehen. Die Syntax sollte reichen, um deren
Anwendung zu verstehen.

Auch auf die Erläuterung der eigenen Funktionen möchte ich hier verzichten.
Wenn man das Prinzip von SMARTY verstanden hat, ist es ein leichtes, sich
dieses Wissen anzueignen. Für den Anfang wird das allerdings nicht
gebraucht.
Es reicht, wenn uns klar ist, dass es noch weitere Funktionen gibt, welche
durch „Plugins“ beliebig erweitert werden können.

1.1.5. Praktische Anwendung

Jetzt werden sich bestimmt einige fragen, was es für Anwendungsbeispiele
für ein solches Templatesystem gibt.

Dazu möchte ich auf die Webseite der Medieninformatiker verweisen, welche
in den nächsten Wochen neu veröffentlicht wird.

Im Allgemeinen, und aus Erfahrung heraus, würde ich sagen, dass es sich
lohnt ein Template-System einzusetzen, wenn die Anzahl der zu erstellenden
Seiten größer 10 ist.
Natürlich sollte es auch ein Projekt sein, welches von vor herein auf PHP
zurück greift, sonst wäre diese Verkomplizierung nicht gerechtfertigt.

[Nico]

So... wer die Template-Klasse nur anwenden möchte, der kann hier ruhig
aufhören zu lesen.
Das folgende Kapitel behandelt nur noch, wie wir selber
eine solche Klasse erstellen können.

[Boris]

Hast Du das mit Word oder so geschrieben? Das hier z.B. würde nämlich bei einem Copy'n'Paste böse schief gehen (einfache und doppelte Anführungszeichen!):

$smarty->assign(‚myWorld‘, „Hallo World.“);

[Nico]

2. Die eigene Template-Klasse

2.1. Theorie

Dieses Kapitel beschäftigt sich mit der Entwicklung einer eigenen Template-
Klasse.
Hier werden noch mal einige Konzepte, die dieses Semester in der Vorlesung
besprochen wurden, angewendet. So brauchen wir zum Beispiel Funktionen,
Klassen und Regular Expressions.

Fangen wir an, das, was wir in den letzten Kapiteln gelernt haben, zu nutzen,
und daraus eine eigene Klasse zu schreiben.

Was brauchen wir, um die Klasse nutzen zu können? Als Erstes sicherlich eine
Funktion, um die Variablen in eine Liste oder ein Array zu schreiben.

assign(varname, value);

Als Nächstes brauchen wir natürlich auch eine Funktion, damit die Datei
gelesen und angezeigt werden kann:

display(template);

Soweit die Memberfunktionen, die wir schon beim Nutzen der Klasse
gebraucht haben. Jetzt kommen allerdings noch ein paar weitere dazu, die
wir für das Parsen des Templatefiles brauchen.

parseFile($string);		// liest das File und gibt es zurück

replaceVar($ref);		// ersetzt Variablen im String

replaceArray($ref);		// ersetzt Arrays im String

replaceForeach($ref);		// ersetzt foreach-Schleifen im String

… diese Liste könnte jetzt endlos fortgeführt werden, um alle
Sprachkonstrukte zu ersetzten. Weitere Möglichkeiten wären die
IF-Bedingung, While-Schleifen, Objekt-Ersetzungen u.s.w.

Damit unser Beispiel übersichtlich bleibt, sollten wir es allerdings bei den drei
Ersetzungen lassen.

2.2. Klassendiagramm

Hier nochmals eine grafische Darstellung der Template-Klasse. Vielleicht
kommen einige mit dieser Darstellung besser klar.




2.3. Funktion der Memberfunktionen

Jetzt geht es los. Die Syntax, wie die Klassen erstellt werden, erinnert sehr
an Java und dürfte kein Problem darstellen:

class Template {

             private $var;
             
             public function assign($var, $value){
                  ...
             }
             ...
         } 

Da wir jetzt die Struktur das Klasse haben, können wir anfangen die Funktion
zu implementieren.


2.3.1. assign()

Als Erstes, würde ich vorschlagen, bauen wir die „assign“-Funktion, um die
Variablen zu registrieren.
Diese lässt sich sehr einfach debuggen und wir brauchen keine zusätzliche
Funktionalität der Klasse für die ersten Tests.

Um die Variablen zu speichern, legen wir noch eine Membervariable an,
welche als Array die Werte und Namen abspeichert.

private $varList = NULL; 

Jetzt können wir die Variablen auch schon in das Array schreiben. Das
einfache Handling der Arrays unter PHP nimmt uns eine Menge Arbeit ab.

public function assign($name, $value){
             $this->varList[$name] = $value;
         } 

Natürlich könnte man jetzt noch Fehler abfangen und schauen, ob der
Variablenname schon einmal registriert wurde, aber für unser Beispiel soll das
genügen.
Mit dem Array $varList können wir jetzt auf alle Werte zugreifen.

Die Funktion können wir testen. Legen wir ein Objekt der Klasse an und lassen
und das gesamte Array zurückgeben.
Achtung, die Sichtbarkeit muss für dieses Beispiel auf „public“ gesetzt
werden, da man sonst nicht auf die Variable zugreifen kann.

Beispiel:

class Template {
         public $varList    = NULL;
     
         public function assign($name, $value){
             $this->varList[$name] = $value;
         }
}

$tmpl = new Template();

$tmpl->assign(eins,"Hallo");
$tmpl->assign(zwei,"Welt");

echo "<pre>";
print_r($tmpl->varList);
echo "</pre>"; 

2.3.2. display()

Diese Funktion wird genutzt, um das Template-File zu öffnen und den String
zum Parsen weiterzuleiten.
Wir müssen testen, ob die Datei überhaupt existiert und ob sie gelesen
werden kann.

Wenn dies der Fall ist, können wir die Datei parsen und via echo an den Client
schicken.

public function display($tpl){
         if ((!file_exists($this->template_dir . "/" .  $tpl)) OR 
             !is_readable($this->template_dir . "/" . $tpl)) {
                 die("Can not read the File");
         }
         $string = file_get_contents($this->template_dir . "/" . 
                                     $tpl);
         echo $this->parseFile($string);
     } 

2.3.3. setTemplateDir() und endlich der Konstruktor

Wer die Funktion display() aufmerksam studiert hat, wird festgestellt haben,
dass die Variable „this->template_dir“ bisher verwendet, aber noch nicht
angelegt wurde.

Das holen wir schnell noch nach und damit wir die Variable „private“
schreiben können, bauen wir gleich noch eine Funktion, um das Verzeichnis
zu setzen.

public function setTemplateDir($dir = NULL){
         // hier wird eine default-Wert an die Funktion übergeben, 
             wenn kein Argument angegeben wird

         if (is_null($dir)) {
             $this->template_dir = dirname(__FILE__);
         }
         else{
               $this->template_dir = $dir;
         }
     } 

Sehr clever ist es hier, diese Funktion gleich im Kostruktor einzubinden, da
sie in jedem Fall aufgerufen werden muss.

public function Template($dir = NULL){
         $this->setTemplateDir($dir);
     } 

Leider wird ein Überladen von Funktionen in PHP nicht unterstützt. Mit dem
Trick, einer Funktion einen Default-Wert zu übergeben, lässt sich allerdings
so manches Problem lösen Template($dir = NULL).

2.3.4. parseFile($string)

In der Funktion „display()“ wurde bereit
„parseFile($string)“ aufgerufen.

Hier wird nichts anderes gemacht, als den Dateistring aus der Template-Datei
zu untersuchen und die Platzhalter zu ersetzten.

Klingt schwierig? Ist es auch.

Aber auch das werden wir verstehen und schon bald werden wir dieses
Konzept zu schätzen wissen.

Als Erstes müssen wir uns wieder an Regular Expressions erinnern.
Da wir einen String nach bestimmten, formatierten Tokens untersuchen
wollen, ist es am einfachsten, diese mit RegEx_Mustern zu „parsen“.

Wie wollten wir den Platzhalter einer Variablen definieren?

{$var}

Es steht immer ein „{$“ am Anfang und ein „}“ am Ende.
Dazwischen stehen Buchstaben beliebiger Reihenfolge und Länge.

Ich habe mal ein Pattern vorbereitet, der uns wahrscheinlich schon
weiter hilft: (danke Stuck Mojo und St@eff.en)

$pattern = '%\{\$(\w+)\}%';

Ich denke, das Suchmuster müsste allen klar sein? Warum die Klammer ()
gebraucht wird, erkläre ich weiter unten.

So, jetzt kommen wir zu dem eigentlichem Ersetzten des Platzhalters. Dazu
nutzen wir die Funktion preg_replace_callback.

$string = preg_replace_callback($pattern, array(&$this, 'replaceVar'), $string); 

Was diese genau tun, werde ich im nächsten Abschnitt versuchen zu
erläutern. Auf jeden Fall ersetzt diese unseren Platzhalter im String mit dem
Wert aus der Variablenliste. Sie sucht uns sozusagen zur Laufzeit den
gesuchten Ersetzungswert.

2.3.4.1.Die PHP-Funktion preg_replace_callback()

In der Hilfe auf www.php.net ist die folgende Beschreibung der Funktion zu
finden:

“Sucht und ersetzt einen regulären Ausdruck unter Verwendung eines Callbacks.

mixed preg_replace_callback ( mixed Suchmuster, callback Callback, 
                mixed Zeichenkette [, int Limit] ); 

Abgesehen von der Tatsache, dass statt des Parameters Ersatz ein Callback
angeben werden soll, dem ein Array von Übereinstimmungen mit der
durchsuchten Zeichenkette übergeben wird, ist das Verhalten dieser
Funktion identisch zu preg_replace(). Der Callback sollte die Ersetzungs-
Zeichenkette liefern.“ (http://www.php.net/manual/de/functio...e-callback.php)

Da es nicht auf Anhieb klar ist, was das bedeutet, versuche ich es noch
einmal, etwas anders zu erklären.

Der Funktion wird ein Suchmuster übergeben sowie die Zeichenkette, in der
gesucht werden soll.

Soweit sollte das alles von preg_replace() bekannt sein. Aber der zweite
Parameter ist etwas, dass hier bestimmt neu erscheint.

Mit ihm kann eine Funktion angegeben werden, die aufgerufen wird um den
„replace“-Wert zurückzugeben. Die Funktion bekommt dabei (automatisch)
den mit dem Suchmuster gefundenen Ausdruck als Argument übergeben.

Dieses Argument – welches der Funktion übergeben wird – setzt sich dabei
wie folgt zusammen:

Die Übergabe ist immer ein Array, in welchem der gesamte Ausdruck im ersten
Element ($arr[0]) gespeichert wird.
In den weiteren Elementen ($arr[1] .. $arr[n]) werden jeweils die Inhalte
in den gefundenen Klammern () zurückgegeben.

Jetzt sollte auch klar sein, warum in dem Suchmuster '%\{\$(\w+)\}%'
der Teil in dem der Variablenname gefunden wird, noch einmal in Klammern
steht.



Jetzt habe ich sicher einige total verwirrt. Aber betrachten wir das einmal an
einem Beispiel.
Wir haben einen String mit der Variable {$varname}. Dieser wird natürlich
durch unser Pattern gefunden. Wie schaut dann dass Array – welches ja der
Funktion als Argument übergeben wird – aus?

Bsp. 1

'%\{\$(\w+)\}%'

 $arr[0]	= 	{$varname}
 $arr[1]	= 	varname

Bsp. 2

'%{foreach from=\$(\w+) item=(\w+)}(.*){/foreach}%sU';

 $arr[0]= {foreach from=$varame item=name}<html-
 							Tags>{/foreach}
 $arr[1]	= 	varname
 $arr[2]	= 	}<html-Tags>

Nun wird mit Sicherheit deutlich, dass das wir in der Callback-Funktion den
Wert $arr[1] nutzen können um in der Variablenliste unseren gesuchten Wert
zu finden.
Dieser wird dann im String durch preg_replace_callback ersetzt.

Das sollten wir jetzt erstmal setzten lassen, aber wenn wir das verstanden
haben, ist der Rest der Klasse (fast) kein Problem mehr.

2.3.5. replaceVar()

Da wir jetzt wissen, dass eine Funktion die Werte zum Ersetzen der
Platzhalter im String zurückgibt, müssen wir diese jetzt auch implementieren.


[PHP]private function replaceVar($ref){
return $this->varList[$ref[1]];
}
[/PHP

Hier wird noch mal deutlich, dass die Funktion nur den Wert des Keys,
welcher als Argument übergeben wurde, zurückgeben wird.

2.3.6. weitere Funktionen

Weiter oben haben wir eine Reihe weiterer Funktionen benannt, welche in
einer Template-Klasse implementiert sein sollten.

Diese alle hier zu besprechen, wäre ein zu großer Aufwand. Da das Prinzip bei
allen weiteren Ersetzungen immer gleich ist, sollte es aber möglich sein, die
Klasse nach und nach zu erweitern.

An der Hochschule haben wir uns im Praktikum weiter mit dieser Klasse beschäftigt.


Gut, das war es eigentlich vom mir. Ich hoffe ich habe bis hier noch nicht alle
Leute verlohren und es hat ein wenig Spaß gemacht



Die Praktikas zu SMARTY sowie das PDF zur Vorlesung könnt Ihr Euch hier downloaden:
Nico Lange -> Publikationen

[Nico]

Hast Du das mit Word oder so geschrieben? Das hier z.B. würde nämlich bei einem Copy'n'Paste böse schief gehen (einfache und doppelte Anführungszeichen!):

$smarty->assign(‚myWorld‘, „Hallo World.“);

sch... nicht mit Word, aber ich hatte alles in InDesign formatiert

Naja, muss ich es halt nochmal nacharbeiten

Danke


Update: So, ich habe alle geändert. Hoffe ich habe alles erwischt.

[Nico]

Zu Guter Letzt sollte man die Quellen nicht vergessen:

• Ohrt, M.;Zmievski,A. (2004): Smarty . die kompilierende PHP Template-Engine : Dokumentation
• Jedrzejewski, T. (2004): Vergleich von Templatesystemen. : PHP-Solutions

... so, jetzt war es das aber nun endgültig.

[steffenk]

Herzlichen Dank an Nico für dieses ausführliche und sehr interessante Tutorial.
Anhand dieses Tutorials sollten so einige Hemmungen bei Einsatz von Smarty überwunden werden.

So langsam wird die Tutorial-Ecke des TP's eine wahre Fundgrube und eine gute Nachschlagquelle

[cinteX]

sehr Schönes Tutorial Nico.
Ich habe nur ein einziges Problem.

Ich habe mir mal deinen zweiten abschnitt zu herzen genommen und habe versucht meine eigene templateengine zu schreiben.

Fehler bekomm ich keine, allerdings wenn ich meine template-file anzeigen lassen möchte, sehe ich nur eine leere seite.

der code is genau der gleiche wie hier beschrieben.

[Nico]

Hi,

also Du hast in der Funktion "parseFile()" das return vergessen, somit kann auch nichts ausgegeben werden.

    
...      $string = file_get_contents($this->template_dir . "/" . $tpl);
        echo $this->parseFile($string);
    }
    
    ...
    
    private function parseFile($string) {
        $pattern = '%\{\$(\w+)\}%'; 
        echo $string = preg_replace_callback($pattern, array(&$this, 'replaceVar'), $string);
        return $string;
} 

viele grüße Nico

[cinteX]

ups ^^
herzlichen dank

**EDIT**
hätte da noch eine frage

private function parseFile($string) {
        $pattern = '%\{\$(\w+)\}%'; 
        echo $string = preg_replace_callback($pattern, array(&$this, 'replaceVar'), $string);
        return $string;
} 

hiermit kann ich ja atm nur variablen parsen.
wie schaut es da mit anderen befehlen, like foreach oder ähnlichem, aus?
im grunde müsste ich doch das $pattern ändern oder?

ich weis allerdings nicht ganz wie.

[cinteX]

Hi,
Ich hatte zwar eine Frage wie ich andere funktionen parsen kann, aber hat sich erledigt
habs hinbekommen.

Allerdings ein kleines problem bleibt dennoch.
Ich hab eine include funktion hinzugefügt.
{include file=$var}

funktioniert auch wunderbar.
ich "includiere" die var.php beispielsweise und lasse diese dann erneut parsen. mein problem, der inhalt dieser var.tpl wird mir nicht an der stelle angezeigt an der der include befehl steht.

aber das so bewerkstelligt.

...
if(preg_match('%\{include file=\$(\w+)\}%', $string)) {
            $pattern = '%\{include file=\$(\w+)\}%';
            $string = preg_replace_callback($pattern, array(&$this, 'replaceInclude'), $string);
        } 

hier unter der funktion parseFile() die abfrage ob der syntax der zu parsenden file dem "include-profil" übereinstimmt.

private function replaceInclude($ref) {
        include($ref[1].".php");
    } 

das die eig. funktion.

vielleicht seht ihr einen fehler :/

**EDIT**
hier das problem
der text oben links sollte bei dem roten pfeil stehen.
http://wwwknut2k.no-ip.org/~cintex/extend/hp.png

**EDIT #2**
habe das Problem gelöst.
habe erste einmal die zu includierende erneut geparst und dann via return anzeigen lassen.

Nun aber Problem nr: 3, aber damit komm ich garnichtklar :/
Ich habe mit einen Parser für eine Switch funktion gebaut.

In parseFile();

$pattern = '%{Switch}(.*){/Switch}%'; 
        echo $string = preg_replace_callback($pattern, array(&$this, 'replaceSwitch'), $string);
        return $string; 

nun folgendes problem, wenn der syntax der switch funktion folgende is:
{Switch}{case local=news}News{/case}{/Switch}

dann wäre ja in der Funktion

private function replaceSwitch($ref) {
    return $ref[1];
} 

würde mir ja: {case lo...}...{/case} ausgeben.
nun möchte ich aber den case syntax erneut parsen und in durch einen include replacen.
wir mach ich das?

ich hatte einige ansätze, jedoch bekomm ich es nicht hin.

[Nico]

Hi,

ich kann ja mal kurz warten, dann hast Du die Lösung wieder selber gefunden

Leider kann ich Dir bei diesem Problem auch nicht weiter helfen, aber vielleicht stellst Du die Frage nochmal im "richtigen" Forum, da hier nicht so oft nach neuen Posts gesucht wird...

grüße