Heyho,
Da es hier im Forum noch kein Tutorial zur Smarty Template Engine gibt und ich gerade etwas Langeweile habe, dachte ich mir ich hole das mal nach.
Was ist Smarty, kann man es essen?
Als erstes, Nein, man kann es nicht essen.
Smarty ist eine Template Engine für PHP. Nun wird sicher die nächste Frage kommen, was eine Template Engine ist.
Es ist nichts anderes, Design und Code zu trennen, sprich eine Trennung zwischen Front -und Backend.
Durch diese Trennung kann man dann schließlich eine sauberes, übersichtliches Webprojekt entwickeln.
Installation
Die Engine bekommt ihr von der Offiziellen Webite, http://www.smarty.net/download
In dem Archiv wird nun der "libs" ordnet benötigt.
In dem Tutorial werde ich die Ordnerstruktur für mein Webprojekt wie folgt anlegen:Inhalt anzeigen
Die Anführungsstriche sind Unterordner.
Inhalt anzeigen
In den Template Ordner, der sich im lib Ordner befindet, kommt nun der Inhalt von dem "libs" ordner aus dem smarty archiv.
Für die ganzen Einstellungen basteln wir uns nun noch eine eigene Klasse, die Smarty einfach erbt.Inhalt anzeigen
Als erstes binden wir die Klasse ein, und lassen unsere Klasse von ihr erben.
Inhalt anzeigen
Als nächstes erstellen wir uns einen Konstruktor in der Klasse
Inhalt anzeigen
Allerdings würde dieser nun den Konstruktor in der Smarty Klasse überschreiben, und das macht sie dann nutzlos.
Daher müssen wir dafür sorgen, dass der Smarty Konstruktor zuerst ausgeführt wird. Das machen wir indem wir folgendes in den Konstruktor unserer Klasse schrieben
Inhalt anzeigen
Nun können wir die Einstellungen für die Ordner, welche wir am Anfang erstellt haben setzen, das ist recht selbsterklärend.
$this->setTemplateDir('template/templates');$this->setCompileDir('template/templates_c');$this->setCacheDir('template/cache');$this->setConfigDir('template/configs');
Inhalt anzeigen
Nun ist unsere Klasse bereit, um in die index.php Datei eingebunden zu werden.Inhalt anzeigen
Inhalt anzeigen
Die Erste Seite mit Smarty
Die Vorbereitungen sind nun soweit getroffen, nun können wir anfangen, uns mit der Engine auseinander zu setzen.
Wie bereits erwähnt, ist der Sinn dahinter, die Trennung zwischen Front und Backend.
Fangen wir mal mit dem Frontend Bereich an. Das ist das was wir auf dem Bildschirm sehen, sprich der HTML Code, dieser wird aller Dings in eine Template Datei geschrieben ".tpl".
Also erstellen wir uns erst mal eine "index.tpl" im Ordner "template/templates/".
Das Template sieht nun erst mal so aus:Inhalt anzeigen
<!DOCTYPE html><html><head> <meta charset="UTF-8"> <title>Smarty Tutorial</title></head><body>Hier ist ein Text für das Smarty Tutorial.</body></html>
Inhalt anzeigen
Allerdings ist das eine Statische Seite, sprich sie wird so angezeigt wie es im Code steht.
Um das zu ändern, kommt jetzt der Backend Bereich.
Also begeben wir uns nun in die index.phpInhalt anzeigen
Als erstes erstellen wir das Klassenobjekt über unsere eigene Klasse.
Inhalt anzeigen
Nun werden wir eine eigenschaft von Smarty kennenlernen, welche uns etwas dynamischer arbeiten lässt.
Die Funktion nennt sich "assign". Assign macht nichts anderes, als einer Variable einen Wert zu geben, allerdings können wir die Variablen dann im Template nutzen.
Der Syntax sieht wie folgt aus.
assign(VariablenName, VariablenWert)
Inhalt anzeigen
Inhalt anzeigen
$smarty->assign('Title','Dynamisches Smarty Tutorial');$Text = "Das ist nun ein neuer Text, der im Backend geschrieben wurde ".$_GET['var'];$smarty->assign('Text',$Text);
Inhalt anzeigen
Nun haben wir also unsere Variablen, und sehen auf unserem Bildschirm immer noch nichts, was nun?
Jetzt lassen wir das Template anzeigen, das geschieht mit der Funktion "display".
Inhalt anzeigen
Inhalt anzeigen
Inhalt anzeigen
Da wir die Variablen also "Title" und "Text" benannt haben, schreiben wir unser Template auch so um:
<!DOCTYPE html><html><head> <meta charset="UTF-8"> <title>{$Title}</title></head><body>{$Text}</body></html>
Inhalt anzeigen
Nun wir auch die ändrung deutlich.
Der Effektive Einsatz
Nachdem wir nun die Grundlegende Anwendung von Smarty verstanden haben, können wir es nun effektiv anwenden.
Als erste erstellen wir in unserem template Ordner noch einen "backend" Ordner.
Die Struktur sieht nun so aus:Inhalt anzeigen
Die Anführungsstriche sind Unterordner.
lib- template.class.php- templatetemplates- backend- cache- configs- templates- templates_cindex.php
Inhalt anzeigen
Nun werden wir im "lib" Ordner eine "system.class.php" Klasse erstellen, in ihr werden wir alles wichtige Regeln.Inhalt anzeigen
Inhalt anzeigen
Nun werden wir in unserer index.php erst mal das verzeichnis definieren, um die ganzen Inkludes ohne Probleme einbinden zu können.
Inhalt anzeigen
Als nächstes werden wir erst mal über die Klassendefinition unsere eigene Template Klasse inkludieren.
Inhalt anzeigen
Inhalt anzeigen
Aber als erstes erstellen wir eine Statische Geschützte Variable, für das Template Objekt in der System Klasse.
Inhalt anzeigen
Inhalt anzeigen
public static function TPL() { if(is_object(self::$Template))return self::$Template; // Fragt ab ob die Variable schon ein Objekt besitzt, falls ja gibt es das Objekt zurück self::$Template = new Template(); // Falls Nein, erstellt es das Objekt. return self::$Template; //Nun wird das erstellte Objekt zurückgegeben.}
Inhalt anzeigen
Inhalt anzeigen
Die neue Anwendung könnte nun so aussehen.
Inhalt anzeigen
Inhalt anzeigen
Nun kommen wir zur Seitenverwaltung. Das mache ich bequem über Query Links : index.php?page=Seite
Dafür erstellen wir als erstes in unserem "lib" Ordner eine "page.class.php" Klasse.
Um die Übersicht zu behalten werden wir sie in unsere System Klasse Inkludieren., direkt unter die Template Klasse:
Inhalt anzeigen
Inhalt anzeigen
Inhalt anzeigen
Nun erstellen wir als erstes den Konstruktor mit dem Parameter $page für den Seitennamen.
Inhalt anzeigen
Nun prüfen wir noch ob der Parameter einen Inhalt besitzt, falls nicht setzen wir als Standard Seite "index".
Inhalt anzeigen
Inhalt anzeigen
Inhalt anzeigen
Nun erstellen wir in der Klasse die eben genannte funktion.
Diese Funktion überprüft nun, ob sie seite (mit der endung .php) im Backend Ordner befindet, falls ja wird diese Inkludiert, falls nein geben wir eine "404" Meldung aus.
public static function checkPage($page) { if(file_exists(Dir."/template/backend/$page.php")) require_once(Dir."/template/backend/$page.php"); else echo "404 .. Seite nicht vorhanden";}
Inhalt anzeigen
Inhalt anzeigen
So ist das richtig, allerdings muss der Backend Code ja auch irgendwo Abgelegt werden, ansonsten macht das Prinzip mit der Codetrennung keine Sinn.
Inhalt anzeigen
Inhalt anzeigen
<?phpdefine('Dir',__DIR__);require_once(Dir.'/lib/system.class.php');?><!DOCTYPE html><html><head> <meta charset="UTF-8"> <title>Smarty Tutorial</title></head><body><?php new Page($_GET['page']); ?></body></html>
Inhalt anzeigen
Bis jetzt sollte hier nichts neues sein, außer das wir unser Page Klassen objekt erstellen, und somit die Seitenverwaltung aufrufen.
Inhalt anzeigen
Inhalt anzeigen
Nun kommt dort, wie bei den "ersten schritten in Smarty" gezeigt er Backend Code.
<?phpSystem::TPL()->assign('testvariable','Ich wurde im Backend geschrieben!');System::TPL()->display('index.tpl');?>
Inhalt anzeigen
Am ende Rufen wir die "index.tpl" auf. Diese muss sich im "template/templates" ordner befinden, wir in den ersten Schritten erklärt.
In ihr geben wir nun die Variable wieder:
Inhalt anzeigen
Nach diesem Anwendungsbeispiel wird hoffentlich endgültig Klar, wie es funktioniert.
Möchte man eine Seite hinzufügen, so erstellt man eine php Datei mit dem Seitennamen im Backend Ordner, man benötigt aber auch die Template Datei im template/temlates Ordner, als Frontend.
Arrays in Smarty
Natürlich kann man auch mit Arrays arbeiten, und diese dann im Template verarbeiten.
Ich werde einfach mal im Backend Ordner eine "array.php" Datei erstellen damit wir sie über "index.php?page=array" aufrufen können. Die "array.tpl" erstelle ich wie immer im template/templates Ordner.Inhalt anzeigen
Als erstes erstellen wir in unserer "array.php" eine Variable als Array.
Inhalt anzeigen
Als nächstes lassen wir mal eine Schleife 5 mal Durchlaufen und setzen somit eine Dimmension und den Wert des Arrays.
Inhalt anzeigen
Nun ist unser Array fertig und wir können ihn zwischenspeichern.
Inhalt anzeigen
Nun zeigen wir noch unsere Template Datei an und somit ist der Backend-Code Fertig.
Inhalt anzeigen
Kommen wir nun zum anzeigen, in PHP würde das ganze nun so aussehen:
echo $array[2]; //ergibt 2, da die schleife in der ersten Dimension beim 2. Durchlauf war und somit auch der wert so gesetzt wurde.
Inhalt anzeigen
In Smarty geht das ganze aber bequemer, indem wir normal die Variable anzeigen, jedoch ergänzen wir die Dimensionen mit einem Punkt und dem wert der Dimension, in unserem Beispiel würde das so aussehen.
Inhalt anzeigen
Das ergibt demnach 2, da der wert der 2. Dimension als 2 gespeichert ist.
For Schleife in Smarty
Passend auf dem Vorherigen Thema mit den Arrays, zeige ich hier nun wie man in einer Template Datei eine Schleife einbindet, um so zum Beispiel verschiedene Sachen aufzulisten, wie z.B. Benutzer.
Ich benutze gleich die Dateien die wir bei dem Array Tutorial genutzt haben.Inhalt anzeigen
Am backend Code verändert sich nichts, daher gehen wir gleich in die Template Datei, ("array.tpl").
Inhalt anzeigen
Inhalt anzeigen
Inhalt anzeigen
Das heißt also, die Variable "i" gilt hier als index, die Schleife fängt bei 0 an und hört Praktisch bei 2 auf.
In PHP würde das ganze so aussehen:
Inhalt anzeigen
Inhalt anzeigen
Inhalt anzeigen
Nun gibt es noch einen sogenannten "forelse", dieses wird aufgerufen, wenn die schleifen z.B. bei 5 anfängt aber nur bis 1 laufen soll.
Inhalt anzeigen
Abfragen in Smarty
Es ist auch möglich, abfragen direkt im Template zu regeln, um z.B. verschiedenen Content anzeigen zu lassen.Inhalt anzeigen
Der Syntax einer einfachen Abfrage sieht demnach so aus.
Inhalt anzeigen
Die Abzufragende variable übergeben wir wieder im backend via.
Inhalt anzeigen
Demnach ist die Funktion selbsterklärend:
{if $variable == 1} Die Variable besitzt den Wert 1{elseif $variable == 2} Die Variable besitzt den Wert 2{else} Keiner der beiden Möglichkeiten treten ein.{/if}
Inhalt anzeigen
Template Dateien Inkludieren
Wenn man seine Website weiter strukturieren möchte, ist es sinnvoll, z.B. für footer, navbar weitere Template Dateien zu verwenden.Inhalt anzeigen
Nehmen wir mal an, das wir ein Template besitzen und nun ein anderes Template einbinden möchten, zwecks der Übersichtlichkeit, verwenden wir die Funktion "include".
Der Syntax sieht demnach so aus:
Inhalt anzeigen
Es ist recht selbsterklärend, allerdings muss die zu Inkludierende Datei sich auch im template/templates Ordner befinden.
PHP Code direkt im Template einbetten
Es gibt auch die Möglichkeit PHP Code im Template zu verwenden, das spricht zwar gegen jede Art, warum man überhaupt smarty verwenden sollte aber es gibt die Möglichkeit.
Sinnvoll wäre es zum Beispiel, wenn man in einem Template eine Klasse öffnet, zum Beispiel zur Seitenverwaltung.Inhalt anzeigen
Der Syntax sieht folgendermaßen aus:
Inhalt anzeigen
Jedoch gibt es da noch ein Problem, Diese Funktion ist in der "normalen" Smarty Klasse nicht vorhanden, wie gesagt aus gutem Grund, da so eine direkte Trennung zwischen Front und Backend nicht mehr gewährleistet wird.
Demnach müssen wir in unserer "template.class.php" die die Erbinformation in "SmartyBC" Umbenennen, da in dieser Klasse die Funktion aktiviert wird.
Inhalt anzeigen
Mehr muss nicht geändert werden
Fazit
Das Resultat ist nun einfache Trennung von Front und Backend. Ist doch ganz einfach oder?
Ich hoffe das Tutorial war gut verständlich, da ich eigentlich nicht so gut im erklären bin
Konstruktive Kritik ist wie immer gerne gesehen, bei Interesse kann ich auch weitere Tutorials machen und auf weitere Funktionen der Engine eingehen.
Bis dahin, Mit Freundlichem Gruß,
Slash™