Speanet.info

Hinweis: Bitte vor dem durcharbeiten dieses Tutorials diesen Artikel hier lesen: Once upon a time there was Smarty!

Inhaltsverzeichnis

• Einleitung
• 1. Installation
• 2. Smarty Konfiguration
• 3. Mit Smarty arbeiten
  • 3.1 Werte an Smarty übergeben
  • 3.2 Template erstellen
  • 3.3 Template ausgeben bzw. parsen
  • 3.4 Konfigurationsdateien
    • 3.4.1 Aufbau
    • 3.4.2 Laden einer Konfigurationsdatei
    • 3.4.3 Ausgabe
  • 3.5 Variablen-Modifikatoren
    • 3.5.1 Beispiele
    • 3.5.2 Anwendung
  • 3.6 Funktionen
    • 3.6.1 Beispiele
    • 3.6.2 Anwendung
• 4. Extras
  • 4.1 Plugins
  • 4.2 Wie kann ich…
    • 4.2.1 …Zeilen in einer Tabelle abwechselnd eine andere Farbe geben?
    • 4.2.2 …PEAR::HTML_QuickForm mit Smarty verwenden?

Einleitung

Was ist Smarty?
Smarty ist eine Template Engine welche die generierten Templates in neue PHP-Dateien umwandelt. Somit muss nicht jedes Template
immer wieder neu geparsed werden, wenn es augerufen wird. Das ganze ist das sogenannte Caching.

Was braucht Ihr?
Einen funktionieren Webserver mit PHP >= 4.0.6 und natürlich Smarty.
Es werden in diesem Tutorial mindestens Grundkenntnisse in PHP voraussgesetzt!

1. Installation

Smarty installieren:
(Da bei dem heruntergeladenen Paket eine ausführliche Installationsanleitung beiliegt, werde ich das hier nicht weiter erläutern)

2. Smarty Konfiguration

Zuerst einmal müssen wir die Smarty Klasse einbinden
define(‘SMARTY_DIR’, ‘/pfad/zu/Smarty/’);
require_once(SMARTY_DIR. ‘Smarty.class.php’);
?>

Anschließend erstellen wir eine neue Instanz von Smarty
$smarty = new Smarty();
?>

Im folgenden nehmen wir eine paar Einstellungen vor, welche in den Kommentaren erklärt werden
$smarty->compile_check = true; //Prüfen, ob sich das Template geändert hat, wenn ja, wird es neu compiliert

$smarty->caching = true; //Caching einschalten
?>

Smarty benötigt 4 Verzeichnisse:

• templates
• templates_c
• configs
• cache

In dem Verzeichnis templates werden die ganzen Templates abgelegt, dieses Verzeichnis kann beliebig viele Unterverzeichnisse enthalten.
Das Verzeichnis templates_c enthält die compilierten Templates, die Smarty erstellt. An diesen Dateien darf nichts geändert werden.
Das configs Verzeichnis dient zur Ablage verschiedene Konfigurations Dateien, was es damit genau auf sich hat, werde ich später erklären.
In dem Verzeichnis cache werden die Templates-Cache abgelegt.

Standardmässig sucht Smarty diese Verzeichnisse in dem Verzeichnis, von wo das PHP-Script aufgerufen wurde.
Dies kann man allerdings durch folgende Eigenschaften ändern:
$smarty->template_dir = ‘/pfad/zum/Template_Verzeichnis/’;
$smarty->compile_dir = ‘/pfad/zum/Template_c_Verzeichnis/’;

$smarty->config_dir = ‘/pfad/zum/Config_Verzeichnis/’;
$smarty->cache_dir = ‘/pfad/zum/Cache_Verzeichnis/’;

?>

3. Mit Smarty arbeiten

3.1 Werte an Smarty übergeben

Nun erkläre ich wie man verschiedene Werte an Smarty übergibt, und wie man diese in einem Template anspricht bzw. ausgibt:

Zuerst einmal die Werte an Smarty übergeben.
//Ein Array, welches aus einer Datenbank stammen könnte

$array = array(
0 => array( ‘id’ => 1,
‘text’ => ‘test’),
1 => array( ‘id’ => 2,
‘text’ => ‘foobar’ ),
2 => array( ‘id’ => 3,
‘text’ => ‘ein weiterer test’
));

$test = ’string’;
$test2 = 2;

$smarty->assign(‘test_array’, $array);
$smarty->assign(‘test’, $test);
$smarty->assign(‘test2′, $test2);
?>

3.2 Template erstellen

Nun erstellen wir das Template.
In der Variable test steht {$test}
In der Variable test2 steht {$test2}

{foreach from=$test_array item=arr}
Die ID lautet: {$arr.id}
Der Text lautet: {$arr.text}
{/foreach}

Als erstes werden die 2 Test Variablen ausgegeben.
Anschließend wird eine foreach-schleife gestartet, welche als Parameter mindestens die 2 Werte from und item erwartet:
- from ist das zu durchlaufende Array
- item ist der Name der Variable des momentanen Elements
In der foreach-schleife wird dann per {$arr.id} auf die ID des aktuellen Elements (in unserem Fall ist dies ein Array) zugegriffen.
Auf die Werte eines Array greift man in einem Smarty-Template mithilfe des . darauf zu, in unserem fall z.b. $arr.id (was dasselbe ist, wie in PHP $arr['id'])

3.3 Template ausgeben bzw. parsen

So, soweit so gut, wir haben Smarty die Werte zugewiesen und ein Template erstellt, nun müssen wir es nur noch ausgeben, dies macht man mit der Methode display:
$smarty->display(‘test.tpl’); //Ich geh jetzt mal davon aus, das wir unser Template unter dem Namen test.tpl abgespeichert haben

?>

Bis hierhin ist es doch noch ganz einfach ;)

3.4 Konfigurationsdateien

Kommen wir nun zum behandeln von Konfigurationsdateien.
Die Konfigurationsdateien werden (wie oben schon erwähnt) in dem configs Verzeichnis abgelegt.

3.4.1 Aufbau

# global Variables
farbe = ‘#DCDCDC’
titel = ‘Seiten Name’
header = “”"Dieser Text erstreckt sich
über mehrere Zeilen, und muss daher
mit drei Anführungszeichen gekennzeichnet werden”"”

[Login]
farbe = ‘#CECECE’
titel = ‘Login Seite’

[.Datenbank]
host = 10.10.10.10
db = foo
user = sql-user
pass = tetst

Die globalen Variablen stehen immer am Anfang der Konfigurationsdatei und werden immer mitgeladen, danach folgen die sogenannten Sektionen, diese müssen beim laden einer Konfigurationsdatei extra mit angegeben werden.
Sie können auch eine Sektion oder eine Variable ‘verstecken’, dies bedeutet, dass Smarty diese Sektionen bzw. Variablen nicht in das Template einliest. Dies ist vorallem für sensible Daten wichtig, die Sie für Ihre Applikation benötigen (hier z.b. mit Datebank Login-Informationen).

3.4.2 Laden einer Konfigurationsdatei

Eine Konfigurationsdatei kann entweder direkt im Template geladen werden, oder noch vorher im PHP-Script.

Hier die 2 Methoden:
//Konfigurationsdatei laden und Variablen zuweisen
$smarty->config_load(‘meine.conf’);

//Nur eine bestimmte Sektion einer Konfigurationsdatei laden, die globalen Variablen werden selbstverständlich mitgeladen.
$smarty->config_load(‘meine.conf’, ‘Login’);
?>

{config_load file=”meine.conf”}
{config_load file=”meine.conf” section=”Login”}

3.4.3 Ausgabe

Ist eine Konfigurationsdatei erfolgreich geladen worden können Sie im Template wie folgt darauf zugreifen:
{#VariableAusEinerKonfigurationsdatei#}

3.5 Variablen-Modifikatoren

Die sogenannten Variablen-Modifikatoren werden dazu verwendet, um den Inhalt von Variablen zu verändern.
Smarty bietet standard-mässig schon eine Menge Modifikatoren an.

3.5.1 Beispiele

Hier nur ein paar Beispiele:

• nl2br – Funktioniert genau wie die PHP-Funktion {phpf}nl2br{/phpf}.
• truncate – Kürzt einen String auf eine bestimmte Länge.
• wordwrap – Erzeugt an einer definierten Stelle einen Umbruch in einer Zeichenkette.
• default – Setzt einen vordefinierten Wert auf eine Variable, falls diese leer ist.

3.5.2 Anwendung

Um einen Modifikator auf eine Variable anzuwenden, müssen Sie nach der Variable einfach ein Pipe-Zeichen (|) anhängen, und dann noch den entsprechenden Modifikator angeben.

Die sieht dann z.b. so aus:
$text = “Dies ist ein Text, der die Funktion von truncate genauer zeigen soll”;

$var = ”;
$smarty->assign(‘langerText’, $text);

$smarty->assign(‘var’, $var);
?>

test.tpl
{$langerText|truncate:30}
{$langerText|truncate:30:”"}
{$langerText|truncate:30:”._.”}
{$var|default:”Kein Wert vorhanden!”}

Ausgabe:
Dies ist ein Text, der die…
Dies ist ein Text, der die
Dies ist ein Text, der die._.
Kein Wert vorhanden!

Welche Parameter Ihr den einzelnen Modifikatoren übergeben müsst, und welche es gibt, könnte Ihr hier nachlesen.

3.6 Funktionen

Smarty bietet natürlich auch eingebaute Funktionen, mit welchen Sie z.b. eine Tabelle dynamisch erzeugen können oder eine Gleichung ausrechnen können.

3.6.1 Beispiele

• math – Mit dieser Funktion können Sie mathematische Gleichungen durchführen].
• cycle – Diese Funktione wird dazu verwendet, um durch eine Anzahl von Werten zu laufen.

3.6.2 Anwendung

test.tpl
{math equation=”5 * z + 4 – x” x=29 z=4}
{cycle values=”test, foo”}
{cycle values=”test, foo”}

Ausgabe
10
test
foo

Nun fragt Ihr euch bestimmt für was das Cycle gut ist, nunja, wenn man z.b. eine Tabelle hat, und den Zeilen abwechselnd eine andere Farbe geben will. Dies erkläre ich dann allerdings noch unter dem Punkt Extras -> Wie kann ich?.

4. Extras

So, jetzt geh ich noch auf ein paar Sachen ein, mit denen man sich vieles erleichtern kann.

4.1 Plugins

Plugins sind eigens geschriebene Funktionen, Variablen-Modifikatoren, Resources, Block-Funktione, …, etc.
Plugins werden im Verzeichnis Plugins abgelegt, dieser befindet sich im Verzeichnis von Smarty
Ein Plugin ist eigentlich nichts anderes als eine normale Funktion.
Plugins werden von Smarty automatisch geladen, dazu müssen diese nur einen speziellen Namen haben, der wie folgt lautet:
smarty_typ_funktionsname

Es stehen folgende Typen zur Verfügung:

• function
• modifier
• block
• compiler
• prefilter
• postfilter
• outputfilter
• resource
• insert

Wie genau man Plugins schreibt, wird hier genauer beschrieben.

4.2 Wie kann ich…

4.2.1 …Zeilen in einer Tabelle abwechselnd eine andere Farbe geben?

$array = array(

0 => array(
‘name’ => ‘Foo’,
‘nachricht’ => ‘Hallo ihr da draussen.’),
1 => array( ‘name’ => ‘Bar’,
‘nachricht’ => ‘Schönes Tutorial von dir *g*’ ),
2 => array( ‘name’ => ‘Foobar’,
‘nachricht’ => ‘Mal sehen ob das alles hier funktioniert’
),
3 => array( ‘name’ => ‘Test’,
‘nachricht’ => ‘Ein normaler Test’
));

$smarty->assign(‘tableArray’, $array);
$smarty->display(‘test.tpl’);
?>

test.tpl

{foreach from=$tableArray item=value}

{/foreach}

Name	Nachricht
{$value.name}	{$value.nachricht}

4.2.2 …PEAR::HTML_QuickForm mit Smarty verwenden?

Um QuickForm mit Smarty nutzen zu können, müsst ihr einen sogenannten Renderer benutzen.
Renderer sind bei QuickForm dabei, und müssen nur noch geladen und verarbeitet werden.

Schreiben wir uns erstmal eine kleine Funktion um das Formular in ein Array umzuwandeln.

function formToArray($form, $smarty, $automaticAssign = true)

{
require_once(‘HTML/QuickForm/Renderer/ArraySmarty.php’);

$renderer = &new HTML_QuickForm_Renderer_ArraySmarty($template);

$renderer->setRequiredTemplate(
‘{if $error}

{else}

{if $required}
*
{/if}
{/if}’
);

$renderer->setErrorTemplate(
‘{if $error}
» «
{/if}’

);

$form->accept($renderer);
if($automaticAssign === true) {

$template->assign(‘form’, $renderer->toArray());

}
return $renderer->toArray();

}

?>

In dieser Funktion erstellen wir zuerst eine neue Instanz von dem Smarty-Renderer, dann setzen wir ein Template für die notwendigen Felder.
Anschliessend wird noch das Fehler Template gesetzt, welches angezeigt wird, wenn bei einer Regel ein Fehler auftritt.
Nun müssen wir noch den Renderer akzeptieren und das generierte Array an Smarty übergeben..
Diese Funktion erwartet als Parameter ein Objekt von QuickForm und ein Objekt von Smarty, optional kann man noch true oder false für automaticAssign angeben, ist automatiAssign auf true, wird das generierte Array automatisch zugewiesen, dies trägt dan den Namen form

Erstellen wir uns nun ein kleines Login Formular, und konvertieren das Formular mithilfe der soeben erstellten Funktion.

require_once(‘HTML/QuickForm.php’);

$form = new HTML_QuickForm(‘Login’, ‘post’);

$form->setRequiredNote(‘Felder mit * sind erforderlich’);
$form->addElement(‘text’, ‘nickname’, ‘Benutzername’);
$form->addElement(‘password’, ‘passwort’, ‘Passwort’);

$form->addRule(‘nickname’, ‘Bitte einen Benutzernamen eingeben’, ‘required’);
$form->addRule(‘password’, ‘Bitte ein Passwort eingeben’, ‘required’);

if($form->validate()) {
formToArray($form, $smarty);
//alternativ können auch die unteren 2 Zeilen verwende werden
//$formArray = formToArray($form, $smarty, false);
//$template->assign(‘formName’, $formArray);
} else {
login($_POST['nickname'], $_POST['password']);
}
?>

Kommen wir nun zu dem Template
{$form.javascript}

{$form.hidden}

Login

Anmelden

{$form.nickname.label} {$form.nickname.html}

{$form.password.label} {$form.password.html}

{$form.requirednote}

Sollte die Validierung Clientseitig erfolgen, so steht das entsprechende Javascript in $form.javascript.
Die Attribute für das Formular stehen in $form.attributes und die hidden fields in $form.hidden.
Der Name eines Feldes wird immer mit $form.feldname.label abgerufen, und das erstellte HTML mit $form.feldname.html.
In $form.requirednote ist der Hinweis für die notwendigen Felder (in unserem Fall: ‘Felder mit * sind erforderlich’).

Wem das ganze zu kompliziert ist, der kann auch die standard Ausgabe von Smarty benutzen, das ganze sieht dann ungefähr so aus:
//… Formular erstellen …
$htmlForm = $form->toHtml();

$template->assign(‘form’, $htmlForm);
?>

und im Template dann einfach {$form} schreiben.