N'oubliez pas que PHP est au départ un moteur de templates pour Perl. Aujourd'hui on a réalisé des surcouches ce qui d'un point de vue historique est une hérésie (et ce n'est pas Rasmus qui me contredira, je vous assure...).
Que ce soit clair, l'usage d'un moteur de template en tant que surcouche PHP (tel que Smarty, PHPLib, etc...) a deux avantages :
- séparation du code et de la présentation.
- possibilité de passer d'un langage à un autre pour peu que le moteur soit implémenté dans les deux langages (par exemple s'il existe une version de Smarty pour Perl, on peut donc utiliser un template Smarty dans un script Perl).
Le premier point est indéniable, le second a un intérêt très discutable : franchement vos templates vous les utilisez pour plusieurs sites réalisés dans plusieurs langages ? De plus je n'ai pas connaissance d'un moteur de template implémenté dans plusieurs langages, et tombe donc à l'eau de fait.
Par contre, l'ajout d'une surcouche implique forcément une perte notable de performances.
Alors pourquoi ne pas utiliser PHP en tant que tel ?
Je vous présente donc le plus petit moteur de template en PHP implémentant :
- appels de fonctions
- affichage de variables
- blocs conditionnels
- boucles
Le code| Code: |
class Template { var $file; var $vars = array(); function Template($tpl) { $this->file = $tpl; } function start() { ob_start(); } function set($var, $val) { $this->vars[$var] = $val; } function display($contents = null) { foreach ($this->vars as $var => $val) $$var = $val; if ($contents === null) { $contents = ob_get_contents(); ob_end_clean(); } include $this->file; } } |
La syntaxe des templates
Variable :
Boucle : | Code: |
<?foreach($tableau as $element):?> ... <?endforeach?> |
Condition : | Code: |
<?if($condition):?> ... <?endif?> |
Appel de fonction : | Code: |
<?fonction(paramètres)?> |
Utilisation du moteur
Instanciation : | Code: |
$template =& new Template("Fichier Template"); |
Ajout d'une variable : | Code: |
$template->set("nom", valeur); |
Utilisation en mode output_buffering : | Code: |
$template->start(); ... $template->display(); |
Dans ce mode, la variable "contents" sera automatiquement définie par la valeur du buffer au moment de l'appel à display().
Utilisation en mode normal : | Code: |
$template->display("Contenu"); |
Dans ce mode la variable "contents" sera automatiquement définie à la valeur du paramètre.
Exemple
Fichier template :
| Code: |
<html> <head> <title><?=$title?></title> </head> <body> <p><?=$contents?></p> <ul> <?foreach($animaux as $animal):?> <li><?=$animal?> <?endforeach?> </ul> </body> |
Utilisation en mode output_buffering :
| Code: |
$template =& new Template("MonTemplate.tpl"); $template->set('title', 'Mon Titre'); $template->set('animaux', array('chien', 'chat', 'souris')); $template->start(); echo "Contenu de ma page"; $template->display(); |
Utilisation équivalente en mode direct :
| Code: |
$template =& new Template("MonTemplate.tpl"); $template->set('title', 'Mon Titre'); $template->set('animaux', array('chien', 'chat', 'souris')); $template->display("Contenu de ma page"); |
Résultat :
| Code: |
<html> <head> <title>Mon titre</title> </head> <body> <p>Contenu de ma page</p> <ul> <li>chien <li>chat <li>souris </ul> </body> |
Conclusion
Vous allez me dire : "mais c'est que du php ton truc ?". Ben oui... PHP offre tous les outils nécessaires pour séparer la présentation du code de façon efficace, et lisible. Pour cela il suffit d'utiliser les syntaxes abrégées (attention aux prologues XML avec les short_tags), et d'avoir de bonnes habitudes. La définition d'une classe simple pour "cadrer" un peu cette utilisation est une bonne habitude car elle restreint les variables accessibles à celle que l'on a définies (pas de vilaines globales). On ne souffre aucune perte de performance, et il suffit de créer une classe fille pour ajouter des fonctionnalités (typiquement : mise en cache, compression gzip).