Le module core intègre les fonctions de base de Templeet.

Généralités:

Les fonctions disponibles sont les suivantes:

set et get : définir et récupérer une variable
array : permet de créer un tableau
rem : permet de commenter son code
noeval : permet de commenter son code sans évaluation
include : inclus un fichier / template
parseparam : lecture d'un paramètre d'un fichier inclus
eval : évalue du code Templeet
if : effectue un test
switch : effectue une série de tests
while : effectue une boucle
for : effectue une boucle
empty : teste si l'argument est vide
inc et dec : fonctions d'incrémentation et de décrémentation
integer : renvoie un entier
executedtime : retourne le temps mis pour traiter le template
createdir : création de répertoires récursivement
compactdir : canonisation d'un chemin

Les fonctions de listes:

Présentation des fonctions de listes
Les sélecteurs de présentation des listes

Syntaxe

Dans un template les fonctions écrites en Templeet seront évaluées, le reste ne sera pas modifié. Une fonction Templeet est précédée du caractère tilde : ~ et les paramètres sont passés entre parenthèse séparés par des virgules.

bla bla     <-- ce texte sera renvoyé tel quel
~time()	 <-- ceci est une fonction Templeet 
~cuthtml('"Bonjour, <b><u>Le Monde!</u></b>", hurla l\'écho.',15)	  <-- ceci est une fonction Templeet avec deux paramètres

La plupart des fonctions PHP qui ne manipulent pas d'objets peuvent être appelées directement dans Templeet:

~md5("Les sanglots longs des violons de l'automne")    =>	  bd5a0565059a60f304f93926daecef06

Revenir en haut

Les blocs d'instructions

Apostrophes et guillemets :

Dans le langage Templeet les apostrophes ' ou les guillemets " délimitent des chaînes de caractères. Les instructions Templeet étant interprétées dans les chaînes, celle-ci peuvent être utilisées pour délimiter des blocs d'instructions. Par exemple :

~if(10>1,
	'Voici le premier bloc délimité par des apostrophes
	~if(~empty(~get("foo")), 
		~set("foo", 10),
		"Un autre bloc délimité par des guillemets"
	)
	',
	'Voici un second bloc délimité par des apostrophes'
)

Bloc <![nomdubloc[ ... ]nomdubloc]> :

Toutefois, lorsque vous avez à implémenter des algorithmes plus complexes qui nécessitent plusieurs conditions imbriquées, il devient difficile de repérer le début et la fin d'un bloc.
Pour faire face à ce problème vous pouvez utiliser une autre syntaxe pour délimiter les blocs : <![nomdubloc[ ... ]nomdubloc]>. Ces blocs sont des chaînes de caractères au même titre que les chaînes délimitées par des apostrophes et des guillemets. Seule la délimitation de ces chaînes changent. On notera que dans ces chaînes, ni les guillemets ni les apostrophes n'ont besoin d'être échappés.

Exemple :

~if(10>1,
	<![bloc1[
	Voici le premier bloc nommé "bloc1"
	~if(~empty(~get("foo")),
		~set("foo", 10),
		<![foo[ Un autre bloc nommé "foo" ]foo]>
	)
	]bloc1]>,
	<![foo[ Encore un autre bloc nommé "foo" ]foo]>
)

Accolades { et } :

Les blocs définis par des accolades ont un fonctionnement particulier.

Les instructions sont séparées par des virgules ",". Comme dans l'exemple ci-dessous :

~string(
{
	~set("i", 2),
	~set("j", 3),
	~get("j"),
	~get("i")+ ~get("j")
}
)

Le rendu de ce script sera :

Comme vous pouvez le remarquer la valeur 3 renvoyée par ~get("j") n'est pas affichée. En effet, seule la dernière instruction du bloc est retournée.

Les accolades ne peuvent être utilisées que en paramètre d'une fonction Templeet. Au besoin vous pouvez utiliser les fonctions string ou rem pour envelopper un bloc d'accolades.

Revenir en haut

Les "vrais" commentaires

Il est possible d'intégrer des commentaires dans vos scripts dont le contenu ne sera pas traité par Templeet (contrairement à la commande ~rem())

Pour cela il faut soit utiliser les caractères // ou le bloc /* ... */ à l'intérieur d'une instruction Templeet.

Exemple :

~string(
// Ceci est un commentaire d'une seule ligne

/*
Ceci est un commentaire de type bloc
*/
)

Autre exemple :

~rem(
// Ceci est un commentaire d'une seule ligne

/*
Ceci est un commentaire de type bloc
*/
)

Revenir en haut

set et get

Ces fonctions servent à manipuler des variables. La fonction ~set() prend 2 arguments, le nom de la variable et le contenu de la variable. La fonction ~get() quant à elle ne prend qu'un seul argument, le nom de la variable à récupérer.

~set('mavariable', 'je suis un test')		

~get('mavariable')				=>	je suis un test

L'exemple ci-dessous utilise ces deux fonctions afin de manipuler des tableaux :

~set('tab[1]', 'valeur1')		
~set('tab[2]', 'valeur2')		
~set('tab[3]', 'valeur3')		

~get('tab[1]')				=>	valeur1
~get('tab[2]')				=>	valeur2
~get('tab[3]')				=>	valeur3

La fonction ~set permet aussi de détruire une variable :

~set('mavariable', 'je suis un test')	

~get('mavariable')			=> je suis un test

~set('mavariable')			

~get('mavariable')			=> 


~set('tab[1]', 'valeur1')		
~set('tab[2]', 'valeur2')		
~set('tab[3]', 'valeur3')		

~get('tab[1]')				=>	valeur1
~get('tab[2]')				=>	valeur2
~get('tab[3]')				=>	valeur3

~set('tab[2]')		

~get('tab[1]')				=>	valeur1
~get('tab[2]')				=>	
~get('tab[3]')				=>	valeur3

~set('tab')		

~get('tab[1]')				=>	
~get('tab[2]')				=>	
~get('tab[3]')				=>

Les variables suivantes sont définies par Templeet, ne les réutilisez pas :

~get('path')     => templeet_doc/core.html.fr
~get('template') => template/templeet_doc/$html.tmpl
~get('lang')     => fr
~get('includedir')       => templeet_doc/fr/
~get('actual_template')  => template/templeet_doc/fr/core.tmpl
~print_r(~get('filenamevars'))     =>
Array
(
    [0] => core
)

~print_r(~get('accept_language'))	=>
Array
(
    [0] => en-us
    [1] => en;q=0.5
)

Les variables suivantes sont définies par l'utilisateur et utilisées par Templeet:

all_lang: tableau des langues dans laquelle existe la page vue.
Pour indiquer qu'une page existe en plusieurs langues il faut faire un tableau dont les clefs sont les langues utilisées. Par exemple pour le français et l'anglais:
```
~set('all_lang',~array_flip(~array('en','fr')))
```
La définition de ce tableau est obligatoire dans le cas où le cache page est utilisé avec le système d'erreur 404.
HTTP-Content-type: définit l'entête HTTP Content-type à retourner
HTTP-charset: définit l'entête HTTP charset à associer au Content-type
HTTP-filename: définit une entête HTTP "Content-disposition: attachment;"

Revenir en haut

array

Cette fonction permet de créer un tableau de données.

Exemple d'utilisation :

~set("tab",
	~array(
		"foo"=>1,
		"bar"=>2
	)
)

~get("tab[foo]") --> 1
~get("tab[bar]") --> 2

Revenir en haut

rem

Cette fonction permet de commenter son code, et commenter c'est bien(tm)

~rem("ceci est un commentaire. ATTENTION ! aucune valeur n'est retournée mais il est évalué par Templeet")

Revenir en haut

noeval

Cette fonction permet de commenter son code sans qu'il y ait d'évaluation.

~noeval("ce code n'est pas évalué  ")

Revenir en haut

include et parseparam

Cette fonction permet d'inclure un fichier ou un autre template. Par défaut elle utilise le répertoire du template père.

Des arguments peuvent être passés à la commande ~include(), et ils peuvent être utilisés dans le template inclus grâce à la commande ~parseparam().

Exemple :

Contenu du fichier "index.html" :

~include('fichier.tmpl',"1er argument", 10)

Contenu du fichier "fichier.tmpl" :

Le premier argument est : ~parseparam(1)
Le second argument est : ~parseparam(2)

Rendu du script "index.html" :

Le premier argument est : 1er argument
Le second argument est : 10

Si cette commande est utilisée dans le template "template/exemple.tmpl" alors le fichier "template/fichier.txt" sera inclus. Ce template peut comporter des commandes Templeet. Il pourra récupérer les arguments passés au moment de l'include. Par exemple ~parseparam(1) retournera "1er argument" (sans les "), et ~parseparam(2) retournera "10" (sans les ").

Revenir en haut

eval

Cette fonction permet d'évaluer du code Templeet. Ainsi du code Templeet peut être généré dynamiquement dans une variable, puis évalué plus tard.

~eval('~set('une_variable',10) ~get('une_variable')')

Cette commande mettra "10" dans la variable "une_variable", puis retournera le contenu de cette même variable.

Voir également les fonctions anonymes.

Revenir en haut

if

Cette commande effectue un test conditionnel, évalue le 2ème argument si le test retourne vrai, sinon et s'il existe, évalue le 3ème argument.

~if(1<2,"c'est vrai!","c'est faux!")

L'exemple précédent retournera c'est vrai! .

Revenir en haut

switch

Cette commande effectue une série de tests. Les arguments sont passés deux par deux. Le premier d'une paire est un test, le deuxième est la valeur à renvoyer si le test est vrai. L'évaluation de switch s'arrête au premier test qui retourne vrai. Il est possible de renvoyer une valeur par défaut si tous les tests ont échoué, il suffit de la mettre comme dernier argument.

~set('x',1)
~switch(
	~get('x')<0,"x est négatif",
	~get('x')>0,"x est positif",
	"x est nul")

L'exemple précédent retournera "x est positif".

Revenir en haut

while

Cette commande prend 2 arguments, elle évalue le 2ème tant que le 1er retourne vrai.

~set('counter',1)
~while(~get('counter')<=3,
	'on compte ... ~get('counter')
	~set('counter',~get('counter')+1)')

Revenir en haut

for

Cette commande prend 4 arguments, elle évalue le 4ème tant que le 2ème retourne vrai. Le premier argument est le code d'initialisation, le 3ème celui d'incrémentation.

~for(~set('counter',1),~get('counter')<=3,~set('counter',~get('counter')+1),
	'on compte ... ~get('counter') '
)
=>

on compte ... 1 on compte ... 2 on compte ... 3

Revenir en haut

empty

Retourne 1 si l'argument est vide, 0 sinon.

~empty(~get('var'))	=>	1
~set('var','quelquechose')~empty(~get('var'))	=>	0

Revenir en haut

inc dec

La fonction ~inc incrémente la variable qui lui est fournie en paramètre. Exemple :

~set("i", 1)
~inc("i")
~get("i") => 2

La fonction ~dec décrémente la variable qui lui est fournie en paramètre. Exemple :

~set("i", 2)
~dec("i")
~get("i") => 1

Revenir en haut

integer

Cette fonction sert pour forcer le type d'un argument à (int). Pour les arrondis par valeurs inférieures et supérieures et les troncatures, pensez aux fonctions PHP : floor, ceil et round.

~divide(8,3)			=>	2.66666666667

~integer(~divide(8,3))			=>	2

~ceil(~divide(8,3))			=>	3

Revenir en haut

executedtime

Cette fonction, qui ne prend pas d'argument, retourne le temps mis pour traiter le template.

~executedtime()			=>	0.1053

Revenir en haut

createdir

La fonction ~createdir() prend un argument, le nom du répertoire à créer. Cette fonction peut créer des répertoires récursivement s'ils n'existent pas.

Note : Cette fonction fait appel à la fonction createdir de templeet.php

Exemple :

~createdir('plop/pika/test/')

Si les répertoires 'plop', 'pika' n'existent pas, ils sont créés au passage.

Revenir en haut

compactdir

La fonction ~compactdir() prend un argument, un chemin à vérifier. Elle retourne le chemin sous forme compacte, en retirant les '.' et '..'.

Cette fonction est utile pour vérifier un argument passé en paramètre et utilisé ensuite au niveau du système de fichiers, pour des questions de sécurité.

Exemple :

~compactdir('/var/www/Templeet/templates/../linuxfr/')

Cela se transforme en : /var/www/Templeet/linuxfr/

Revenir en haut

Présentations des fonctions de listes

Templeet comprend un certain nombre de fonctions qui gèrent des listes. Une liste est une suite d'élements. Une liste peut être le résultat d'une requête SQL ou bien les éléments d'un tableau ou encore les entrées dans un répertoire du système de fichiers.

Toutes les fonctions de listes ont des paramètres qui leurs sont propres parce que un tableau ne se gère pas comme une base de données par exemple. Néanmoins, toutes les fonctions de listes ont en commun le principe de présentation des éléments. Celle-ci se fait à l'aide de sélecteurs.

Revenir en haut

Les sélecteurs de présentation des listes

Les sélecteurs sont des paramètres passés aux fonctions de liste qui permettent de déterminer le rendu de la liste. Un sélecteur se compose de deux éléments:

Un type sous la forme de deux caractères en majuscule
Une valeur qui sera interpretée au moment du traitement d'un état particulier de l'avancement dans le traitement de la liste

L'appel d'une fonction de liste se compose de la manière suivante:

~fonction_de_liste(les paramètres propres à la fonction, type_selecteur_1, valeur_selecteur_1, type_selecteur_2, valeur_selecteur_2 ...)

Chaque fonction traite un certain nombre de sélecteurs mais pas forcément tous. Le seul sélecteur qui soit obligatoire est le sélecteur LM. Le sélecteur LM est utilisé pour traiter chacun des éléments de la liste.

Exemple dans le cas du traitement d'un tableau:

~set('tab_list[clef_un]','valeur_un')
~set('tab_list[clef_deux]','valeur_deux')
~set('tab_list[clef_trois]','valeur_trois')

~array_list(~get('tab_list'),0,,'LM','la clef est ~array_fld('key') et la valeur est ~array_fld('current')<br />')

Le tableau 'tab_list' est créé puis listé. L'appel de cette fonction comporte juste le sélecteur LM qui a pour valeur:

la clef est ~array_fld('key') et la valeur est ~array_fld('current')<br />

La fonction ~array_fld() est une fonction associée à la fonction ~array_list(). Chaque fonction de traitement de liste a une et parfois plusieurs fonctions associées.

Ces fonctions ne peuvent être appelées qu'à l'intérieur d'un sélecteur parce qu'elles permettent d'obtenir des informations sur l'élément qui est en cours de traitement. En l'occurrence, ~array_fld('key') permet de connaitre la clef de l'élément du tableau en cours de traitement et ~array_fld('current') retourne l'élément en cours de traitement.

Le code précédent retourne donc:


la clef est clef_un et la valeur est valeur_un
la clef est clef_deux et la valeur est valeur_deux
la clef est clef_trois et la valeur est valeur_trois

Les autres sélecteurs permettent de gérer des cas particuliers. Ainsi LF et LL sont évalués respectivement avant le premier élément et après le dernier élément.

Exemple:

~array_list(~get('tab_list'),0,,
  'LM','la clef est ~array_fld('key') et la valeur est ~array_fld('current')<br />',
  'LF','ce sélecteur est évalué avant le premier élément<br />',
  'LL','ce sélecteur est évalué après le dernier élément<br />'
  )

=>

ce sélecteur est évalué avant le premier élément
la clef est clef_un et la valeur est valeur_un
la clef est clef_deux et la valeur est valeur_deux
la clef est clef_trois et la valeur est valeur_trois
ce sélecteur est évalué après le dernier élément

Liste des sélecteurs:

LM : évalué pour chacun des éléments
LF : évalué avant le premier élément
LL : évalué après le dernier élément
LR : évalué pour le premier élément. Si ce sélecteur est présent le sélecteur LM n'est pas évalué pour le premier élément.
LN : évalué pour le dernier élément. Si ce sélecteur est présent le sélecteur LM n'est pas évalué pour le dernier élément.
LS : évalué entre chaque élément
LD : évalué dans le cas où la liste ne contient aucun élément
L1 : évalué dans le cas où la liste n'est constituée que d'un seul élément. Si ce sélecteur est présent le sélecteur LM n'est pas évalué pour le dernier élément.
LE : évalué dans le cas où une erreur survient dans le traitement de la liste. (problème dans une requête SQL par exemple)

Revenir en haut

Menu

Documentation

Projets Templeet

Syntaxe

Les blocs d'instructions

Les "vrais" commentaires

set et get

array

rem

noeval

include et parseparam

eval

if

switch

while

for

empty

inc dec

integer

executedtime

createdir

compactdir

Présentations des fonctions de listes

Les sélecteurs de présentation des listes