Ce moteur est un logiciel libre. Vous pouvez la redistribuer ou la modifier suivant les termes de la Licence Générale Publique Limitée GNU telle que publiée par la Free Software Foundation (version 2.1).
Ce script est distribuée dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE : sans même la garantie implicite de COMMERCIALISABILITé ou d'ADéQUATION à UN OBJECTIF PARTICULIER. Consultez la Licence Générale Publique Limitée pour plus de détails.
Vous devriez avoir reçu une copie de la Licence Générale Publique Limitée GNU avec ce script. Si ce n'est pas le cas, écrivez à :
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
Pour toute demande d'information au sujet du moteur "OpenTPL", vous pouvez contacter son auteur : michael - dot - hurni - at - gmail - dot - com
Les moteurs de template ont souvent été critiqués car ils imposaient l'apprentissage d'un nouveau langage, parfois fastidieux. La réalité n'est pas ce problème d'apprentissage, mais bien le but réel de l'utilisation d'un moteur de template.
Les bonnes moeurs souhaiteraient une séparation entre la logique métier et la logique présentation (ce qui ne correspond en réalité pas toujours à la séparation du code HTML et du code PHP).
Il ne tient qu'à vous d'utiliser ce moteur à bon escient. Nous rappelons qu' OpenTPL est un moteur efficace en terme de performances mais aussi en possibilités. Nous évitons au maximum les fonctionnalités superflues qui rendent les temps de génération de page parfois énormes.
OpenTPL offre les fonctionnalités de base, comme la gestion de variables, de blocs (ou régions) répétés, de blocs conditionnels. Les fonctionnalités comme l'inclusion de fichier, l'interprétation directe de résultat Mysql, ou encore les modificateurs de variables pour la partie template sont des fonctionnalités additionnelles destinées à rendre l'utilisation du moteur plus agréable.
Très soucieux des performances de rendu, nous avons rendu possible la désactivation de certaines fonctionnalités citées ci-dessus. D'autre part, la combinaison de ce moteur avec un système de cache dédié (livré avec ce moteur) vient à améliorer encore les performances de vos scripts.
D'après le principe général du moteur de template, il devient utile de pouvoir communiquer les informations de couche applicative vers la couche présentation. Nous utiliserons donc les variables. Cet aspect est la base d'un moteur de template. Aussi, dans OpenTPL, nous avons particulièrement soigné les performances mais aussi les possibilités qui s'offrent à vous dans ce domaine.
Nous allons dans un premier temps réaliser un script php affichant une citation au hasard.
<?php $liste = Array( "Comprendre, c'est pardonner", "La beauté est une contradiction voilée", "Le bonheur n'est jamais immobile"); $citation = array_rand($liste); echo $citation; ?>
Nous devons à présent créer le code html qui va accueillir la variable php $citation et la mettre en forme (en rouge gras par exemple). Les variables sont notées sous la forme {nom_de_la_variable}. Le code qui suit correspond au "template" (ou gabarit HTML) de notre système. Nous allons l'enregistrer sous "template/gabarit1.tpl"
<html>
<body>
<span style="color: #ff0000; font-weight: bold" >
Citation au hasard: {citation}
</span>
</body>
</html>
Il est temps maintenant d'instancier le moteur OpenTPL et de lui indiquer quelle variables qui sont à transmettre au gabarit
<?php
// on inclut la classe OpenTPL
include_once 'class.OpenTPL.php';
// On créé un objet OpenTPL
// On spécifie en argument le nom du fichier gabarit
$view = new OpenTPL("template/gabarit1.tpl");
$liste = Array(
"Comprendre, c'est pardonner",
"La beauté est une contradiction voilée",
"Le bonheur n'est jamais immobile");
$citation = array_rand($liste);
// on assigne à la variable citation du gabarit la variable
// $citation issue du code php.
$view -> assign("citation",$citation);
// On appel la fonction display() qui va traiter le gabarit
// et remplacer l'ensemble des variables par leur valeur
$view -> display();
?>Ce qui affichera par exemple :
<html> <body> <span style="color: #ff0000; font-weight: bold" > Citation au hasard: La beauté est une contradiction voilée </span> </body> </html>
Cet exemple nous à appris à instancier la class OpenTPL et à utilise une fonction de base : les variables et leur assignation.
L'exemple précédent nous a appris à assigner des variables simples. Il devient parfois rébarbatif d'assigner chacune des variables, une à une. Nous verrons ainsi différentes méthodes pour assigner vos différentes variables. Voici une méthode d'assignation vous permettant d'assigner plusieures variables en une fois : l'assignation par tableau associatif PHP (Array).
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$liste = Array(
"citation1" => "Comprendre, c'est pardonner",
"citation2" => "La beauté est une contradiction voilée",
"citation3" => "Le bonheur n'est jamais immobile");
// on assign en une fois l'ensemble des citations
$view -> assign($citation);
$view -> display();
?>Exemple de template correspondant :
<html>
<body>
<span style="color: #ff0000; font-weight: bold" >
Citation 1: {citation1}
</span>
<span style="color: #00ff00; font-weight: bold" >
Citation 2: {citation2}
</span>
<span style="color: #0000ff; font-weight: bold" >
Citation 3: {citation3}
</span>
</body>
</html>Il est possible d'aller encore plus loin avec l'assignation de variable : l'utilisation de variables référencées par une clé (similaire au Array php). Nous les appelerons des variable-objets ou variable-tableaux.
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$citation = Array(
"lundi" => "Comprendre, c'est pardonner",
"mardi" => "La beauté est une contradiction voilée",
"mercredi" => "Le bonheur n'est jamais immobile");
$view -> assign("citation",$citation);
$view -> display();
?>Exemple de template correspondant :
Citation du lundi: {citation.lundi}
Citation du mardi: {citation.mardi}
Citation du mercredi: {citation.mercredi}
Vous pouvez définir directement des variables de template référencées. Les variables référencées sont notées sous la forme nom_tableau.nom_clé au sein du template. La notation nom_tableau[nom_clé] n'est pour l'instant possible que pour l'assignation mais correspond en réalité à la même variable dans le template.
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$view -> assign("citation.lundi","Comprendre, c'est pardonner");
// Autre notation
$view -> assign("citation[lundi]","Comprendre, c'est pardonner");
// Le niveau de profondeur est illimité…
$view -> assign("citation.lundi.matin","Comprendre, c'est pardonner");
$view -> assign("citation[lundi][matin]","Comprendre, c'est pardonner");
$view -> display();
?>Il est également possible d'insérer directement un tableau complet (référencé par des clé non numérique) au moteur.
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$citation = Array(
"lundi" => Array(
"matin" => "Comprendre, c'est pardonner",
"midi" => "La beauté est une contradiction voilée"),
"mardi" => Array(
"matin" => "Le bonheur n'est jamais immobile")
);
$view -> assign($citation);
$view -> display();
?>Exemple de gabarit correspondant :
Citation du lundi matin: {citation.lundi.matin}Bien que parfois illisible, le mélange complet de l'ensemble de ces techniques d'assignations et de notations est possible pour ce même exemple de template. Dans un souci de propreté, on évitera ces mélanges rendant la lecture du code assez fastidieuse.
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$citation = Array(
"lundi.matin" => "Comprendre, c'est pardonner",
"lundi" => Array(
"midi" => "La beauté est une contradiction voilée"),
);
$view -> assign($citation);
$view -> assign("citation[mardi].matin","Le bonheur n'est jamais immobile");
$view -> display();
?>Il est possible de définir au sein du template des modificateurs de variables. Ces modificateurs vont influer sur l'affichage de la variable. Ils sont appelés de la manière suivante : {variable|modificateur}. Prenons l'exemple suivant pour illustrer le fonctionnement des modificateurs de variables.
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$view -> assign("phrase","ceci est une phrase d'exemple");
$view -> display();
?>{phrase|uppercase}Ceci affichera dans le code HTML
CECI EST UNE PHRASE D'EXEMPLE
Les modificateurs peuvent être multiple et sont appliqués dans l'ordre où il on été définis.
{phrase|ucwords|escape}Ceci affichera dans le code HTML
Ceci Est Une Phrase D\'exemple
Des paramètres (ou arguments) pour certains modificateurs sont existants. Les paramètres sont à déclarer après le nom du modificateur (séparés par un espace)
{phrase|cut 16}Ceci affichera une version troncé au mieux de notre phrase dans le code HTML
ceci est une…
Il est également possible de spécifier plusieurs paramètres.
{phrase|cut 16 strict}Ceci va afficher dans le code HTML
ceci est une phr…
| Nom | Paramètres | Effet sur la variable |
|---|---|---|
| uppercase | converti tous les caractères alphabétiques en majuscules | |
| lowercase | converti tous les caractères alphabétiques en minuscules | |
| ucfirst | Converti le premier caractère d'une chaîne en majuscule | |
| ucwords | Converti le premier caractère de chaque mot en majuscule | |
| wordwrap | (int) number | Retour à la ligne tous les x (number) caractères. |
| cut | (int) number [,"strict"] | Coupe une chaîne à la fin d'un mot à x (nomber) (maximum) caractères. Le paramètre "strict" permet d'ignorer le maintient de mot entier |
| md5 | Converti la variable en sa signature md5 | |
| nl2br | Converti les retours à la ligne en <br/> | |
| sprintf | (string) format | Formate une chaîne selon le format spécifié |
| date | (string) format | Formate un timestamp selon le format spécifié |
| datefr | (string) format | Formate un timestamp en français selon le format spécifié |
| htmlentities | Convertit tous les caractères éligibles en entités HTML | |
| escape | Echape les simples et double quottes. | |
| accent_escape | Convertit tous les caractères accentués en entités HTML | |
| utf8 | Convertit une chaîne ISO-8859-1 en UTF-8 |
Avec les variables, les blocs de code (au sein des fichiers template) sont une autre fonction essentielle de tout moteur de template.
Pour illustrer le fonctionnement des bloc de code, nous allons imaginer l'exemple suivant : un site Internet disposé en 2 colonnes, sur la colonne de gauche, 3 cadres présentant le sommaire, les statistiques de connexion ainsi que la liste des sites partenaires. Au niveau codage, ces trois blocs possèdent la même structure : un titre et un contenu. Au lieu de répéter inutilement ces trois cadres au sein du moteur de template, nous allons les définir en temps que blocs (cadre_gauche).
[cadre_gauche]
<div class="cadre_gauche">
<div class="titre">{titre}</div>
{contenu}
</div>
[/cadre_gauche]Nous allons assigner maintenant les variables titre et contenu,
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$titre = "sommaire";
$contenu = "<ul><li><a href=\"accueil.html\">Accueil</a></li>\n";
$contenu .= "<li><a href=\"page1.html\">Page1</a></li>\n";
$contenu .= "<li><a href=\"page2.html\">Page2</a></li></ul>";
$view -> assign("titre",$titre);
$view -> assign("contenu",$contenu);
$view -> display();
?>
La méthode $view -> bloc("cadre_gauche") va retourner le code HTML suivant
<div class="cadre_gauche"> <div class="titre">Sommaire</div> <ul><li><a href="accueil.html">Accueil</a></li> <li><a href="page1.html">Page1</a></li> <li><a href="page2.html">Page2</a></li></ul> </div>
On pourrait ainsi imaginer la boucle suivante
<?php
…
$gauche = Array(
Array("titre" => "sommaire","contenu" => "..."),
Array("titre" => "sommaire","contenu" => "..."),
Array("titre" => "sommaire","contenu" => "..."));
foreach($gauche as $cadre) {
$view -> assign($cadre);
$codeHtmlGauche .= $view -> bloc("cadre_gauche",NO_ASSIGN);
}
?>Il est à présent impératif de remplacer dans le template le bloc cadre_gauche par son contenu HTML
<?php … $view -> bloc["cadre_gauche"] = $codeHtmlGauche; echo $view -> render(); ?>
Nous remarquons par ailleurs l'argument NO_ASSIGN placé dans la méthode bloc() qui sert à empêcher le remplacement automatique du bloc par sont contenu (dans le cas contraire, les blocs suivants seraient introuvables pour les cadre suivants)
Il est également possible d'affecter n'importe qu'elle type de valeur à la variable $view -> bloc["cadre_gauche"]. Si celle-ci n'est pas affectée, le bloc ne s'affichera pas.
Cette méthode d'assignation étant très fastidieuse elle à été automatisé par la méthode repeat(). Cette méthode à toute fois été conservée s'avérant parfois utile dans certaine situation.
Cette méthode à été mise en place dans le but de simplifier la déclaration des blocs simples (ou "régions répétées").
Nous allons réutiliser le même exemple que celui cité précédemment. Nous avons besoin de légèrement modifier notre template, en effet les variables doivent être référencées de la manière suivante {nom_du_bloc.nom_de_la_variable}
[cadre_gauche]
<div class="cadre_gauche">
<div class="titre">{cadre_gauche.titre|ucfirst}</div>
{cadre_gauche.contenu}
</div>
[/cadre_gauche]La déclaration du groupe de blocs est ainsi largement simplifié.
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$gauche = Array(
Array("titre" => "sommaire","contenu" => "..."),
Array("titre" => "statistiques","contenu" => "..."),
Array("titre" => "partenaires","contenu" => "..."));
$view -> repeat("cadre_gauche",$gauche);
$view -> display();
?>D'autre part, des paramètres sont crées et accessibles directement depuis le template. Il sont nommés de la façon suivante : {[nom_du_bloc]._[nom_du_paramètre]}. Nous allons légèrement modifier le template précédent, pour afficher quelque uns de ces paramètres.
[cadre_gauche]
<div class="cadre_gauche">
<div class="titre">{cadre_gauche.titre|ucfirst}</div>
Numero du bloc : {cadre_gauche._num}<br/>
Nombre de bloc : {cadre_gauche._count}
</div>
[/cadre_gauche]Ce code affichera
<div class="cadre_gauche"> <div class="titre">Sommaire</div> Numero du bloc : 1<br/> Nombre de bloc : 3 </div> <div class="cadre_gauche"> <div class="titre">Statistiques</div> Numero du bloc : 2<br/> Nombre de bloc : 3 </div> <div class="cadre_gauche"> <div class="titre">Partenaires</div> Numero du bloc : 3<br/> Nombre de bloc : 3 </div>
D'autre paramètres sont créés, ils contiennent des valeurs booléennes (vrai ou faux) nous verrons plus tard comment les utiliser
| Nom | Type | Retour |
|---|---|---|
| _num | entier | Numéro de la ligne courante |
| _count | entier | Nombre de ligne total |
| _odd | bool | vrai si la ligne est impaire |
| _even | bool | vrai si la ligne est paire |
| _last | bool | vrai si la ligne courante est la dernière ligne |
| _first | bool | vrai si la ligne courante est la première ligne |
Nous avons vu dans l'exemple précédent qu'il était possible de masquer ou d'afficher un bloc (à l'aide du script PHP). Nous verrons dans cette partie comment rendre conditionnel, l'affichage de ces blocs par le biais de conditions définies au sein même du template.
Les blocs conditionnels se présentent de la manière suivante :
[if condition] Code à afficher si condition vraie [/if]
La clause 'else' (sinon) est possible
[if condition] Code à afficher si condition vraie [else] Code à afficher si condition fausse [/if]
Les conditions peuvent contenir :
| Opérateur | Signification |
|---|---|
| =, ==, eq | égal à |
| <>, !=, neq | différent de |
| < , lt | strictement supérieur à |
| > , gt | strictement inférieur à |
| <= , lte | inférieur ou égal à |
| >= , gte | supérieur ou égal à |
| and, AND, && | opérateur logique ET |
| or, OR, || | opérateur logique OU |
| ! | Inverse la condition qui le précède |
Test booléen simple
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$view -> assign("affiche",true);
$view -> assign("affiche_suite",false);
$view -> assign("affiche_fin",true);
$view -> display();
?>[if affiche]Ce texte sera affiché[/if] [if affiche_suite] Celui la non car affiche_suite vaut false [else] Celui là quand même [/if] [if !affiche_fin] Ce texte ne sera pas affiché à cause de l'inverseur '!' [/if]
Comparaisons de variables combinaison de conditions
<?php
include_once 'class.OpenTPL.php';
$view = new OpenTPL("template/gabarit1.tpl");
$view -> assign("nombre_article",1);
$view -> assign("nombre_page",5);
$view -> assign("affiche",true);
$view -> display();
?>Il y a {nombre_article} article[if nombre_article > 1]s[/if]
Il y a {nombre_page} page[if nombre_page > 1]s[/if]
Il y a [if nombre_page > nombre_article]
plus
[else]
moin
[/if] de page que d'articles
<!-- Combinaison de condition -->
[if (nombre_page > nombre_article) && !affiche]
Il y a plus de page que d'article mais ce texte ne sera pas affiché
[/if]Vous savez à présent comment utiliser les paramètres _odd, _even, _last et _first issus des blocs (ou régions) répétés. Dans cet exemple, la balise <hr/> sera afficher après chaque news, sauf après la dernière
[news]
<div class="news"><h1>{news.titre|uppercase}</h1>
{news.content}
</div>
[if !news._last]<hr/>[/if]
[/news]Il est possible de séparer vos templates en plusieurs fichiers et de les inclure au sein de vos fichiers de template.
{include "fichier.tpl"}Le code de ce fichier inclus sera interpréter par le moteur de template. Les variables, blocs, etc.. seront donc interprétés. Il vous est possible d'inclure des fichiers au sein des fichiers inclus.
L'exemple ci-dessus montre comment inclure le fichier "fichier.tpl". Il est possible d'utiliser un nom de variable comme nom de fichier.
<?php
$view -> assign("header","header.tpl");
?>{include header}Comme pour les variables classiques, l'utilisation de modificateurs est possible.
{include source.html|htmlentities}Vous pouvez également inclure des pages php, qui seront executés (ou interprétés) avant d'être "ajoutés" au template principal.
{include "info.php"}Afin d'aller encore plus vite, les tâches les plus courantes ont été simplifiées. La lecture et la mise en forme d'un résultat Mysql en sont un excellent exemple. Pour illustrer sont fonctionnement, imaginons par exemple la base de données suivante représentant une classe d'élèves. Celle-ci est composée de trois champs.
CREATE DATABASE `classe` ; CREATE TABLE `eleves` ( `identifiant` VARCHAR( 255 ) NOT NULL , `nom` VARCHAR( 255 ) NOT NULL , `prenom` VARCHAR( 255 ) NOT NULL , PRIMARY KEY ( `identifiant` ) ) ENGINE = innodb;
Ajoutons à présent quelques élèves à notre base de données
INSERT INTO `eleves` (`identifiant`, `nom` ,`prenom`)
VALUES
('michael.h', 'horthis', 'michael'),
('aurelien.e', 'epouillard', 'aurelien'),
('regis.b', 'bolderas', 'regis');Imaginons le template suivant, présentant sous forme de tableau HTML la liste des élèves de la classe que nous venons de créer.
<html>
<head><title>Classe</title></head>
<body>
Voici les {eleve._count} élèves de la classe <br/>
<table>
<tr><th>numero</th><th>nom</th><th>prenom</th></tr>
[eleve]
[if eleve._even]
<tr bgcolor="gray">
[else]
<tr bgcolor="white">
[/if]
<td>{eleve._num}</td>
<td>{eleve.nom|uppercase}</td>
<td>{eleve.prenom|ucfirst}</td>
</tr>
[/eleve]
</table>
</body>
</html>Rappelons que la condition eleve._even est vrai lorsque la ligne est impaire et inversement lorsque la ligne est paire. Les variables {eleve._count} et {eleve._num} contiennent respectivement le nombre de ligne et le numéro de la ligne courante.
Nous allons à présent associer la table Mysql au bloc "eleve".
<?php
include_once "class.OpenTPL.php";
$view = new OpenTPL("template/gabarit1.tpl");
$connexion = mysql_connect("localhost","root","");
mysql_select_db("ecole",$connexion);
$query = "SELECT * FROM eleves";
$result = mysql_query($query,$connexion);
$view -> repeat_mysql_result("eleve",$result);
$view -> display();
?>Voici le code source HTML qui sera produit.
<html> <head><title>Classe</title></head> <body> Voici les 3 élèves de la classe <br/> <table> <tr><th>numero</th><th>nom</th><th>prenom</th></tr> <tr bgcolor="gray"> <td>1</td> <td>HORTHIS</td> <td>Michael</td> </tr> <tr bgcolor="white"> <td>2</td> <td>EPOUILLARD</td> <td>Aurelien</td> </tr> <tr bgcolor="gray"> <td>3</td> <td>BOLDERAS</td> <td>Regis</td> </tr> </table> </body> </html>
Une autre notation consiste à renseigner directement la requête à exécuter. L'effets est le même que dans l'exemple présenté ci-dessus.
<?php
$view -> repeat_mysql_query("eleve","SELECT * FROM eleves",$connexion);
?>Note : le paramètre $connexion est optionnel, il est utile lorsque vous utiliser plusieurs connexions Mysql différentes.
Pour mettre en cache un fichier complet, utilisons l'instruction suivante :
<?php $view -> cache(3600); ?>
Cette instruction à deux effets. Elle instancie dans un premier temps la mise en cache du code qui va suivre. Elle recherche un cache existant de la page courante inférieur à une durée de 3600 secondes (1 heure) et renvoie true le cas échéant.
La méthode getCache() retourne le contenu de la dernière mise en cache.
La methode sendCache() est similaire à getCache mais affiche le contenu du cache au lieu de le retourner et arrete le script php (le code qui suis cette instruction n'a donc aucune incidance)
La méthode setCache() indique la fin de mise en cache. On l'utilisera de préférence après les dernieres assignations de valeurs. (Les assignations suivantes n'étant pas prises en compte).
Voici un exemple de mise en cache
<?php
include_once "class.OpenTPL.php";
$view = new OpenTPL("template/gabarit1.tpl");
if($view -> cache(3600)) $view -> sendCache();
$connexion = mysql_connect("localhost","root","");
mysql_select_db("ecole",$connexion);
$query = "SELECT * FROM eleves";
$result = mysql_query($query,$connexion);
$view -> repeat_mysql_result("eleve",$result);
$view -> display();
$view -> setCache();
?>Le nom référence du fichier de cache est calculé à partir de l'url de la page ainsi que des valeurs $_GET envoyées à celle-ci. Il est possible de personnaliser ce nom référence à l'aide de la méthode setCacheName. Cette méthode doit être utiliser avant la méthode cache().
<?php
$view -> setCacheName("mon_cache");
?>On peut également imaginer un cache partiel, n'enregistrant pas certaines assignations. Voici un exemple d'implémentation.
Nous allons dans un premier temps maintenir les variables non définies à l'aide de la variable $view -> config -> keep_unassigned_vars (fixée à true). Nous allons ensuite remplacer le contenu HTML du template par le contenu du cache si ce dernier existe (grace à la methode loadCache).
Le cache devrait textuellement contenir la chaîne {nombre_visiteur} celle-ci n'étant pas définie avant la mise en cache et n'étant pas supprimée grâce à la propriété $view -> config -> keep_unassigned_vars.
Si le cache est expiré ou inexistant, on assigne les valeurs à mettre en cache.
<?php
include_once "class.OpenTPL.php";
include_once "stat.php"; // renseigne la variable $nombre_de_visiteur
$view = new OpenTPL("template/gabarit1.tpl");
$view -> config -> keep_unassigned_vars = true;
if($view -> cache(3600)) $view -> loadCache();
else {
// le cache est expiré
$connexion = mysql_connect("localhost","root","");
mysql_select_db("ecole",$connexion);
$query = "SELECT * FROM eleves";
$result = mysql_query($query,$connexion);
$view -> repeat_mysql_result("eleve",$result);
$view -> setCache();
}
// Après avoir terminer la mise en cache, on assigne les valeurs non 'cachées'
$view -> config -> keep_unassigned_vars = false; // optionnel
$view -> assign("nombre_visiteur",$nombre_de_visiteur);
$view -> display();
?>Afin d'optimiser au mieux le contenu de votre cache, il est possible de compresser ce dernier au format GZ (avec encodage compatible gzip).
<?php
include_once "class.OpenTPL.php";
$view = new OpenTPL("template/gabarit1.tpl");
if($view -> cache(3600,GZ_COMPRESSION)) $view -> sendCache();
$view -> assign("time",time());
$view -> display();
$view -> setCache();
?>Ce script va utiliser la compression GZ.
La methode sendCache() va renvoyer le code au format GZ en incluant l'entête "Content-Encoding:gzip" si le client accepte ce type de transfert ou décompresser le contenu du cache avant de l'envoyer le cas échéant.
Vous pouvez également forcer la décompression :
<?php if($view -> cache(3600,GZ_COMPRESSION)) $view -> sendCache(NO_GZ); ?>
Dans la même situation, la méthode getCache() renverrait le contenu du cache décompresser dans le cas ou ce dernier utiliserait la compression GZ.
Le modificateur de variables "cache" peut s'appliquer aux variables de type 'include', afin de placer le contenu de ces dernières dans un cache.
{include info.php|cache}Des paramètres permettent de modifier le comportement de ce modificateur
Cache d'une heure {include info.php|cache 3600}
Cache stocké en Gzip {include info.php|cache gz}
Cache de 30 minutes, stocké en Gzip {include info.php|cache 1800 gz}La compression Gzip du cache permet d'économiser de l'espace disque. Il réduit néanmoins les performances (pour les fichiers inclus) due au processus automatique de décompression.