Note :

Les fonctions disponibles sont les suivantes:

• Les blocs d'instructions
• Les "vrais" commentaires
• 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

Les blocs d'instructions

Apostrophes et guillements :

Dans le langage Templeet les apostrophes ' ou les guillemets " sont 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]>.

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épararés par des virgules ",". Comme dans l'exemple ci dessous :

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

Le rendu de ce script sera :

5

Comme vous pouvez le remarquer la valeur 3 renvoyée par ~get("j") n'est pas affichée. En effet, seul le dernier bloc d'instruction est affiché.

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
*/
)

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.fr.html
~get('template') => template/doc.fr.html
~get('lang')     => fr
~get('templatedir')	      => template/
~get('actual_template')  => template/templeet_doc/core.fr.html

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

rem

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

~rem("c'est un peu bourrin comme approche mais ça devrait marcher...")

noeval

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

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.txt',"1er argument", 10)

Contenu du fichier "fichier.txt" :

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 ").

eval

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

if

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

switch

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

while

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

for

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

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

empty

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

plus minus multiple et divide

~plus(2,3)			=>	5

~minus(3,5)			=>	-2

~multiple(3,5)			=>	15

~divide(8,3)			=>	2.6666666666667

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

integer

~divide(8,3)			=>	2.6666666666667

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

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

equal notequal sup inf infequal supequal

~inf(2,2)			=>	0
~infequal(2,2)			=>	1

~sup(3,3)			=>	0
~supequal(3,3)			=>	1

~equal(3,5)			=>	0
~equal(3,3)			=>	1

~notequal(8,3)			=>	1
~notequal(8,8)			=>	0

and or xor not

~and(0,1)			=>	
~and(1,1)			=>	1

~or(0,0)			=>	
~or(1,0)			=>	1

~xor(0,1)			=>	1
~xor(1,1)			=>	0

~not(0)			=>	1
~not(1)			=>	0

executedtime

~executedtime()			=>	0.0833