Guten Abend zusammen! Wie letzte Woche bereits angekündigt möchte ich diese Woche ein wenig weiter über die verschiedenen PHP Template-Engines Smarty, Twig, Mustache und RainTPL schreiben.

Der Fokus soll Heute auf dem Entwickler-Aufwand liegen! Denn wer macht sich schon gerne mehr arbeit als nötig?

Fangen wir also direkt an – Die vorgestellten Systeme setzen unterschiedlich viel Kenntnis zum Thema PHP und OOP voraus: Die einfachsten Installationen bieten uns Smarty, RainTPL und Mustache, wobei Mustache (je nach Nutzung) schon einen gewissen Kenntnisstand benötigt – Twig ist womöglich das umfangreichste, aber auch das aufwändigste der vier System und kann bei Neulingen auf Schwierigkeiten oder Verständnisprobleme stoßen.

Folgendermaßen werden die Template-Engines benutzt:

Smarty

Smarty benötigt PHP 5.2 oder höher und benötigt ganze vier Ordner:

• template – Innerhalb dieses Ordners liegen die Template-Dateien.
• compile – Hier liegen die in PHP-Code umgeschriebenen Templates.
• config – Hier liegen die Konfigurations-Dateien von Smarty.
• cache – Hier liegen die Cache-Dateien von Smarty.

Die Template-Engine wird folgendermaßen eingebunden und genutzt:

require_once('pfad/nach/Smarty.class.php');

// Neue Smarty Instanz erzeugen.
$smarty = new Smarty;

// Optional: Pfade für Templates, Konfiguration und Caching bestimmen.
$smarty->setTemplateDir('templates/');
$smarty->setCompileDir('templates_c/');
$smarty->setConfigDir('config/');
$smarty->setCacheDir('cache/');

// Variable zuweisen
$smarty->assign('titel', 'Welt');
$smarty->assign('planeten', array('Mars', 'Saturn', 'Venus'));

// Template rendern/darstellen.
$smarty->display('template.tpl');

Twig

Wie weiter oben schon beschrieben ist Twig mit dem größten Entwickler-Aufwand verbunden – Bietet allerdings eine enorme Feature-Bandbreite inklusive einer C-Extension die dieser Template-Engine einen enormen Performance-Schub gibt. Das System setzt mindestens PHP 5.2.4 voraus und lässt sich durch die hohe Modularität schnell und einfach erweitern.

require_once '/pfad/zu/Twig/Autoloader.php';

// Autoloader registrieren.
Twig_Autoloader::register();

// Komponente zur String-Verarbeitung laden.
$loader = new Twig_Loader_String;

// Template-Engine Umgebung vorbereiten, der zweite Parameter ist optional.
$twig = new Twig_Environment($loader, array(
    'cache' => 'pfad/zum/cache'
));

// String rendern.
echo $twig->render('Hallo {{ titel }}! (...)', array('titel' => 'Welt'));

// Oder eine komplette Datei, dann allerdings mit der "Filesystem"-Komponente.
$loader = new Twig_Loader_Filesystem('/pfad/zu/templates');
$twig = new Twig_Environment($loader);
echo $twig->render('index.html', array(
        'titel' => 'Welt', 
        'planeten' => array('Mars', 'Saturn', 'Venus')
    ));

Mustache

Mustache bietet, ähnliche wie Twig, verschiedene Komponenten zum Laden von Templates an, ist im Gegensatz dazu allerdings äußerst schlank verpackt und verlangt nicht viel vom Anwender. Weiterer Vorteil: Die notwendig saubere Datenaufbereitung erlaubt es uns sämtliche Daten sowohl in PHP als auch Javascript (usw.) zu verarbeiten… Praktisch, das Mustache für viele Sprachen verfügbar ist 😉 Das verfolgte Ziel ist einfach: Möglichst wenig Syntax – Das hält die Lernkurve sehr niedrig und erlaubt einen schnellen Einstieg.
Mustache benötigt mindestens PHP 5.2!

require '/pfad/zu/Mustache/Autoloader.php';

// Autoloader wird registriert.
Mustache_Autoloader::register();

// Mustache Instanz erstellen.
$m = new Mustache_Engine;

// Rendern eines Strings.
echo $m->render('Hallo {{titel}}', array('titel' => 'Welt'));

// Wie bei Twig ist es möglich verschiedene Loader-Komponenten und sonstige Parameter zu setzen.
$m = new Mustache_Engine(array(
    'cache' => 'pfad/zu/cache',
    'loader' => new Mustache_Loader_FilesystemLoader('pfad/zu/templates')
));

// Rendern einer Datei (index.mustache).
echo $m->render('index', array(
    'titel' => 'Welt',
    'planeten' => array(
        'name' => 'Mars',
        'name' => 'Saturn',
        'name' => 'Venus'
    )
));

Wie weiter oben schon beschrieben lässt sich Mustache aber auch noch ganz anders nutzen – Statt einfachem „Wert zuweisen“ können wir auch so genannte View-Klassen übergeben und mit Lambda Funktionen arbeiten. Twig verfügt auch über diese Möglichkeit, allerdings habe ich dazu kein schönes Beispiel gefunden (Beispielcode für Mustache von github):

class Chris {
    public $name  = "Chris";
    public $value = 10000;

    public function taxed_value() {
        return $this->value - ($this->value * 0.4);
    }

    public $in_ca = true;
}

// ...

$m = new Mustache_Engine;
$chris = new Chris;
echo $m->render('template', $chris);

Das entsprechende Template dazu:

Hello {{name}}
You have just won ${{value}}!
{{#in_ca}}
Well, ${{taxed_value}}, after taxes.
{{/in_ca}}

RainTPL

Das eher unbekannte RainTPL ist sehr schlank und schlicht gehalten und punktet mit einer einfachen Syntax und niedriger Speicherauslastung. Die unterstützte PHP Version ist nicht ganz klar, auf der Homepage heißt es lediglich „PHP5 kompatibel“. Es gibt außerdem einige selbst geschriebene Benchmarks, doch diese möchte ich mir für nächste Woche etwas genauer ansehen.

include "pfad/zu/rain.tpl.class.php";

// Template und Cache Verzeichnis setzen (optional).
raintpl::$tpl_dir = "tpl/";
raintpl::$cache_dir = "tmp/";

// Eine neue Instanz erstellen.
$tpl = new raintpl;

// Ein paar Daten zuweisen.
$tpl->assign(array(
    'titel' => 'Welt',
    'planeten' => array('Mars', 'Saturn', 'Venus')
));

// Template rendern und ausgeben.
$tpl->draw('index');

Nun, das war es vorerst für diese Woche.
Ich weiß, ich weiß… ich wollte eigentlich noch auf die Performance und Speicherauslastung eingehen doch dazu reicht die Zeit leider nicht – Stattdessen genehmige ich mir noch eine Woche um ein paar (eigene) Tests mit den verschiedenen Systemen zu machen!

In diesem Sinne wünsche ich euch da draußen eine angenehme und entspannte Rest-Woche!