In Form gebracht: Aller guten Dinge sind drei

Neue Features in Smarty 3
Kommentare

Smarty gilt als eine der beliebtesten PHP Template Engines. Mit Smarty 3, dessen Alphaversion im September erschien, wurde Smarty nicht einfach nur verbessert, sondern komplett neu entwickelt. Bei Redaktionsschluss dieses Artikels war die Beta 7 released. Bis zur offiziellen Freigabe wird zwar noch etwas Zeit ins Land gehen, von einer vollständigen Dokumentation ganz zu schweigen, dennoch gibt es viele, die mit Spannung auf Smarty 3 warten und sofort umsteigen wollen. Dieser Artikel gibt einen aktuellen Überblick über die wichtigsten Neuerungen.

Für Unsicherheit sorgte zunächst vor allem die Aussage, Smarty 3 sei nicht abwärtskompatibel zu Smarty 2. Die Entwickler haben sich um eine hohe Rückwärtskompatibilität bemüht, daher trifft das nur für einige (wenige) Punkte zu. In jedem Fall bietet die neue Smarty-Version jede Menge Verbesserungen und neue Features. Smarty 3 ist dabei nicht einfach eine Weiterentwicklung von Smarty 2, sondern wurde von Grund auf neu programmiert. Es ist nun komplett in PHP 5 geschrieben und der Parser/Compiler wurde um einen Lexer erweitert (Kasten: Lexer/Parser), mit dem verschiedene Syntaxverbesserungen, frühere Fehlererkennung, rekursive Funktionen und andere Features möglich werden. Die Smarty-Entwickler versprechen eine intuitivere Nutzung, schnelleres Einarbeiten und höhere Performance. Eine bestmögliche Abwärtskompatibilität stand dabei immer im Vordergrund – es sind kaum Effekte auf das öffentliche API gegenüber Smarty 2 zu bemerken.

Lexer/Parser Ein Compilier-Vorgang besteht aus mehreren Phasen, zu denen auch die Lexikalische Analyse (Scanning) und die Syntaktische Analyse (Parsing) gehören. Der Lexer, auch Scanner genannt, zerlegt den Quellcode in seine einzelnen Bestandteile: Variablen, Operatoren und Symbole. Der Parser prüft diese einzelnen Bestandteile auf syntaktische Richtigkeit und ordnet sie zu hierarchischen Gruppen.

Das neueste Betarelease kann auf der offiziellen Smarty-Seite heruntergeladen werden. Man kann auch das SVN-Repository nutzen, auf dem die jeweils aktuellste Version zur Verfügung steht. Die Verzeichnisstruktur hat sich gegenüber der von Smarty 2 nur geringfügig geändert:

/ Smarty.class.php /sysplugins/   internal.* /plugins/   block.*   function.*   modifier.*   ...  

Das Verzeichnis /sysplugins enthält den Smarty Core. Die hier enthaltenen Dateien sollten Sie nicht verändern. In /plugins liegen die Plug-ins, mit denen die Funktionalitäten der Template Engine erweitert werden – wie auch schon bei Smarty 2. Hier können wie gewohnt eigene Plug-ins hinzugefügt werden. Anders als im Vorgänger sind Plug-ins in Smarty 3 Klassen, die Smarty_Internal_PluginBase erweitern. Jedes Plug-in hat die Eigenschaft $this->smarty, die eine Smarty-Instanz referenziert. Plug-ins im Smarty-2-Stil (Funktionen) werden weiterhin unterstützt, sie werden einfach ins /plugins-Verzeichnis von Smarty 3 übertragen.

Wie in Smarty 2 müssen auch die Verzeichnisse für Templates und Cache (/templates, /templates_c, /cache, /configs) selbst angelegt werden. /cache und /templates_c müssen Schreibrechte haben. Auch an der Einbindung der Smarty-Klasse in das Skript hat sich auf den ersten Blick nichts geändert:

require('Smarty.class.php'); $smarty = new Smarty(); $smarty->assign('foo','bar'); $smarty->display('index.tpl');

Objekte und Variablensichtbarkeit

In Smarty 2 werden alle zugewiesenen Variablen global in einem einzigen Smarty-Objekt gespeichert. Damit sind sie in sämtlichen Templates verfügbar. In Smarty 3 können Variablen ebenfalls dem Smarty-Objekt zugewiesen werden. Sie können aber auch einem Datenobjekt (Smarty_Data) oder einem Template-Objekt (Smarty_Template) übergeben werden. Damit wird es möglich, auf die Sichtbarkeit von Variablen Einfluss zu nehmen und so Namenskonflikte zu vermeiden. Das API von Daten- und Template-Objekten ähnelt der des Smarty-Objekts: Alle bekannten Methoden zum Zuweisen von Variablen können auch auf Daten- und Template-Objekte angewendet werden. Datenobjekte sind hier eine Art Variablencontainer mit eigenem Sichtbarkeitsbereich:

$data = new Smarty_Data();  $data->assign('foo','bar'); $data->load_conf('app.conf');

Datenobjekte können ein Smarty-Objekt oder ein anderes Datenobjekt als Elternklasse zugewiesen bekommen, indem die Objektinstanz dem Konstruktor als Parameter übergeben wird: $data = new Smarty_Data($smarty);. Jedes Template wird in Smarty 3 durch ein Objekt repräsentiert. Mittels Smarty_Template können einzelne Templates unabhängig gerendert werden, ohne das Singleton Pattern von Smarty zu verletzen. Um ein Template zu erzeugen, bedient man sich der createTemplate()-Methode des Smarty-Objekts. Diese Methode erwartet dann dieselben Parameter wie fetch() und display():

function createTemplate($template, $cache_id = null, $compile_id = null, $parent = null);

Der erste Parameter ist der Name des Templates. Es kann auch ein Smarty- oder ein Datenobjekt übergeben werden, dann wird eine Kopie dieses Objekts erzeugt. Der zweite Parameter ist die Elternklasse. Ein Template „erbt“ immer alle Variablen seiner Eltern, d. h. es hat auf diese Variablen Zugriff:

$tpl = $smarty->createTemplate('mytpl.tpl'); // ohne Elternklasse $tpl = $smarty->createTemplate('mytpl.tpl',$smarty); // Smarty-Instanz ist Parent $tpl->assign('foo','bar');    $tpl->conf_load('my.conf');

fetch() und display() erzeugen übrigens implizit ein Template-Objekt. Wird der vierte Parameter ($parent) dabei nicht spezifiziert, wird automatisch das Smarty-Objekt als Parent zugewiesen. Wird ein Template innerhalb eines anderen Templates via {include} aufgerufen, ist das aufrufende Template automatisch die Elternklasse des Subtemplates. Auf diese Weise können Template-Objekte beliebig tief miteinander verkettet werden. Das Objekt am Ende der Kette kann auf alle Variablen zugreifen, die zu diesem Template und zu den Elternobjekten gehören. Das Smarty-Objekt kann immer nur Wurzel einer solchen Kette sein, muss es aber nicht.

Jedes Template kann so auf seine eigenen Variablen und die seiner Eltern zugreifen. Variablen eines Subtemplates sind im Elterntemplate nicht verfügbar. Dasselbe gilt für Veränderungen, die im Subtemplate an Variablen des Elterntemplates vorgenommen wurden. Dieses Verhalten kennen wir bereits aus Smarty 2. In Smarty 3 kann Variablen zusätzlich ein Scope-Attribut zugewiesen werden. So ist es z. B. möglich, Variablen eines Subtemplates eine globale Sichtbarkeit zu geben, sodass diese auch im Elterntemplate verfügbar sind. Smarty kennt die Scopes localparentrootund global:

{assign var=foo value='bar' scope='parent'}  {$foo='bar' scope='parent'}  // Kurzform

local ist der Standardwert, die Variable ist nur lokal sichtbar. parent macht die Variable für das (direkte) Elterntemplate sichtbar, root macht sie für alle Templates der Objektkette sichtbar, also für sämtliche Elterntemplates bis zur Wurzel. Und mit scope=’global‘ schließlich wird die Variable für alle Smarty-Templates der Anwendung verfügbar. Das Scope-Attribut kann auch dem {include}-Tag hinzugefügt werden, dann ist dieser Scope Standard für alle Variablen, die im inkludierten Template erzeugt oder verändert werden.

[ header = Seite 2: Exception Handling ]

Exception Handling

Mit PHP 5 hält das Exception Handling Einzug in Smarty. Bei vielen Fehlern wird nun eine Ausnahme geworfen, die mittels eigenem Exception Handler aufgefangen und behandelt werden kann. Die Funktion bzw. Klasse/Methode, die das Exception Handling übernehmen soll, wird an Smarty wie folgt übergeben:

$smarty->setExceptionHandler('ExceptionFunktion');  $smarty->setExceptionHandler(array('ExceptionKlasse','ExceptionMethode')); 

Es wird entweder der Name der Funktion oder der Name der Klasse und der Methode (dann als Array) übergeben.

Neue Smarty-Syntax

Die Syntax von Smarty ist nun noch enger an der von PHP angelehnt, was vor allem PHP-Entwicklern den Einstieg erleichtern soll. {assign} und {math} sind unter Smarty-Usern nicht sehr beliebt. Sie wurden in Smarty 3 durch eine stark vereinfachte Syntax ersetzt. Für die Rückwärtskompatibilität werden beide aber weiterhin unterstützt. {assign} wird in Smarty 2 verwendet, um Variablen innerhalb eines Templates zu erzeugen oder ihnen einen neuen Wert zuzuweisen. Eine typische Anweisung lautete beispielsweise {assign var=flaeche value=’$x * $y’}. In Smarty 3 ist das nun ganz einfach: {$flaeche = $x * $y}.

Kompliziert wurde es, wenn komplexere Berechnungen nötig waren, da dazu oft mehrere assign-Statements erforderlich waren, weil innerhalb der Backticks keine Klammern gesetzt werden dürfen:

{assign var=einWert value=’$x + 1’} {assign var=einWert value=’$einWert / 2’}

Dasselbe in Smarty 3: {$einWert = ($x + 1) / 2}. Mit dieser neuen Syntax ist jetzt sogar das Erzeugen von nummerischen und assoziativen Arrays möglich:

{$arr=(1, 2, 3)} {$arr=('one'=>1, 'two'=>2, 'tre'=>3, 'foo'=>$bar)} 

Smarty-Tags können auch innerhalb anderer Tags als Werte verwendet werden, z. B. {$foo={counter}+3}. Das geht sogar innerhalb von doppelten Anführungszeichen: {$foo="Dies ist Durchlauf Nummer {counter}"}. Mit dem {math}-Tag werden in Smarty 2 Berechnungen ausgeführt. Das Ergebnis wird direkt ausgegeben: {math equation="x * y" x=$height y=$width}. In Smarty 3 sind solche Ausdrücke nun wesentlich einfacher möglich, ohne die Gefahr, sich die Finger zu brechen: {$height * $width}.

Ausdrücke sind in Smarty 3 im Übrigen fast überall erlaubt. So können bspw. Variablennamen auch variable Bestandteile oder Ausdrücke enthalten:

$foo_{$bar}    $foo_{$x+$y}   

Variablen können nun auch ganz einfach per {$foo++} bzw. {$foo–} inkrementiert bzw. dekrementiert werden (in Smarty 2 nur per {assign} möglich). Auch PHP-Funktionen können direkt verwendet werden:

{$foo = strlen($bar)} {$foo = myfunct(($x+$y))}

Außerdem können nun Objekte an Smarty 3 übergeben werden. Innerhalb des Templates sind sämtliche Methoden und Eigenschaften des Objekts verfügbar. So kann z. B. ein SimpleXMLElement-Objekt einfach an Smarty übergeben und innerhalb der Templates genutzt werden. Objektmethodenaufrufe lassen sich dabei verketten: {$object->method1($x)->method2($y)}.

Arrays

Wie oben bereits dargestellt, lassen sich Arrays nun auch innerhalb eines Templates erzeugen. Das ist auf verschiedene Weise möglich. Ist die Variable kein Array, wird sie automatisch in eines umgewandelt:

{$arr=(1, 2, 3)} {assign var=arr values=[1,2,3]} {$arr['foo']=1}

Der Zugriff auf die Werte eines Arrays innerhalb des Templates erfolgte in Smarty 2 mittels Punkt. Die eckigen Klammern waren templateinternen Funktionalitäten vorbehalten. Ab Smarty 3 kann auf Arrays auch per eckigen Klammern zugegriffen werden, wie wir es aus PHP gewohnt sind:

{$arr[1]} {$arr['foo']} {$arr['bar'][1]} {$arr[$x+$x]}   

Auch der Zugriff auf assoziative Indizes, die Sonderzeichen enthalten, wurde wesentlich vereinfacht:

{assign var=foo value="home-address"} {$user[$foo]}  // in Smarty 2  $user['home-address']  // in Smarty 3

Der Zugriff per Punkt funktioniert weiterhin und wurde um einige Features erweitert. So können die Delimiter verwendet werden, um Ausdrücke als Index zu verwenden oder um verschachtelte Arrays darzustellen:

{$foo.a.b.c}        =>  $foo['a']['b']['c']  {$foo.a.{$b+4}.c}   =>  $foo['a'][$b+4]['c']  // Ausdrücke als Index {$foo.a.{$b.c}}     =>  $foo['a'][$b['c']]  // verschachtelter Index

for – foreach – while

Mit dem neuen {for}-Tag, das {section} ersetzt, können unter anderem nummerische Arrays durchlaufen werden. {section} wird für die Abwärtskompatibilität weiterhin unterstützt, aber nicht mehr empfohlen: {for $x=0, $y=count($foo); $x<$y; $x++} .... {/for}. Im ersten Ausdruck im for-Tag, das die Schleife initialisiert, können beliebig viele Anweisungen durch Komma getrennt übergeben werden. Ebenfalls zulässige Formen sind:

{for $x = $start to $end step $step} ... {/for} {for $x = $start to $end} ... {/for}

Dabei wird $x in jedem Durchlauf um 1 (bzw. $step) erhöht bzw. -1 reduziert, abhängig vom Start- und Endwert. Anstelle von $start und $end können beliebige Ausdrücke verwendet werden. Auch die {foreach}-Anweisung zum Durchlaufen assoziativer Arrays wurde vereinfacht:

{foreach from=$myarray item=var}...{/foreach}  // Smarty 2 {foreach $myarray as $var}...{/foreach}  // Smarty 3 {foreach $myarray as $key => $var}...{/foreach}  // das geht auch

Innerhalb von {for}– und {foreach}-Schleifen kann nun auf Smarty-interne Variablen so zugegriffen werden:

$var@first          true im ersten Durchlauf $var@last           true im letzten Durchlauf $var@key            aktueller Array-Schlüssel (nur foreach) $var@iteration      Nummer des Durchlaufs (beginnt bei 1) $var@index          Nummer des Durchlaufs (beginnt bei 0 = Key bei for) $var@total          Anzahl der Array-Elemente, die durchlaufen werden

Neben foreach und for gibt es nun auch while-Schleifen:

{while $foo}...{/while} {while $x > 10}...{/while} {literal} fällt weg

JavaScript- und CSS-Blöcke müssen nun nicht mehr zwingend in {literal}-Tags eingeschlossen werden. In Smarty 2 führen eingebettete JS- und CSS-Anweisungen zu einem Fehler, wenn sie geschweifte Klammern enthalten, weil Smarty versucht, die vermeintlichen Anweisungen zu parsen. Um das zu verhindern, müssen solche Abschnitte in {literal}-Tags eingefasst werden. In Smarty 3 ist das nun nicht mehr nötig, denn Anweisungen, in denen der Delimiter ein nachfolgendes bzw. führendes Leerzeichen hat, werden ignoriert. Dieses Verhalten lässt sich per $smarty->auto_literal=false deaktivieren.

[ header = Seite 3: Funktionen im Template ]

Funktionen im Template

Wiederkehrende Anweisungen innerhalb von Templates konnten in Smarty 2 nur als Plug-ins umgesetzt werden, wenn man Coderedundanzen vermeiden wollte. In Smarty 3 ist es nun auch möglich, Funktionen zu definieren, und zwar im Template. Diese können sogar beliebig tiefe Rekursionen beinhalten. Eine Funktion wird innerhalb eines {function}…{/function}-Blocks definiert. Ein typischer Anwendungsfall für einen rekursiven Aufruf ist ein verschachteltes Menü, vergleiche Listing 1.

// Funktionsdefinition
{function name=menu level=0}
    {foreach $data as $entry} {if is_array($entry)} <li{$entry@key} {menu data=$entry level=$level+1} {else}
  • {$entry}
  • {/if} {/foreach}
{/function} // Menü-Array {$menu = ['eintrag1','eintrag2' => ['eintrag21','eintrag22','eintrag23' => ['eintrag231']],'eintrag3']} // Aufruf {menu data=$menu} Ausgabe: * eintrag1 * eintrag2 * eintrag21 * eintrag22 * eintrag23 * eintrag231 eintrag3

Über das name-Attribut im function-Tag wird ein Funktionsname festgelegt, über den die Funktion aufgerufen wird, dabei können beliebige weitere Attribute in das Funktionstag eingefügt werden. Diese stellen die Default-Werte der lokalen Funktionsvariablen dar. Ein Aufruf von Funktionen mit variablem Namen ist mittels {call}-Tag möglich. Als name-Attribut wird der Name der Funktion übergeben: {call name=$irgendeineFunktion}.

Template Enheritance

Eine weitere neue Funktionalität in Smarty 3 ist die Template-Vererbung. Damit soll die Wiederverwendbarkeit von Template-Bestandteilen ermöglicht werden. Im Basistemplate werden dazu Blöcke mit veränderlichen Inhalten per {block} … {/block} gekennzeichnet. Im abgeleiteten Template werden dann die Inhalte für diese Blöcke (und nur für diese) definiert. Alles, was in abgeleiteten Templates außerhalb von {extend}– und {block}-Tags definiert wird, wird ignoriert (Listing 2).

basis.tpl


{block name="title"}Standard{/block}
{block name="head"}{/block}


{block name="body"}{/block}



my.tpl
{extend file="basis.tpl"}
{block name="title"} Seitentitel {/block}
{block name="head"}  {/block}
{block name="body"}  {/block}

Aufruf im Skript
$smarty->display('my.tpl');

Ausgabe:


Seitentitel






{block}-Tags in der abgeleiteten Datei können ein optionales append- oder prepend-Attribut enthalten. Dann wird der in diesem Block enthaltene Inhalt dem Inhalt des Elternblocks vorangestellt oder angefügt:

{block name='title' append} Kind-Titel {/block}
Ausgabe:    Standard Kind-Titel 

Template Enheritance kann auch noch anders festgelegt werden: $smarty->display('extends:parent.tpl|child.tpl|grandchild.tpl');. Der Vererbungsbaum kann beliebig tief verschachtelt werden, Child-Templates können wieder abgeleitet werden usw. Allerdings geht die Vererbung zu Lasten der Performance, da in jeder abgeleiteten Datei zur Laufzeit nach Änderungen gesucht werden muss.

„Echtes“ PHP

Bereits in Smarty 2 gibt es die Möglichkeit, „reinen“ PHP-Code mittels {php}-Tags ins Template einzubetten. In Smarty 3 ist dieses Feature allerdings standardmäßig deaktiviert. Falls Sie es benötigen, setzen Sie $smarty->allow_php_tag = true. In Smarty 3 können aber auch reine PHP-Templates eingebunden werden. Diese werden nicht wie tagbasierte Templates kompiliert, sondern direkt inkludiert. Wenn Sie ein PHP-Template einbinden, müssen Sie das Smarty über den Ressourcentyp php mitteilen: $smarty->display('php:foo.php');Achtung: PHP-Templates unterliegen nicht den Sicherheitsfeatures von Smarty.

Auch innerhalb eines „normalen“ Templates können PHP-Dateien eingebunden werden: {include file=”php:foo.php”}. In den PHP-Dateien kann dann ganz normal auf die Smarty-Variablen zugegriffen werden: . Außerdem können PHP-Funktionen wie in normalen PHP-Dateien verwendet werden: .

Die Smarty-Plug-ins sind zurzeit noch nicht in PHP-Templates verfügbar. Eine entsprechende Wrapper-Funktion ist laut Smarty-Entwickler jedoch geplant. Die Möglichkeit, PHP-Dateien direkt in Smarty aufzurufen, ist standardmäßig deaktiviert und kann mit $smarty->allow_php_templates = true aktiviert werden.

Mehr Sicherheit

Für mehr Sicherheit sorgen soll die Klasse Smarty_Security, in der verschiedene Sicherheitseinstellungen gemacht werden können. So werden hier die PHP-Funktionen festgelegt, die im Smarty-Template verwendet werden dürfen. Es wird eingestellt, ob in Templates auf Smarty-Konstanten zugegriffen werden darf und wie -Tags innerhalb von Templates behandelt werden. Wenn Sie eigene Security-Features implementieren möchten, leiten Sie Smarty_Security ab und binden Sie Ihre Klasse mittels $smarty->security_class=’meineSecurityKlasse‘ ein.

Bessere Performance

Die Performance ist ein heißes Thema in der Diskussion um Smarty 3. Einerseits wird der enorme Performancegewinn als Top-Vorteil der neuen Smarty-Version und als das schlagende Argument für einen Umstieg gehandelt. Andererseits trifft man im Web und im Smarty-3-Forum noch überwiegend auf den Tenor, dass Smarty 3 langsamer sei als sein Vorgänger, teilweise drastisch (s.h.Vergleich auf bohwaz/blog oder die Diskussion auf smarty.net). Allerdings stammen die meisten Benchmarks von früheren Betas, und in der Zwischenzeit ist wieder viel passiert. Außerdem steht die Funktionalität am Anfang eines Projekts vor der Performance, die ohne Zweifel noch verbessert werden wird. Dank Lexer, schlankerem Core und anderen Optimierungen bleibt Smarty 3 in dieser Hinsicht vielversprechend.

Für schnelles Laden sollte unbedingt die Cache-Funktion aktiviert und die Option force_compile deaktiviert werden, denn sonst werden Templates bei jedem Aufruf neu kompiliert. Jeder Kompilierungsvorgang dauert aufgrund des Lexers und komplexeren Prüfungen in Smarty 3 länger, die Aufrufe vorkompilierter Templates sollen dafür jedoch bedeutend schneller sein. In Smarty 2 gab es bei der Frage nach dem Caching nur Schwarz oder Weiß. Wurde der Cache aktiviert, wurde alles gecachet, ohne Ausnahme. In Smarty 3 lassen sich nun mittels {nocache} … {/nocache}-Tag oder nocache-Attribut ausgewählte Bereiche eines Templates vom Caching ausschließen. Letzteres (nocache oder nocache=true) kann in beliebigen Tags verwendet werden:

{$foo nocache=true}
{strlen($foo) nocache}

Eine Variable kann auch bereits im Skript als vom Caching ausgeschlossen deklariert werden. Setzen Sie dazu den dritten Parameter der assign-Methode auf true$smarty->assign('foo',$something,true);.

Migration von Smarty 2 auf Smarty 3

Wie wir gesehen haben, werden viele Funktionen von Smarty 2 unterstützt, auch wenn sie nicht mehr empfohlen werden. Es ist weitestgehend rückwärtskompatibel und die Migration zu Smarty 3 gestaltet sich in aller Regel als sehr einfach. Einige Punkte gibt es dennoch zu beachten. Zunächst einmal ist Smarty 3 komplett in PHP 5 geschrieben. Wenn Sie eine eigene Klasse geschrieben haben, die die Smarty-Klasse erweitert, muss diese ebenfalls in PHP 5 umgewandelt werden. Das bedeutet z. B., dass beim Erzeugen der abgeleiteten Klasse der Konstruktor (Interzeptormethode __construct()) der Parent-Klasse (also Smarty) nicht mehr implizit aufgerufen wird. Er muss per parent::__construct(); explizit aufgerufen werden. Auch das {php}-Tag ist in Smarty 3 standardmäßig deaktiviert. Falls Sie es in Ihren Templates nutzen, setzen Sie $smarty->allow_php_tag=true.

Delimiter mit einem folgenden bzw. führenden Leerzeichen werden nicht mehr als Smarty-Tags interpretiert. { if … } wird somit beispielsweise nicht kompiliert und muss in {if …} umgewandelt werden. Per Suchfunktion des Editors lassen sich solche Stellen jedoch schnell ausfindig machen und beheben. Wird dieses neue Verhalten von Smarty nicht gewünscht, kann es per $smarty->auto_literal = false abgestellt werden.

Smarty 3 ist strenger, was das Einfassen von Strings in Hochkommata angeht. Diese dürfen nur noch weggelassen werden, solange der String ausschließlich aus Buchstaben, Ziffern und Unterstrich besteht. Smarty 2 war da um Einiges toleranter. Außerdem zeigten sich Probleme mit ‘ (Accent Grave bzw. Backticks, keine einfachen Hochkommata), die in Smarty 2 z. B. innerhalb der{assign}-Tags verwendet werden. Diese führen im aktuellen Smarty-Release zu einer Exception und müssen durch doppelte Anführungszeichen ersetzt werden.

Smarty 3 nutzt seine eigenen Autoloader, die per spl_autoload_register() registriert werden. Die Interzeptormethode __autoload() funktioniert daher nicht. Falls Sie eine solche in Ihrem Code verwenden, müssen Sie sie explizit per spl_autoload_register() registrieren. Die Dateinamen von eigenen Plug-ins müssen für den Smarty-eigenen Autoloader lowercase sein.

Die speziellen Smarty-Variablen innerhalb {foreach} oder {section} (z. B. $smarty.foreach.foo.index) waren in Smarty 2 global sichtbar. In Smarty 3 haben diese nur noch lokalen Scope, d. h. in inkludierten Templates kann auf diese Werte nicht mehr zugegriffen werden. Falls sie im Subtemplate benötigt werden, müssen sie explizit als Parameter im {include}-Statement übergeben werden: {include file='meinTemplate.tpl' index=$smarty.foreach.foo.index}.

Smarty 3 arbeitet zudem standardmäßig mit UTF-8 Encoding. Dieses Encoding wird auch für Modifizierer (trimescape etc.) als Standardzeichensatz verwendet. Falls Ihr Template ein anderes Encoding verwendet, ändern Sie die Konstante SMARTY_RESOURCE_CHAR_SET, da sonst Ausgabefehler auftreten können. Die Datei SMARTY2_BC_NOTES, die im Smarty-Paket enthalten ist, gibt Ihnen aktuelle Hinweise zu den jeweils bekannten Unverträglichkeiten zwischen den Versionen.

Fazit

Dieser Artikel gibt einen (unvollständigen) Überblick über neue Funktionalitäten von Smarty 3, von dem bei Redaktionsschluss die Beta 7 veröffentlicht war. Fast täglich erscheinen im SVN-Repository Aktualisierungen mit neuen Features, Optimierungen und Bugfixes. Bis die offizielle Smarty 3 erscheint, wird aber wohl noch etwas Zeit ins Land gehen. Wer es nicht erwarten kann, kann jedoch schon jetzt auf ein relativ stabiles Release umsteigen und kommt dann in den Genuss vieler neuer Möglichkeiten und Vereinfachungen. Bei Fragen zum Umstieg oder zu neuen Funktionalitäten steht das extra eingerichtete Smarty-3-Forum zur Verfügung. Bugs, Ideen und Anregungen sendet man besser an die Google Group Smarty Developer.

Alles in allem kann man wohl sagen, dass Smarty 3 ein großer Schritt in die richtige Richtung ist. Nur wenig Aufwand bei der Umstellung werden belohnt durch interessante Funktionalitäten, bessere Erweiterbarkeit, mehr Sicherheit und eine wesentlich vereinfachte Syntax. Insbesondere PHP-Entwickler werden das zu schätzen wissen.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Meinungen zu diesem Beitrag

X
- Gib Deinen Standort ein -
- or -