Initiation Smarty

Initiation aux templates en PHP avec Smarty
par Eric POMMEREAU

Date de publication : 15 dcembre 2006 Dernire mise jour : 5 novembre 2008
Cet article pour but d'initier le lecteur l'utilisation des templates en PHP avec le moteur de template Smarty. Une autre ide, sous-jacente, est de convaincre de l'intrt d'utiliser un systme de template dans les dveloppements PHP. Il ne s'agit en aucun cas ici de vous en prsenter toutes les fonctionnalits, mais de vous donner un aperu de ce que l'on peut faire avec Smarty et comment on peut le faire. J'ai souhait rendre Smarty le plus accessible possible en mettant l'accent sur les aspects pratiques (exemples, recettes de code et debogage), j'espre que vous aurez plaisir me lire.
Initiation aux templates en PHP avec Smarty par Eric POMMEREAU
I - Introduction..............................................................................................................................................................3 I-A - Remerciements.............................................................................................................................................. 3 I-B - Prsentation................................................................................................................................................... 3 I-C - Avantages et inconvnients...........................................................................................................................3 I-C-1 - Inconvnients.........................................................................................................................................3 I-C-2 - Avantages..............................................................................................................................................4 I-D - Installer...........................................................................................................................................................4 I-E - Tester..............................................................................................................................................................4 II - Retour sur les mtas-structures............................................................................................................................ 6 II-A - Les tableaux..................................................................................................................................................6 II-A-1 - Les tableaux indexes............................................................................................................................6 II-A-2 - Les tableaux associatifs....................................................................................................................... 7 II-B - Les objets (syntaxe PHP5)........................................................................................................................... 7 II-C - Les fichiers xml (avex SimpleXml)............................................................................................................... 8 III - Les diffrentes variables Smarty.......................................................................................................................... 8 III-A - Les variables simples...................................................................................................................................8 III-B - Les tableaux.................................................................................................................................................9 III-B-1 - Les tableaux indexes...........................................................................................................................9 III-B-2 - Les tableaux associatifs.................................................................................................................... 10 III-B-3 - La fonction append()......................................................................................................................... 11 III-C - Les objets (syntaxe PHP5)........................................................................................................................ 11 III-D - Doc Smarty................................................................................................................................................ 12 III-E - Les variables internes................................................................................................................................ 13 IV - Les fonctions natives.......................................................................................................................................... 13 IV-A - Section....................................................................................................................................................... 13 IV-B - If, else, elseif............................................................................................................................................. 14 IV-C - Literal......................................................................................................................................................... 15 IV-D - Include....................................................................................................................................................... 16 V - Les fonctions utilisateur....................................................................................................................................... 16 V-A - Html_options............................................................................................................................................... 17 V-B - Cycle........................................................................................................................................................... 17 V-C - Mailto.......................................................................................................................................................... 18 V-D - Liste des fonctions utilisateur..................................................................................................................... 18 VI - Les modificateurs de variable............................................................................................................................ 18 VI-A - Upper......................................................................................................................................................... 18 VI-B - Default........................................................................................................................................................19 VI-C - Truncate..................................................................................................................................................... 19 VII - La console de debogage...................................................................................................................................20 VII-A - Appel dans le script PHP......................................................................................................................... 20 VII-B - Appel dans le template.............................................................................................................................20 VII-C - La console sans javascript....................................................................................................................... 20 VII-D - Paramtre dans l'url................................................................................................................................. 21 VIII - Recettes de code............................................................................................................................................. 21 VIII-A - Extraction Mysql vers tableau HTML...................................................................................................... 21 VIII-B - Utilisation d'une source xml.....................................................................................................................22 VIII-C - Production d'un fichier XML (fil rss)........................................................................................................ 24 IX - Ressources......................................................................................................................................................... 25 X - Conclusion........................................................................................................................................................... 25
-2Copyright 2008 - Eric POMMEREAU. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu' 3 ans de prison et jusqu' 300 000 E de dommages et intrts.
http://eric-pommereau.developpez.com/tutoriels/initiation-smarty/
I - Introduction I-A - Remerciements

Tout d'abord merci Yogui, responsable de la partie PHP chez DEVELOPPEZ.COM, qui a tout de suite rpondu prsent quand je l'ai contact pour la rdaction de cet article et qui a largement contribu l'amlioration du document d'origine. Merci galement GrandFather et titoumimi pour leurs contributions. Merci mes collgues: Sylvain JAMES, Jean-Luc MICHEL et Jean PEYROUX qui m'ont support dans la rdaction de cet article.
I-B - Prsentation
Smarty est un systme (ou moteur) de templates (entendez par template modle ou patron) utilisable avec PHP 4 ou PHP 5. Vous trouverez le site officiel ici Dans cet article les exemples sont prsents en PHP5
I-C - Avantages et inconvnients

L'intrt principal de Smarty rside dans la sparation du contenu et de la forme. Le concept d'un systme de template en gnral et de Smarty en particulier est de rserver les tches de production des donnes PHP et de mettre le code de prsentation (HTML en l'occurence) dans des 'templates' ou modles, un fichier qu l'on suffixera dans nos exemples par '.TPL' L'analyse des avantages et inconvnients de Smarty que je fais ci-aprs est le fruit des quelques expriences que j'ai eu avec ce moteur de templates. Je sais que tout le monde ne sera pas forcment d'accord avec les arguments avancs. Je vous encourage donc mettre Smarty en oeuvre et vous faire vous-mme une opinion... l'important est d'essayer pour se faire une ide.
I-C-1 - Inconvnients
L'utilisation du systme de template Smarty n'est pas la porte de tous, souvent le dveloppeur non chevronn sera rebut par son utilisation. Par exemple, il est frquent de ne pas trouver immdiatement la faon d'accder sa variable dans le template (mme avec un peu d'exprience d'ailleur)... ce qui peut tre un peu irritant. Mme avec une certaine exprience en PHP "traditionnel" (production et prsentation PHP mlangs), l'utilisation de Smarty n'est pas vidente, elle remet en cause nombre de choses dans la manire de dvelopper. L'apprentissage du langage de templates (ce que l'on retrouvera dans nos fichiers .TPL) est indispensable. Cela pourra aussi en refroidir plus d'un. Ainsi il faudra connatre les variables (et les innombrables faon d'y accder), les fonctions, le debogage. C'est ce que je me propose de vous expliquer.
I-C-2 - Avantages
Le premier avantage que je vois l'utilisation de Smarty est le gain de temps moyen/long terme. Si sa mise en place peut prendre un peu plus de temps, plus on avance dans un projet et plus Smarty apparat comme une vidence. Le second avantage est la plus grande facilit de travailler plusieurs. Prenez une quipe de dveloppement avec des niveaux disparates (c'est le cas o je travaille). Ce dcouplage mtier / prsentation permet potentiellement tout le monde de participer au dveloppement bien plus facilement que dans un dveloppement PHP plus traditionnel. Un autre avantage qui m'est particulirement cher (demandez donc mes collgues !!!) est qu'avec Smarty au final le code produit est plus "propre" et "comprhensible" .. au final mieux organis en particulier dans les gros projets. Bien sur il est possible de coder comme un cochon quand mme !!! Enfin, un systme de cache permet d'acclrer considrablement la vitesse des traitements (la page n'est pas systmatiquement recalcule). La dcision d'utiliser la gestion de cache est la charge du dveloppeur.
Vous l'aurez compris, en ce qui me concerne, je suis convaincu que Smarty est un outil de PRODUCTIVITE.
I-D - Installer
L'installation de Smarty ncessite peu de pr-requis: Un serveur web supportant PHP (apache ou IIS par exemple) Php version 4.0.6 ou version siprieure
Je vous encourage galement tlcharger (ou consulter) la documentation de Smarty qui est trs complte. L'tape suivante est de tlcharger les sources de Smarty et de les installer sur votre serveur (dans les exemples j'utilise le package WAMP). Attention l'archive contenant les sources de Smarty, tlchargeable sur ce site, est au format .tar.gz, procurez vous de quoi dcompresser ce type d'archive (par exemle 7zip). Une fois l'archive de Smarty rcupre, vous constaterez la prsence de plusieurs fichiers et rpertoires:
En fait pour dmarrer c'est simplement le rpertoire '/libs' qui nous intresse. Il contient les fichiers suivants:
Un conseil: placez les sources de Smarty dans un rpertoire en ayant l'esprit que vous pourrez utiliser ce systme de templates dans plusieurs projets, la racine de votre serveur web par exemple.
I-E - Tester
En premier lieu vous devez crer le fichier PHP qui aura pour objet de "piloter" Smarty (Inclusion de la librairie et instanciation de l'objet Smarty et affichage du template aprs compilation). test.php
// Inclusion de la librairie require_once('../Smarty/Smarty.class.php'); // Instanciation d'un l'objet Smarty $oSmarty = new Smarty(); // Affichage du template aprs compilation
test.php
$oSmarty->display('test.tpl');
L'tape suivante est de crer deux rpertoires (dans les exemples, ces deux rpertoires sont placs la racine du rpertoire contenant le fichier PHP): templates/ templates_c/
Ces deux rpertoires contiendront respectivement les fichiers templates (.TPL) et les fichiers compils. La prsence de ces deux rpertoires est obligatoire pour l'utilisation de Smarty. Vous avez le choix pour l'emplacement des rpertoires: L'emplacement explicite: Dans ce cas vous spcifiez vous-mme l'emplacement de ces deux rpertoires avec les deux proprits de l'objet Smarty: "template_dir" et "compile_dir" L'emplacement implicite: il s'agit simplement de crer ces deux rpertoires dans le rpertoire du script PHP qui s'occupe des manipulations Smarty (c'est la mthode que nous retiendrons pour les exemples)
Pour terminer notre premier test, nous allons crer un fichier "test.tpl" dans le rpertoire "templates/". C'est dans ce fichier que l'on retrouvera tout ce qui concerne l'affichage de notre page, savoir le HTML (ventuellement JAVASCRIPT et STYLE) et les instructions propres Smarty qui auront pour tche d'afficher les donnes produites dans le fichier PHP. En voici le contenu: test.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Test smarty</title> </head> <body> <h1>Test smarty</h1> </body> </html>
Pour la prvisualisation, lancez votre page "test.php". Vous devriez obtenir le rsultat suivant:
Page de test Nous allons ensuite tester le passage d'une variable (produite dans le fichier PHP) au template Smarty, dans le but d'afficher une chane de caractres dans notre page HTML. Avant de nous lancer dans l'criture du code sachez qu'il est ncessaire de respecter deux tapes: 1 2 Ct PHP: utilisation de la mthode assign() de l'objet Smarty pour affecter la variable Smarty la valeur de la variable PHP Ct TEMPLATE: Afficher la variable Smarty
test.php
<?php // Inclure la librairie smarty require_once('../smarty/Smarty.class.php');
test.php
// Instancier notre objet smarty $oSmarty = new Smarty(); // Affecter la valeur "Bonjour le monde" la varaible SMARTY 'hello_world' $oSmarty->assign('hello_world', 'Bonjour le monde');
// Provoque le rendu du template $oSmarty->display('test.tpl'); ?>
test.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html> <head> <title>Test smarty</title> </head> <body> <h1>Test smarty</h1>  <h2 color="red">{$hello_world}</h2> </body> </html>
Revenons en l'utilisation de la mthode assign() dans le fichier PHP. Cette mthode prend deux arguments: 1 2 Le nom de la variable "cible" que l'on utilisera dans le fichier template (c'est une chane de caractres) La variable ou la valeur PHP que l'on souhaite associer au premier argument(variable ou valeur)
Voi pour nos tests. Maintenant nous allons faire un bref retour sur les mtas-structures PHP (tabelaux, objets, fichiers xml -avec simpleXML-) que nous utiliserons par la suite.
II - Retour sur les mtas-structures

La matrise des tableaux (initialisation et accs aux valeurs) me parat un pr-requis indispensable pour utiliser Smarty dans de bonnes conditions.
II-A - Les tableaux

Nous allons revoir les deux principaux types de tableau que l'on utilise en PHP: les tableaux indexs et les tableaux associatifs (paire cl/valeur).
II-A-1 - Les tableaux indexes

L'utilisation la plus simple, chaque valeur ajoute au tableau est attribue un index que l'on utilisera pour accder la valeur.
$aMonTableauIndexe = array('Sylvain', 'Jean-Luc', 'Jean', 'Eric'); echo $aMonTableauIndexe[2]; // affiche 'Jean'
II-A-2 - Les tableaux associatifs

Pour ce qui est des tableau associatifs, la syntaxe est quelque peu diffrente puisque l'on doit associer chaque cl une valeur.
$aMonTableauAsscoiatif = array( 'Jean-Luc' => 'Michel', 'Jean' => 'Peyroux', 'Eric' => 'Pommereau', 'Sylvain' => 'James' ); echo $aMonTableauAsscoiatif['Jean']; // Affiche 'Peyroux'
II-B - Les objets (syntaxe PHP5)

Voici un petit exemple d'une classe reprsentant une personne. Nous allons voir, dans un premier temps, la dfinition de la classe, puis son utilisation. A la fin du script j'utilise la fonction print_r($objet) pour afficher le contenu de l'objet.
class personne { public $nom = ""; public $prenom = ""; public $aInfos = array(); public function __construct($sNom, $sPrenom) { $this->nom = $sNom; $this->prenom = $sPrenom; } public function add_info($sInfo) { array_push($this->aInfos, $sInfo); } } $oPersonne = new personne('POMMEREAU', 'Eric'); $oPersonne->add_info('Fixe: 01.53.71.29.14'); $oPersonne->add_info('Adresse: 122, rue du Chteau des Rentiers 75013 PARIS'); $oPersonne->add_info('Date de naissance: 23/11/1973'); printf( '<pre>%s</pre>', print_r($oPersonne, 1) ); /* AFFICHE ********************************** personne Object ( [nom] => POMMEREAU [prenom] => Eric [aInfos] => Array ( [0] => Fixe: 01.53.71.29.14 [1] => Adresse: 122, rue du Chteau des Rentiers 75013 PARIS [2] => Date de naissance: 23/11/1973 ) ) */
II-C - Les fichiers xml (avex SimpleXml)

La librairie SimpleXML porte trs bien son nom. Grce SimpleXML vous allez charger un fichier XML (provenant d'une chane de caractres ou d'un fichier) et accder ses valeurs en deux coups de cuillres pot. Dans notre exemple nous allons charger un fichier XML et montrer comment accder une valeur de ce fichier. personnes.xml
<?xml version="1.0" encoding="iso-8859-1"?> <personnes> <personne> <nom>POMMEREAU</nom> <prenom>ERIC</prenom> </personne> <personne> <nom>JAMES</nom> <prenom>Sylvain</prenom> </personne> <personne> <nom>MICHEL</nom> <prenom>Jean-Luc</prenom> </personne> </personnes>
Maintenant le fichier PHP que l'on utilise pour accder la valeur du fichier XML par l'intermdiaire de la librairie SimpleXML Le fichier PHP
<?php $oFichierXml = simplexml_load_file('personnes.xml'); // Lecture et affichage du nom *************** echo $oFichierXml->personne[0]->nom; // Affiche: 'POMMEREAU'
?>
III - Les diffrentes variables Smarty

Nous allons voir dans ce chapitre comment passer des variables PHP au moteur Smarty et ensuite comment les utiliser dans les fichiers de templates. Le mcanisme d'affectation des variables n'est pas si simple... comme nous allons le voir.
III-A - Les variables simples

On commence ici en douceur puisque l'on reprend le mme principe que le test que l'on a fait (dans le chapitre 'tester'). Dans le fichier PHP, nous allons crer 2 variables (un entier et une chane de caractres). Ensuite il nous faut les "recenser" dans l'objet Smarty avec la mthode assign('variable_cible_smarty', $variablePHP). Enfin on provoque l'affichage avec la mthode display('nom_du_template.tpl') de notre objet Smarty. Fichier exemple.php
// Instancier notre objet smarty $oSmarty = new Smarty(); // Fixer les chemins de template (optionnel) $oSmarty->template_dir = '../templates'; $oSmarty->compile_dir = '../templates_c'; // 1. Affectation des variables $une_chaine = "C'est gnial smarty"; $un_entier = 33; // 2. Recensement dans smarty $oSmarty->assign('smarty_une_chaine', $une_chaine);
Fichier exemple.php
$oSmarty->assign('smarty_un_entier', $un_entier); // 3. Affichage du template aprs passage de l'objet $oSmarty->display('exemple.tpl');
La mthode assign() de la classe Smarty recense une variable PHP (second argument) et l'associe une chane de caractres qui sera une variable Smarty dans le fichier de template. On peut tre drout (croyez moi je l'ai t aussi!!) et faire des erreurs en pensant que le premier argument doit tre une variable. Donc n'oubliez pas !!! Le premier argument d'assign est une chane de caractres. exemple.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Test smarty</title> </head> <body> <h1>Test smarty</h1> <ul> <li>une chaine: <span style="color:red;">{$smarty_une_chaine}</span></li> <li>un entier: <span style="color:red;">{$smarty_un_entier}</span></li> </ul> </body> </html>
Pour les dveloppeurs qui utilisent PHP4 on utilisera avantageusement la mthode assign_by_ref() qui vite la "recopie" des variables.
III-B - Les tableaux III-B-1 - Les tableaux indexes

Si l'usage des variables simple est relativement simple, l'utilisation des tableaux s'avre un peu plus dlicate... mais rassurez vous, rien d'insurmontable. A noter que le principe pour le rfrencement des variables Smarty est exactement le mme (ce sera le cas quelque soit le type de variable utilis). C'est dans le fichier de template que l'on modifiera la syntaxe pour accder la variable souhaite tabIndexe.php
// Inclure la librairie smarty require_once('../smarty/Smarty.class.php'); // Instancier notre objet smarty $oSmarty = new Smarty(); // 1. Cration et affectation d'un tableau index $mon_tableau_indexe = array("Jean-Luc","Jean","Sylvain","Eric"); // 2. Recensement dans smarty $oSmarty->assign("smarty_mon_tableau_indexe", $mon_tableau_indexe); // 3. Affichage du template aprs passage de l'objet $oSmarty->display('tabIndexe.tpl');
tabIndexe.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head>
tabIndexe.tpl
<title>Test smarty</title> </head> <body> <h1>Test smarty</h1> <ul> <li>Une valeur du tableau  <li>Une valeur du tableau  <li>Une valeur du tableau  <li>Une valeur du tableau  </ul> </body> </html>
index: {$smarty_mon_tableau_indexe[0]}</li> index: {$smarty_mon_tableau_indexe[1]}</li> index: {$smarty_mon_tableau_indexe[2]}</li> index: {$smarty_mon_tableau_indexe[3]}</li>
III-B-2 - Les tableaux associatifs

Mme principe que ce que l'on a vu prcdemment, l'accs aux valeurs est un peu diffrent de la mthode utilise pour les tableaux indexs un exemple: tabAssoc.php
// Inclure la librairie smarty require_once('../smarty/Smarty.class.php'); // Instancier l'objet smarty $oSmarty = new Smarty(); // 1. Cration et affectation d'un tableau associatif $aMonTableauAsscoiatif = array( "Eric" => "Pommereau", "Jl" => "Michel", "Jean" => "Peyroux" ); // 2. Recensement dans smarty $oSmarty->assign("smarty_mon_tableau_assoc", $aMonTableauAsscoiatif); // 3. Affichage du template aprs passage de l'objet $oSmarty->display("tabAssoc.tpl");
tabAssoc.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Test smarty</title> </head> <body> <h1>Test smarty</h1> <ul> <li>Une valeur du tableau associatif: {$smarty_mon_tableau_assoc.Eric}</li>  <li>Une valeur du tableau associatif: {$smarty_mon_tableau_assoc.Jl}</li>  <li>Une valeur du tableau associatif: {$smarty_mon_tableau_assoc.Jean}</li>  </ul> </body> </html>
- 10 Copyright 2008 - Eric POMMEREAU. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu' 3 ans de prison et jusqu' 300 000 E de dommages et intrts.
III-B-3 - La fonction append()

Une alternative l'utilisation d'un tableau intermdiaire (comme je l'ai fait dans les deux exemples prcdents): l'utilisation de la mthode append(). Une autre utilit cette mthode est la possibilit d'ajouter la mme variable Smarty du contenu plusieurs moments du script, ce qui est exclu avec la mthode assign(). exemple 1 (tableau index)
// selection de 5 enregistrements ( partir de 0) $sQuery = "SELECT PSN_FIRST_NAME, PSN_LAST_NAME, PSN_PHONE FROM person ORDER BY PSN_LAST_NAME LIMIT 0,5"; $mysql_rs = mysql_query($sQuery, $mysql_ressource) or die(mysql_error()); while ($aRow = mysql_fetch_array($mysql_rs)) { $oSmarty->append('smarty_table_mysql', $aRow); } /* ... INSTRUCTIONS ... */ // selection de 5 enregistrements ( partir de 5) $sQuery = "SELECT PSN_FIRST_NAME, PSN_LAST_NAME, PSN_PHONE FROM person ORDER BY PSN_LAST_NAME LIMIT 5,5"; $mysql_rs = mysql_query($sQuery, $mysql_ressource) or die(mysql_error()); while ($aRow = mysql_fetch_array($mysql_rs)) { $oSmarty->append('smarty_table_mysql', $aRow); }
Attention cependant, utiliser la mthode append() ne permet pas le debogage ct PHP (par exemple avec la fonction print_r()) puisqu'il n'y a pas de variable intermdiaire dans le script PHP.
III-C - Les objets (syntaxe PHP5)

Reprenons l'exemple (dfinition de la classe et utilisation de l'objet) vu au dessus, et exempleClass.php
// Inclure la librairie smarty require_once('../smarty/Smarty.class.php'); // Dfinition de la classe class personne { public $nom = ""; public $prenom = ""; public $aInfos = array(); public function __construct($sNom, $sPrenom) { $this->nom = $sNom; $this->prenom = $sPrenom; } public function add_info($sInfo) { array_push($this->aInfos, $sInfo); }
// Instancier notre objet smarty - 11 Copyright 2008 - Eric POMMEREAU. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu' 3 ans de prison et jusqu' 300 000 E de dommages et intrts.
exempleClass.php
$oSmarty = new Smarty(); // 1. Cration et affectation d"un objet $oPersonne = new personne("POMMEREAU", "Eric"); $oPersonne->add_info("mobile: 06.11.75.86.xx"); $oPersonne->add_info("Adresse: 4, villa des Marronniers 91580 ETRECHY"); $oPersonne->add_info("Date de naissance: 23/11/1973"); // 2. Recensement dans smarty $oSmarty->assign("smarty_objet_personne", $oPersonne); // 3. Affichage du template aprs passage de l"objet $oSmarty->display("exempleClass.tpl");
Maintenant voyons comment "rcuprer nos petits" dans notre fichier de template: exempleClass.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Test smarty</title> </head> <body> <h1>Test smarty</h1> <ul> <li>Proprit "nom" de l'objet: {$smarty_objet_personne->nom}</li>  <li>Proprit "aInfos" (premire valeur du tableau) de l'objet: {$smarty_objet_personne->aInfos[0]} </li>  </ul> </body> </html>
III-D - Doc Smarty

Vous trouverez dans la liste suivante, provenant tout droit de la documentation Smarty, qui expose les diverses faon d'accder des variables dans les templates Smarty:
{$foo} <-- affiche une variable simple (qui n'est pas un tableau ou un objet) {$foo[4]} <-- affiche le 5me lment d'un tableau index {$foo.bar} <-- affiche la cl "bar" d'un tableau, identique $foo['bar'] en PHP {$foo.$bar} <-- affiche la valeur de la cl d'un tableau, identique $foo[$bar] en PHP {$foo->bar} <-- affiche la proprit "bar" de l'objet {$foo->bar()} <-- affiche la valeur retourne de la mthode "bar" de l'objet {#foo#} <-- affiche la variable du fichier de configuration "foo" {$smarty.config.foo} <-- synonyme pour {#foo#} {$foo[bar]} <-- syntaxe uniquement valide dans une section de boucle, voir {section} Plusieurs autres combinaisons sont autorises {$foo.bar.baz} {$foo.$bar.$baz} {$foo[4].baz} {$foo[4].$baz} {$foo.bar.baz[4]} {$foo->bar($baz,2,$bar)} <-- passage de paramtres {"foo"} <-- les valeurs statiques sont autorises
III-E - Les variables internes

Smarty offre, en plus du mcanisme "manuel" d'affectation de variable, la possibilit d'accder certaines variables rserves accessible par l'intermdiaire de la variable "smarty". Il s'agit en fait de l'enrobage des variables PHP ($_SERVER ou $_ENV par exemple). Cette fois encore je reprends la doc Smarty pour afficher quelque unes de ces variables Pour accder aux valeurs de ces variables internes vous n'avez rien faire ct PHP, tout est directement accessible dans le fichier de template. L'accs se fait par la variable "$smarty" qui est automatiquement cre. Quelques variables internes de Smarty
{* Affiche la valeur de page dans l'url (GET) http://www.example.com/index.php?page=foo *} {$smarty.get.page} {* affiche la variable "page" rcupre depuis un formulaire (POST) *} {$smarty.post.page} {* affiche la variable "utilisateur" du regroupement de get/post/cookies/server/env *} {$smarty.request.utilisateur} {* affiche la valeur du cookie "utilisateur" *} {$smarty.cookies.utilisateur} {* affiche la variable serveur "SERVER_NAME" *} {$smarty.server.SERVER_NAME}
IV - Les fonctions natives

La comprhension des fonctions Smarty est indispensable, en effet c'est grce aux fonctions que vous allez pouvoir rpter une portion de code, insrer du code en fonction de certaines conditions, insrer du javascript dans vos templates et bien d'autres choses encore. Les fonctions s'utilisent entre accolage ex: {section}. Comme en html avec les balises, toute dclaration de fonction s'accompagne d'une balise de "fermeture". Pour la fonction {section} on utilisera par exemple {/section}.
IV-A - Section
Cette fonction essentielle est peut-tre la premire qui m'a fait prendre conscience du potentiel de Smarty. Section vous permet d'afficher une portion de code HTML autant de fois qu'il y a d'lments dans le conteneur qui lui a t indiqu. C'est en fait strictement la mme chose qu'une boucle, gardez toujours a l'esprit. Pour que tout cela fonctionne, il faut donc avoir pass Smarty un conteneur de donne (tableau ou objet) et lui se charge du reste. Vous devez spcifier au moins deux arguments: LOOP qui est la variable Smarty (tableau ou objet assign en PHP) et un attribut NAME dont la valeur reprsente le nom de la SECTION. La valeur de NAME est comme un index que nous utiliserons dans la fonction pour accder l'lment courant, aller un exemple: section.php
// Inclure la librairie smarty require_once('../smarty/Smarty.class.php'); // Instancier l'objet smarty $oSmarty = new Smarty(); $aMonTableau = array("Jean", "Jean-Luc", "Sylvain", "Eric"); // 2. Recensement dans smarty de la variable $aMonTableau
section.php
$oSmarty->assign('smarty_tableau', $aMonTableau); // 3. Affichage du template aprs passage de l'objet $oSmarty->display('section.tpl');
Jusqu'ici, rien de particulier, la nouveaut se trouve dans le template: section.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>La fonction section</title> </head> <body> <h2>La fonction section</h2> <ul>  {section name=idx_smarty_tableau loop=$smarty_tableau} <li>{$smarty_tableau[idx_smarty_tableau]}</li> {/section} </ul> </body> </html>
IV-B - If, else, elseif

Tout comme en PHP, Smarty offre dans ses templates la possibilit d'afficher du contenu en fonction de certaines conditions dfinies par le dveloppeur (ou le graphiste) dans le fichier de template. Prenons l'exemple de la gestion d'un profil "administrateur" o certains lments ne doivent pas tre affichs dans certains cas. On pourra tester l'existence ou la valeur d'une variable pour dterminer que la portion de code concerne doit ou ne doit pas s'afficher On dclarera la fonction "IF" de cette faon {if ma_condition}mon code...{/if}. Dans le cas du {IF}, l'argument (ma_condition) est la condition que l'on souhaite valuer (galit, diffrence, ngation...). Un exemple: if.php
// Inclure la librairie smarty require_once('../smarty/Smarty.class.php'); // Instancier notre objet smarty $oSmarty = new Smarty(); $userIsAdmin = 'true'; // 2. Recensement dans smarty $oSmarty->assign('smarty_userIsAdmin', $userIsAdmin); // 3. Affichage du template aprs passage de l'objet $oSmarty->display('if.tpl');
Ici encore rien de particulier ct PHP, c'est la partie TEMPLATE qui est concerne, dans cet exemple, on teste la valeur d'une variable Smarty concernant les droits d'un utilisateur. if.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Fonctions IF/ELSE/ELSEIF</title> </head> <body>
if.tpl
<h2>Les fonctions IF/ELSE/ELSEIF</h2> {if $smarty_userIsAdmin == 'true'} <div>Salut administrateur</div> {else} <div>Salut utilisateur lambda !!</div> {/if}
</body> </html>
IV-C - Literal
Literal vous permet de dsactiver un temps l'interprtation Smarty. Cela permet notamment l'insertion de scripts JAVASCRIPT qui gnrerent habituellement des erreurs (entre autre cause des accolades). En effet le fichier de template suivant gnre une erreur: sansLiteral.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title></title> </head> <body> <script language="JavaScript" type="text/javascript"> function test () { alert('Bonjour le monde !!'); } </script> </body> </html>
Fatal error: Smarty error: [in index.tpl line 10]: syntax error: unrecognized tag: alert('Bonjour le monde !!'); (Smarty_Compiler.class.php, line 439) in C:\Program Files\wamp\www\demos\smarty\lib_smarty\Smarty.class.php on line 1095 En utilisant la fonction {LITERAL}, c'est dire en entourant le script javascript ou la C.S.S. concern, cela ne posera plus de problme: avecLiteral.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Literal</title> </head> <body> {LITERAL} <script language="JavaScript" type="text/javascript"> function test () { alert('Bonjour le monde !!'); } </script> {/LITERAL} </body> </html>
IV-D - Include
Cette fonction permet d'appeler dans un template un autre template, dans la mme ide qu'un include() PHP. Cela permet de dcoupler encore plus la prsentation. Nous allons voir dans l'exemple suivant le cas d'une zone principale et d'un "HEADER". include.php
require_once('../smarty/Smarty.class.php'); // Instancier l'objet smarty $oSmarty = new Smarty(); $oSmarty->assign('header_text', "Ceci est l'entte de ma page !!!"); $oSmarty->assign('main_text', "Ceci est la zone principale de ma page !!!"); // 3. Affichage du template aprs passage de l'objet $oSmarty->display('include.tpl');
Le fichier de template que l'on va inclure: header.tpl
<div id="header" style="background-color:teal;"> <h1>{$header_text}</h1> </div>
Voyons maintenant le template qui prend en charge l'inclusion (ici du template header.tpl) include.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Exemple d'include</title> </head> <body> {include file="header.tpl"} <div id="main" style="background-color:#6699cc;"> <h1>{$main_text}</h1> </div> </body> </html>
Dans le template inclu on peut utiliser sans problme les variables Smarty.
V - Les fonctions utilisateur

Pourquoi fonctions utilisateur ? Eh bien c'est une des caractristiques et des forces de Smarty. Les fonctions utilisateurs ont le mme principe de fonctionnement que les fonctions natives, un mot cl, des arguments, le tout entre accolades. Quelle diffrence alors ? Ces fonctions ne font pas partie du coeur de Smarty mais utilises comme PLUGIN. D'ailleurs vous verrez dans les sources de Smarty un rpertoire /plugin. Si vous regardez bien vous retrouvez un fichier par fonction utilisateur.
V-A - Html_options
La fonction HTML_OPTIONS provoque l'affichage d'une liste d'options ( l'intrieur d'un lment HTML "SELECT"). Il faut pour cela lui indiquer une liste de valeurs qui seront affiches et une liste d'identifiants associs ces valeurs... vite un exemple !!! html_options.php
$oSmarty = new Smarty(); // Liste des textes pour les "<option>" $aNoms = array("Sylvain", "Jean", "Jean-Luc", "Eric"); // Liste des valeurs pour les "<option>" $aIndex = array(1,2,3,4); // L'lment selectionn est le 3 $iSelected = 3; $oSmarty->assign('smarty_liste_noms', $aNoms); $oSmarty->assign('smarty_liste_index', $aIndex); $oSmarty->assign('smarty_liste_selected', $iSelected); $oSmarty->display('html_options.tpl');
html_options.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>exemple HTMLOPTIONS</title> </head> <body> <form name="mon_formulaire"> <select name="gars_du_dev"> {html_options values=$smarty_liste_index selected=$smarty_liste_selected output=$smarty_liste_noms} </select> </form> </body> </html>
Rsultat
V-B - Cycle
La fonction CYCLE permet l'affichage en alternance de 1 n valeurs. Dans la pratique, on l'utilisera avantageusement pour l'alternat de couleurs dans un tableau affichant un ensemble de donnes. C'est ce que nous allons voir tout de suite dans l'exemple cycle.php
require_once('../lib_smarty/Smarty.class.php'); $oSmarty = new Smarty(); $aNoms = array("Sylvain", "Jean", "Jean-Luc", "Eric"); $oSmarty->assign('smarty_liste_noms', $aNoms); $oSmarty->display('cycle.tpl');
cycle.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head>
cycle.tpl
<title>Exemple fonction cycle</title> </head> <body> {section name=idx loop=$smarty_liste_noms} <div style="background-color:{cycle values="red,blue"};">{$smarty_liste_noms[idx]}</div> {/section} </body> </html>
V-C - Mailto
Comme son nom l'indique cette fonction vous permet d'ajouter rapidement un lien mailto (lien vers un ou plusieurs mails). L'utilisation de mailto permet notamment l'encodage en javascript / hexadcimal des adresses mails qui sont alors bien moins facilement reprables. Un exemple d' utlisation en encodage javascript: encode.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Exemple fonction encode</title> </head> <body> {mailto address="eric190@free.fr" encode="javascript"} </body> </html>
V-D - Liste des fonctions utilisateur

capture config_load foreach,foreachelse include include_php insert if,elseif,else ldelim,rdelim literal php section, sectionelse strip
VI - Les modificateurs de variable

Les modificateurs de variable permettent de modifier le contenu des variables passes SMARTY. Grce aux modificateurs le dveloppeur pourra intervenir sur le contenu, l'apparence des variables. Les modificateurs sont nombreux et relativement simples mettre en oeuvre. Le modificateur de variable s'applique comme un filtre en mettant un "pipe" aprs la variable
VI-A - Upper
UPPER permet de mettre le contenu de la variable en capitales.
// Inclure la librairie smarty
Initiation aux templates en PHP avec Smarty par Eric POMMEREAU require_once('../smarty/Smarty.class.php'); // Instancier notre objet smarty $oSmarty = new Smarty(); $oSmarty->assign("smarty_phrase", "Les chaussettes de l'archi-duchesse"); // 3. Affichage du template aprs passage de l'objet $oSmarty->display('exemple.tpl');
Modificateur UPPER
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Exemple modificateur UPPER</title> </head> <body> <p>{$smarty_phrase|upper}</p> </body> </html>
Rsultat
LES CHAUSSETTES DE L'ARCHI-DUCHESSE
VI-B - Default
Ce modificateur permet de donner une variable Smarty une valeur par dfaut. Par exemple pour insrer un espace dans un tableaux quand la donne est vide. Modificateur DEFAULT
<table> <tr> <td>{$smarty_nom|default:" "}</td> <td>{$smarty_prenom|default:" "}</td> </tr> </table>
VI-C - Truncate
Truncate entrane la ssure d'une chane de caractres au nombre de caractres souhait
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Modificateur TRUCATE</title> </head> <body> <p>{$smarty_phrase|truncate:30}</p> </body> </html>
Par dfaut, le dcoupage ne se fait normalement pas sur un mot mais su la fin du mot, issu de la doc Smarty: "Par dfaut, truncate tentera de couper la chane la fin d'un mot". Cette caractristique est facilement "dbrayable".
VII - La console de debogage

La console de deboguage permet au dveloppeur notamment de voir les templates appels, les variables Smarty et leurs contenu ainsi que les variables de configuration. C'est un formidable outil que je vous encourage vivement utiliser. Dans son utilisation "de base", l'appel la console se fait dans le script PHP, ce qui provoque au rechargement de page l'apparition d'une fentre "popup" (attention aux bloqueurs de popup). L'affichage de la console est donc effectu en javascript.
VII-A - Appel dans le script PHP

Premire possibilit, l'appel dans le script PHP qui implmente Smarty. Dans ce cas de figure, on fixe une proprit debugging true. console.php
// Inclure la librairie smarty require_once('../smarty/Smarty.class.php'); // Instancier notre objet smarty $oSmarty = new Smarty(); $oSmarty->debugging = true; $oSmarty->assign("smarty_phrase", "Les chaussettes de l'archi-duchesse"); // 3. Affichage du template aprs passage de l'objet $oSmarty->display('exemple.tpl');
VII-B - Appel dans le template

Une autre faon d'appeler la console consiste insrer une fonction {DEBUG} dans le template consoleInTemplate.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Exemple d'utilisation de la console de dbogage</title> </head> <body> <p>{$smarty_phrase|truncate:30}</p> {debug} </body> </html>
VII-C - La console sans javascript

Une fonction trs intressante: l'affichage de la console directement dans le fichier de sortie sans passer par javscript, il s'agit d'un paramtre (OUTPUT) ajouter dans la fonction {debug}: consoleEnHtml.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>La console sans javascript</title>
consoleEnHtml.tpl
</head> <body> <p>{$smarty_phrase|truncate:30}</p> {debug output="html"} </body> </html>
Affichage de la console sans passer par JAVASCRIPT Comme vous le voyez la console n'est plus lance dans une fentre popup mais bien intgre la page web gnre
VII-D - Paramtre dans l'url

Dernire fonctionnalit que nous allons voir, c'est un must !!! la console est 'appelable' en passant un paramtre dans l'url qui invoque le script php. Pour se faire il faut permettre Smarty de le faire en fixant la proprit 'debugging_ctrl' 'URL' comme ceci: consoleUrl.php
$oSmarty = new Smarty(); $oSmarty->debugging_ctrl= 'URL';
Appel de la console en utilisant un paramtre dans l'URL Voyez dans la barre d'adresse, j'ai pass le paramtre 'SMARTY_DEBUG' (peu importe qu'il y ait une valeur associe), la proprit Smarty "debugging_ctrl" tant true, la console s'est affiche.
VIII - Recettes de code

L'objet de cette partie du tutoriel est de vous prsenter quelques cas concrets de ce que l'on peut faire et comment on peut le faire avec SMARTY.
VIII-A - Extraction Mysql vers tableau HTML

Voil un exemple que l'on retrouve dans la plupart des applications, partir d'un ensemble de donnes (une table Mysql dans notre exemple) pour afficher un tableau Un screenshot de ma table visualise avec phpMyAdmin (base training, table person)
La partie PHP ne prsente rien d'exceptionnel. L'ide est d'empiler chacune des "lignes"rcupres (avec la fonction mysql_fetch_array) pour rutiliser le tableau ainsi constitu dans le template Smarty. fromMysqlToTable.php
require_once('../lib_smarty/Smarty.class.php'); $oSmarty = new Smarty(); $mysql_ressource = mysql_connect('localhost', 'root', ''); mysql_select_db("training", $mysql_ressource); $sQuery = "SELECT PSN_FIRST_NAME, PSN_LAST_NAME, PSN_PHONE FROM person ORDER BY PSN_LAST_NAME"; $mysql_rs = mysql_query($sQuery, $mysql_ressource) or die(mysql_error()); - 21 Copyright 2008 - Eric POMMEREAU. Aucune reproduction, mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu' 3 ans de prison et jusqu' 300 000 E de dommages et intrts.
fromMysqlToTable.php
$aRecordSet = array(); while ($aRow = mysql_fetch_array($mysql_rs)) { array_push($aRecordSet, $aRow); } $oSmarty->assign('smarty_table_mysql', $aRecordSet); $oSmarty->display('index.tpl');
mysqlToTable.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title></title> </head> <body> <table width="450px"> <tr style="background-color:teal;color:white;"> <th>NOM</th> <th>PRENOM</th> <th>TELEPHONE</th> </tr>  {section name=idx loop=$smarty_table_mysql} <tr style="background-color:{cycle values="#ffffcc, #cccccc"};"> <td>{$smarty_table_mysql[idx].PSN_LAST_NAME}</td> <td>{$smarty_table_mysql[idx].PSN_FIRST_NAME}</td> <td>{$smarty_table_mysql[idx].PSN_PHONE}</td> </tr> {/section} </table> </body> </html>
Rsultat: un tableau HTML avec alternat de couleur
VIII-B - Utilisation d'une source xml

Nous allons voir comment, partir d'un fichier XML (source fichier ou bien chane de caractres) on peut mettre ces donnes dans notre template. personnes.xml
<?xml version="1.0"?> <personnes> <personne> <nom>PEYROUX</nom> <prenom>Jean</prenom> <tels> <tel>06.76.89.78.56</tel> </tels> </personne> <personne> <nom>MICHEL</nom> <prenom>Jean-Luc</prenom> <tels> <tel>01.87.54.23.34</tel> <tel>06.12.21.34.54</tel> <tel>09.09.98.89.09</tel> </tels> </personne> <personne>
personnes.xml
<nom>POMMEREAU</nom> <prenom>Eric</prenom> <tels> <tel>01.78.98.87.87</tel> <tel>06.12.34.32.34</tel> </tels> </personne> </personnes>
Comme nous allons le voir, la taille du code PHP est particulirement faible. personnes.php
require_once('../lib_smarty/Smarty.class.php'); $oSmarty = new Smarty(); $oXmlFile = simplexml_load_file("personnes.xml"); $oSmarty->assign('smarty_xml_file', $oXmlFile); $oSmarty->display('personnes.tpl');
Le fichier de template est un peu plus complexe puisque nous utilisons la fonction foreach (un peu diffrente de {SECTION}), cette fonction est de plus imbrique pour obtenir les tlphones de chacun: personnes.tpl
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>Utilisation d'une source XML</title> </head> <body> <table width="450px"> <tr style="background-color:teal;color:white;"> <th>NOM</th> <th>PRENOM</th> <th>TELEPHONES</th> </tr>  {foreach from=$smarty_xml_file item=personne} <tr style="background-color:{cycle values="#ffffcc, #cccccc"};"> <td>{$personne->nom}</td> <td>{$personne->prenom}</td> <td> <table>  {foreach from=$personne->tels->tel item=telephone} <tr> <td> {$telephone} </td> </tr> {/foreach} </table> </td> </tr> {/foreach} </table> </body> </html>
VIII-C - Production d'un fichier XML (fil rss)

Nous avons vu comment utiliser avec Smarty une source XML. Nous allons maintenant voir comment produire du XML. Plus particulirement dans cette exemple nous allons produire un fil RSS 2.0. Pour raliser ce fil RSS, nous allons utiliser une source mysql dont voici un aperu:
Pour la suite mme logique que ce que nous avons pu voir prcdemment. Le fichier PHP charg de la rcupration des donnes et de la "ventilation" vers Smarty.
rss.php
<?php require_once('../lib_smarty/Smarty.class.php'); $oSmarty = new Smarty(); // Le tableau conteneur des lments RSS $aRssItems = array(); // Se connecter mysql if (! $oConnexion = mysql_connect('localhost', 'root', '')) die("Impossible de se connecter"); // Choisir la base de donnes if (! mysql_select_db('demos')) die("Erreur de selection de la base de donnes"); // Construire la requte $sSql = "SELECT `title` , `description` , `link` FROM rss" ; // Excuter la requte et rcuprer le jeu d'enregistrments if (! $oMysqlRes = mysql_query($sSql)) die("Erreur: la requte n'a pu tre excute"); // Pour chaque ligne du jeu d'enregistrement while ($oRow = mysql_fetch_array($oMysqlRes, MYSQL_ASSOC)) { // Ajouter dans le conteneur array_push($aRssItems, $oRow); } // Passer la $oSmarty->assign('smarty_RssItems', $aRssItems); header("Content-Type: text/xml"); $oSmarty->display('rss.tpl') ?>
Enfin, le fichier de template est un fichier XML standard RSS 2.0 Standard RSSavec une partie "dynamique" reproduite autant de fois qu'il y a d'lments dans la base de donne. rss.tpl
<?xml version="1.0" encoding="ISO-8859-1" ?> <rss version="0.91"> <channel> <title>Exemple de production de fil RSS avec SMARTY</title> <link>http://localhost/demos/init_smarty/demoRSS/</link>
rss.tpl
<description>La dmo suivant vous montre comment crer facilement un flux RSS avec SMARTY.</description> <language>fr</language> <copyright>Eric POMMEREAU</copyright> <webMaster>eric-pommereau@developpez.com</webMaster> <image> <title>Smarty</title> <url>http://localhost/demos/init_smarty/demoRSS/smarty_icon.gif</url> <link>http://smarty.php.net/</link> <width>88</width> <height>31</height> </image> {section name=itemIndex loop=$smarty_RssItems} <item> <title>{$smarty_RssItems[itemIndex].title}</title> <description>{$smarty_RssItems[itemIndex].description}</description> <link>{$smarty_RssItems[itemIndex].link}</link> </item> {/section}
</channel> </rss>
Le Fil RSS tel qu'il apparat dans le navigateur FIREFOX
IX - Ressources Smarty
Le site de Smarty : Documentation : Smarty La doc Smarty ressources Smarty Smarty : PHP Template Programming and
Les ressources (article, plugins et autres applications utilisant Smarty) : Un seul livre (pour le moment...), il est en anglais : Applications
Tutoriels
Articles concernant les gabarits sur Tutoriel : Tutoriel : Tutoriel : developpez.com Comparatif des systmes de template pour PHP Dcouverte des principaux moteurs de template en PHP Conception avance d'une galerie d'images gnre la vole
Forums
Forums : Forums : Forums: Gnral sur developpez.com Partie PHP sur developpez.com Partie bibliothques PHP sur developpez.com
X - Conclusion
Un petit conseil pour la route: si vous ne vous tes jamais servi de Smarty ne reprenez pas un projet "du type traditionnel" existant ... a peut vite tourner au cauchemar. Je prconise plutt un dmarrage en douceur sur un projet tout neuf.
Voil... c'est termin. J'espre que vous avez eu plaisir me lire, si j'ai su susciter quelques vocation quand l'utilisation de Smarty dans vos projets... alors mon objectif est atteint !!! Pour ma part je suis convaincu que Smarty est un bon systme (peut-tre pas le meilleur...) pour crer, maintenir et faire voluer des applications en PHP. N'hsitez pas me contacter si vous avez des questions, des suggestion ou pour signaler une erreur. Contact: eric.pommereau@caramail.com

Sprache

Willkommen bei Scribd!

Initiation Smarty

Hochgeladen von

Dokumentinformationen

Datum des Uploads

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Beschreibung:

Copyright:

Verfügbare Formate

Initiation Smarty

Hochgeladen von

Beschreibung:

Copyright:

Verfügbare Formate

Verwandte Titel

Initiation aux templates en PHP avec Smarty

par Eric POMMEREAU

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

I - Introduction I-A - Remerciements

I-C - Avantages et inconvnients

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

// Provoque le rendu du template $oSmarty->display('test.tpl'); ?>

II - Retour sur les mtas-structures

II-A - Les tableaux

II-A-1 - Les tableaux indexes

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

II-A-2 - Les tableaux associatifs

II-B - Les objets (syntaxe PHP5)

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

II-C - Les fichiers xml (avex SimpleXml)

III - Les diffrentes variables Smarty

III-A - Les variables simples

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

$oSmarty->assign('smarty_un_entier', $un_entier); // 3. Affichage du template aprs passage de l'objet $oSmarty->display('exemple.tpl');

III-B - Les tableaux III-B-1 - Les tableaux indexes

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

index: {$smarty_mon_tableau_indexe[0]}</li> index: {$smarty_mon_tableau_indexe[1]}</li> index: {$smarty_mon_tableau_indexe[2]}</li> index: {$smarty_mon_tableau_indexe[3]}</li>

III-B-2 - Les tableaux associatifs

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

III-B-3 - La fonction append()

III-C - Les objets (syntaxe PHP5)

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

III-D - Doc Smarty

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

III-E - Les variables internes

IV - Les fonctions natives

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

$oSmarty->assign('smarty_tableau', $aMonTableau); // 3. Affichage du template aprs passage de l'objet $oSmarty->display('section.tpl');

Jusqu'ici, rien de particulier, la nouveaut se trouve dans le template: section.tpl

IV-B - If, else, elseif

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

Le fichier de template que l'on va inclure: header.tpl

<div id="header" style="background-color:teal;"> <h1>{$header_text}</h1> </div>

V - Les fonctions utilisateur

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

V-D - Liste des fonctions utilisateur

VI - Les modificateurs de variable

LES CHAUSSETTES DE L'ARCHI-DUCHESSE

<table> <tr> <td>{$smarty_nom|default:"&nbsp;"}</td> <td>{$smarty_prenom|default:"&nbsp;"}</td> </tr> </table>

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

VII - La console de debogage

VII-A - Appel dans le script PHP

VII-B - Appel dans le template

VII-C - La console sans javascript

Initiation aux templates en PHP avec Smarty par Eric POMMEREAU

</head> <body> <p>{$smarty_phrase|truncate:30}</p> {debug output="html"} </body> </html>

VII-D - Paramtre dans l'url

$oSmarty = new Smarty(); $oSmarty->debugging_ctrl= 'URL';

<table> <tr> <td>{$smarty_nom|default:" "}</td> <td>{$smarty_prenom|default:" "}</td> </tr> </table>