|
About
Community
Docs
Tools
Comparisons
Site Translations
|
|
A propos de ce document
|
Le Guide de l'utilisateur Velocity a pour but d'aider les concepteurs de page et les fournisseurs de contenu ? se
familiariser avec Velocity et avec la syntaxe de son langage de script, simple mais puissant, le Velocity Template
Language (VTL). Beaucoup d'exemples dans ce guide concernent l'utilisation de Velocity pour l'inclusion de contenu
dynamique dans des sites web, mais tous les exemples du VTL pourraient aussi bien s'appliquer ? d'autres pages ou
gabarits.
Merci de choisir Velocity!
|
|
|
Velocity, qu'est-ce que c'est?
|
Velocity est un moteur de substitution, bas? sur Java. Il permet aux concepteurs de pages web de faire r?f?rence
? des m?thodes d?finies dans du code Java. Les concepteurs de pages peuvent travailler en ?quipe avec des
programmeurs Java pour d?velopper des sites web dans l'architecture MVC (Mod?le-Vue-Contr?leur), ce qui signifie
que les infographistes peuvent se concentrer sur la cr?ation d'un site au d?sign attractif et les programmeurs
peuvent se consacrer enti?rement ? l'?criture de code de qualit?. Velocity s?pare le code Java des pages web,
ce qui rend le site plus facile ? maintenir dans le long terme et fournit une alternative r?aliste aux
Java Server Pages (JSPs) ou ?
PHP.
Velocity peut ?tre utilis? pour g?n?rer des pages web, du SQL, du Postcript et tout ce qui peut ?tre g?n?r? ? partir
d'un gabarit. Vous pouvez l'utiliser comme un utilitaire ind?pendant pour g?n?rer du code source ou des ?tats
imprim?s, ou bien comme un composant int?gr? dans d'autres syst?mes. A terme, Velocity fournira les services
d'inclusion pour le framework d'applications web Turbine.
Velocity et Turbine fournissent un service d'inclusion qui permettra de d?velopper des applications web dans une
v?ritable architecture MVC.
|
|
|
Qu'est-ce que Velocity peut faire pour moi?
|
|
L'exemple de MudStore
|
Supposons que vous soyez un concepteur de pages pour une boutique en ligne sp?cialis?e dans la vente de terre cuite. Appelons-la "The Online Mud Store". Les affaires marchent fort. Les clients passent commande pour diff?rents types et diverses quantit?s de terre cuite. Ils s'identifient sur votre site avec un nom d'utilisateur et un mot de passe, ce qui leur permet de suivre leurs commandes et d'en passer de nouvelles. Pour l'instant, vous vendez de la glaise Terracotta, un produit qui marche bien. Quelques-uns de vos clients ach?tent r?guli?rement de la glaise Bright Red, que vous vendez aussi, bien s?r, mais qui n'a pas autant la cote et qui se trouve d'habitude rel?gu?e dans les marges de vos pages. Les informations relatives ? chaque client sont suivies dans votre base de donn?es, et donc un jour la question se pose: pourquoi ne pas utiliser Velocity pour proposer des offres sp?ciales ? une client?le cibl?e, celle qui est la plus int?ress?e ? un type de marchandise?
Avec Velocity, il est tr?s facile de personnaliser les pages web pour certains visiteurs. En tant que concepteur de pages du MudRoom, vous voulez maintenant r?aliser la page d'accueil que verra votre client apr?s s'?tre identifi? sur votre site.
Vous tenez une r?union avec les ing?nieurs d?veloppement de votre entreprise, et tout le monde s'accorde sur le fait que $customer contiendra les informations relatives au client qui s'est connect? et $mudsOnSpecial tous les types de terre disponibles ? la vente en ce moment. L'objet $flogger contient diff?rentes m?thodes pour aider ? la promotion de certains produits. Pour la t?che qui nous concerne, occupons-nous seulement de ces trois r?f?rences. Rappelez-vous que vous n'avez pas ? vous soucier de la mani?re dont les d?veloppeurs vont extraire les informations n?cessaires de la base de donn?es, vous supposez seulement que ?a fonctionne -- ce qui vous permet de vous occuper de votre part du boulot et les d?veloppeurs de la leur.
Vous pouvez inclure l'instruction VTL suivante dans votre page web:
 |
|
|
|
<HTML>
<BODY>
Hello $customer.Name!
<table>
#foreach( $mud in $mudsOnSpecial )
#if ( $customer.hasPurchased($mud) )
<tr>
<td>
$flogger.getPromo( $mud )
</td>
</tr>
#end
#end
</table>
|
|
|
|
|
Les d?tails pr?cis de l'instruction foreach seront d?crits un peu plus loin; ce qui compte pour l'instant, c'est l'impact que peut avoir ce petit script sur votre site web. Quand un client qui appr?cie habituellement la glaise BrightRed se connecte, et que ce produit est en vente, c'est ce qu'il verra en premier lieu. Si un client qui a achet? beaucoup de Terracotta se connecte, c'est la vente de Terracotta qui sera affich?e en t?te et au centre. La flexibilit? de Velocity est tr?s grande, limit?e seulement par votre cr?ativit?.
Dans le manuel de r?f?rence du VTL, vous trouverez la documentation de beaucoup d'autres ?l?ments de Velocity, qui ensemble vous donnent la puissance et la souplesse dont vous avez besoin pour faire de votre site web une pr?sence sur le web. Lorsque vous deviendrez de plus en plus familiers avec ces ?l?ments, vous mettrez ? votre service toute la puissance de Velocity.
|
|
|
|
|
Introduction au Velocity Template Language (VTL)
|
Le Velocity Template Language (VTL) a ?t? con?u pour inclure du contenu dynamique dans une page web de la mani?re la plus facile, la plus simple et la plus propre. M?me un infographiste avec peu ou pas de bagage en programmation sera rapidement capable d'utiliser le VTL pour incorporer du contenu dynamique dans un site web.
VTL utilise des r?f?rences pour embarquer du contenu dynamique dans un site web, et une variable est un type de r?f?rence. Une variable fait r?f?rence ? quelque chose qui est d?fini dans le code Java, ou elle peut prendre sa valeur d'une instruction VTL dans la page web. Voici un exemple d'instruction VTL
Cette instruction VTL -- comme toutes les instructions VTL d'ailleurs -- commence par le caract?re # et
contient une directive set. Quand un visiteur demande votre page web, le moteur de substitution Velocity
(Velocity Templating Engine) recherche dans votre page tous les caract?res #, d?termine lesquels marquent le
d?but d'instructions VTL, et quels caract?res # n'ont rien ? voir avec le VTL.
Le caract?re #est suivi d'une directive, set. La directive setutilise une expression
(entre parenth?ses) -- une ?quation qui assigne une valeur? une variable. La variable est ?crite
? gauche et sa valeur ? droite; les deux sont s?par?s par un caract?re =.
Dans l'exemple ci-dessus, la variable est $aet la valeur est Velocity. Cette variable, comme toutes
les r?f?rences, commence par le caract?re $. Les valeurs sont toujours entour?es d'apostrophes;
dans Velocity, il n'y a jamais de confusion possible entre les types de donn?es puisque seules des cha?nes de
caract?res (informations de type texte) peuvent ?tre pass?es ? des variables.
Le truc suivant peut ?tre utile pour mieux comprendre comment Velocity fonctionne :Les r?f?rences commencent
par $ et sont utilis?es pour r?cup?rer quelque chose. Les directives commencent par #et sont
utilis?es pour faire quelque chose.
Dans l'exemple ci-dessus, #setest utilis? pour assigner une valeur ? une variable. La variable, $a,
peut alors ?tre utilis?e dans le gabarit pour produire "Velocity".
|
|
|
Les commentaires
|
Les commentaires permettent d'inclure du texte descriptif qui ne sera pas report? dans la sortie du moteur
d'inclusion. Les commentaires sont une mani?re utile de se rappeler et d'expliquer ? d'autres ce que font les
instructions VTL, ou ? toute autre fin utile. Voici un exemple de commentaire en VTL.
|
|
|
|
## Ceci est un commentaire d'une seule ligne.
|
|
|
|
|
Un commentaire d'une ligne commence par ## et se termine ? la fin de la ligne. Si vous voulez ?crire
quelques lignes de commentaires, pas besoin de multiplier ces commentaires d'une ligne. Les commentaires multi-lignes,
qui commencent par #* et se terminent par *#, sont l? pour ce cas de figure.
|
|
|
|
Ceci est du texte ? l'ext?rieur du commentaire multi-lignes. Les visiteurs du site peuvent le voir.
#*
Ici commence donc un commentaire de plusieurs lignes.
Les visiteurs du site ne le verront pas, parce que le
moteur de substitution de Velocity
(Velocity Templating Engine) l'ignore.
*#
Ce texte-ci est ? l'ext?rieur du commentaire: il est visible.
|
|
|
|
|
Voici quelques exemples pour clarifier la mani?re dont les commentaires d'une et plusieurs lignes fonctionnent:
|
|
|
|
Ce texte est visible. ## Ce texte ne l'est pas.
Ce texte est visible.
Ce texte est visible. #* Ce texte, qui fait partie d'un commentaire
de plusieurs lignes, n'est pas visible. Ce texte n'est pas visible;
il faut aussi partie du commentaire multi-lignes.
Ce texte n'est toujours pas visible. *# Ce texte est ? l'ext?rieur
du commentaire, il est donc visible.
## Ce texte n'est pas visible.
|
|
|
|
|
Il y a un troisi?me type de commentaires, le bloc de commentaires VTL, que vous pouvez utiliser pour ?crire des
informations telles que l'auteur du document ou la version.
|
|
|
|
#**
Ceci est un bloc de commentaires VTL, qui
peut ?tre utilis? pour inscrire des informations
telles que l'auteur ou la version du document.
@author
@version 5
*#
|
|
|
|
|
|
|
|
Les r?f?rences
|
Il y a trois types de r?f?rences en VTL: les variables, les propri?t?s et les m?thodes. En tant que concepteur
utilisant le VTL, vous et vos ing?nieurs devez vous mettre d'accord sur les noms des r?f?rences, de mani?re ? pouvoir
les utiliser correctement dans vos gabarits de pages.
Tout ce qui entre et sort d'une r?f?rence est trait? comme un objet cha?ne de caract?res. S'il y a un objet qui
repr?sente $foo(un objet Integer par exemple), Velocity appellera sa m?thode .toString()
pour convertir l'objet en String.
Variables
La notation abr?g?e pour une variable consiste en un caract?re "$" initial suivi d'un IdentificateurVTL.
Un identificateur VTL doit commencer par une lettre (a .. z ou A .. Z). Le reste des caract?res est limit? aux types
suivants:
- lettre (a .. z, A .. Z)
- chiffre (0 .. 9)
- tiret ("-")
- trait de soulignement ("_")
Voici quelques exemples de r?f?rences valides en VTL:
|
|
|
|
$foo
$mudSlinger
$mud-slinger
$mud_slinger
$mudSlinger1
|
|
|
|
|
Lorsque VTL r?f?rence une variable, telle que $foo, la variable peut prendre sa valeur soit d'une directive
set dans le gabarit, soit d'un programme Java. Par exemple, si la variable Java $foo a la valeur
bar ? la ligne ? laquelle il est fait appel au gabarit, bar remplace toutes les instances de
$foo dans la page web. Autrement, si j'inclus l'instruction
la sortie sera la m?me pour toutes les instances de $foo qui suivent cette directive.
Propri?t?s
Les propri?t?s sont la seconde esp?ce de r?f?rences en VTL et elles ont un format qui les distingue.
La notation abr?g?e consiste en un caract?re $ initial suivi d'un identifiant VTL, suivi d'un point (".")
et d'un autre identifiant VTL. Quelques exemples de r?f?rences valides de propri?t?s en VTL:
|
|
|
|
$customer.Address
$purchase.Total
|
|
|
|
|
Prenons le premier exemple, $customer.Address. Cette expression peut avoir deux significations.
Elle peut signifier: "Regarde dans la table de hachage identifi?e par customer et renvoie la valeur associ?e
? la cl? Address. Mais $customer.Address peut aussi faire r?f?rence ? une m?thode (les r?f?rences
qui d?signent des m?thodes seront discut?es dans la section suivante); $customer.Address pourrait ?tre
une mani?re abr?g?e d'?crire $customer.getAddress(). Quand quelqu'un demande votre page, Velocity va
d?terminer laquelle de ces deux possibilit?s a un sens, et retournera la valeur appropri?e.
M?thodes
Une m?thode est d?finie dans le code Java et peut faire quelque chose d'utile, comme effectuer un calcul ou
prendre une d?cision. Les m?thodes sont des r?f?rences qui consistent en un caract?re "$" initial, suivi d'un
identifiant VTL, suivi d'un corps de m?thode. Un corps de m?thode VTL consiste en un identifiant VTL
suivi du caract?re parenth?se ouvrante ("("), ?ventuellement suivi d'une liste de param?tres, suivi du caract?re
parenth?se fermante (")"). Quelques exemples de r?f?rences de m?thodes valides en VTL:
|
|
|
|
$customer.getAddress()
$purchase.getTotal()
$page.setTitle( "My Home Page" )
$person.setAttributes( ["Strange", "Weird", "Excited"] )
|
|
|
|
|
Les deux premiers exemples -- $customer.getAddress() et
$purchase.getTotal() -- peuvent avoir l'air semblables ? ceux utilis?s dans la section pr?c?dente,
consacr?e aux Propri?t?s, $customer.Address et
$purchase.Total. Si vous avez devin? que ces exemples sont li?s entre eux d'une mani?re ou d'une autre,
vous avez raison!
Les propri?t?s VTL peuvent ?tre utilis?es comme une notation abr?g?e pour des m?thodes VTL.
La propri?t? $customer.Address a exactement le m?me effet que l'utilisation de la m?thode
$customer.getAddress(). Il est g?n?ralement pr?f?rable d'utiliser une propri?t? lorsqu'il y en a une
de disponible. La principale diff?rence entre les Propri?t?s et les M?thodes est que pour les m?thodes, on peut
sp?cifier une liste de param?tres.
La notation abr?g?e peut ?tre utilis?e pour les m?thodes suivantes
|
|
|
|
$sun.getPlanets()
$annelid.getDirt()
$album.getPhoto()
|
|
|
|
|
On s'attend logiquement ? ce que ces m?thodes retournent les noms des plan?tes qui tournent autour du soleil,
qu'elles nourissent notre ver de terre ou prennent une photo dans un album. Il n'y a que la notation longue
qui fonctionne pour les m?thodes suivantes:
|
|
|
|
$sun.getPlanet( ["Earth", "Mars", "Neptune"] )
## On ne peut pas passer une liste de param?tres avec $sun.Planets
$sisyphus.pushRock()
## Velocity suppose que je veux dire $sisyphus.getRock()
$book.setTitle( "Homage to Catalonia" )
## On ne peut pas passer une liste de param?tres
|
|
|
|
|
Notation formelle des r?f?rences
Dans les exemples ci-dessus, nous avons utilis? la notation abr?g?e pour les r?f?rences, mais il y a aussi
une notation formelle pour les r?f?rences, illustr?e ci-dessous:
|
|
|
|
${mudSlinger}
${customer.Address}
${purchase.getTotal()}
|
|
|
|
|
Dans presque tous les cas, vous utiliserez pour les r?f?rences la notation abr?g?e, mais dans certains cas
la notation formelle est requise pour une ex?cution correcte.
Supposons que vous soyez en train de construire dynamiquement une phrase dans laquelle $vice doit ?tre
utilis? comme base pour la construction d'un nom de la phrase. Le but est de permettre ? quelqu'un de choisir le mot
de base et de produire l'un des deux r?sultats suivants:
"Jacques est pyromane" ou "Jacques est cleptomane".
L'utilisation de la notation abr?g?e ne convient pas pour cette t?che. Consid?rons en effet l'exemple suivant:
|
|
|
|
Jacques est un $vicemane.
|
|
|
|
|
La syntaxe est ici ambigu?, et Velocity suppose que $vicemane, et non $vice, est l'identifiant
que vous pensiez utiliser. Ne trouvant pas de valeur pour $vicemane, il renverra $vicemane.
L'utilisation de la notation formelle peut r?soudre ce probl?me.
|
|
|
|
Jacques est un ${vice}mane.
|
|
|
|
|
Cette fois Velocity sait que $vice, et non $vicemane, est la r?f?rence. La notation formelle est
souvent utile quand les r?f?rences sont directement adjacentes ? du texte au sein d'un gabarit.
Notation silencieuse des r?f?rences
Lorsque Velocity rencontre une r?f?rence non d?finie, son comportement normal est de produire une image de la
r?f?rence. Par exemple, supposons que la r?f?rence suivante apparaisse dans un gabarit VTL:
|
|
|
|
<input type="text" name="email" value="$email"/>
|
|
|
|
|
Quand le formulaire est charg? pour la premi?re fois, la variable r?f?renc?e par $email n'a pas de valeur,
mais vous pr?f?reriez un champ de texte vide ? la valeur "$email". L'utilisation de la notation silencieuse contourne
le comportement normal de Velocity; au lieu d'utiliser $email dans le code VTL, utilisez $!email.
L'exemple pr?c?dent ressemblerait donc ? ceci:
|
|
|
|
<input type="text" name="email" value="$!email"/>
|
|
|
|
|
A pr?sent, quand le formulaire est charg? pour la premi?re fois et que $email n'a toujours pas de valeur,
une cha?ne vide sera produite au lieu de "$email".
La notation formelle et la notation silencieuse peuvent ?tre utilis?es ensemble, comme illustr? ci-dessous.
|
|
|
|
<input type="text" name="email" value="$!{email}"/>
|
|
|
|
|
|
|
|
Sortie litt?rale
|
VTL utilise des caract?res sp?ciaux, comme $ et # pour accomplir sa t?che; il faut donc prendre
quelques pr?cautions pour utiliser ces caract?res dans vos gabarits. Cette section est consacr?e ? l'?chappement
du caract?re $.
Devise
Il n'y a pas de probl?me particulier ? ?crire "J'ai achet? un sac de 2 kg de patates au march? de la ferme
pour seulement $2.50!". Comme dit plus haut, un identifiant VTL commence toujours par une lettre, majuscule ou
minuscule, et donc $2.50 ne serait pas pris par erreur pour une r?f?rence.
Echapper des r?f?rences VTL valides
Il peut se produire dans certains cas que Velocity se trouve induit en confusion. Echapper les
caract?res sp?ciaux est le meilleur moyen de traiter les caract?res sp?ciaux du VTL dans vos gabarits, et ceci se
fait en utilisant le caract?re backslash (\).
|
|
|
|
#set( $email = "foo" )
$email
|
|
|
|
|
Lorsque Velocity rencontre une r?f?rence ? $email dans votre gabarit VTL, il cherche dans le contexte la
valeur correspondante. Ici, la sortie sera foo, parce que $email est d?fini. Si $email
n'?tait pas d?fini, la sortie serait $email.
Supposons que $email soit d?fini (par exemple, cette r?f?rence a la valeur foo)
et que vous vouliez produire $email. Il y a diff?rentes mani?res de le faire, mais la plus simple est
d'utiliser le caract?re d'?chappement.
|
|
|
|
## La ligne qui suit d?finit $email dans ce gabarit:
#set( $email = "foo" )
$email
\$email
\\$email
\\\$email
|
|
|
|
|
sera rendu comme:
Notez que le caract?re \ s'applique au $ ? partir de la gauche. Cette r?gle d'application
? partir de la gauche fait que \\\$email est rendu comme \\$email. Comparons maintenant ces examples
? ce qui se passe lorsque $email n'est pas d?fini.
|
|
|
|
$email
\$email
\\$email
\\\$email
|
|
|
|
|
sera rendu comme:
|
|
|
|
$email
\$email
\\$email
\\\$email
|
|
|
|
|
Remarquez comment Velocity traite les r?f?rences d?finies diff?remment de celles qui n'ont pas ?t? d?finies.
Voici par exemple une directive set qui donne ? $foo la valeur gibbous.
|
|
|
|
#set( $foo = "gibbous" )
$moon = $foo
|
|
|
|
|
La sortie sera: $moon = gibbous -- o? $moon est rendu litt?ralement puisqu'il n'est pas d?fini,
alors que gibbous est rendu au lieu de $foo.
Il est aussi possible d'?chapper les directives VTL; ceci est d?crit plus en d?tail dans la section Directives.
|
|
|
Directives
|
Les r?f?rences permettent aux concepteurs de pages de g?n?rer du contenu dynamique pour des sites web alors que les
directives -- des ?l?ments de script, faciles ? utiliser, qui peuvent ?tre mis en oeuvre pour manipuler de
mani?re cr?ative la sortie d'un code Java -- permet aux concepteurs de vraiment prendre en charge l'apparence et le
contenu du site web.
#set
La directive #set s'utilise pour donner une valeur ? une r?f?rence. Une valeur peut ?tre assign?e soit ? une
r?f?rence de type variable, soit ? une r?f?rence de type propri?t?, et ceci toujours entre parenth?ses, comme montr?
ici:
|
|
|
|
#set( $primate = "monkey" )
#set( $customer.Behavior = $primate )
|
|
|
|
|
Le c?t? gauche (left hand side -- LHS) de l'assignation doit ?tre une r?f?rence variable ou propri?t?. Le membre de
droite (right hand side -- RHS) peut ?tre de l'un des types suivants:
- Une r?f?rence (variable)
- Une cha?ne de caract?res litt?rale
- Une r?f?rence (propri?t?)
- Une r?f?rence ? une m?thode
- Un nombre litt?ral
- Une ArrayList
Les exemples suivants montrent chacun des types susmentionn?s:
|
|
|
|
#set( $monkey = $bill ) ## r?f?rence (variable)
#set( $monkey.Friend = "monica" ) ## cha?ne de caract?res litt?rale
#set( $monkey.Blame = $whitehouse.Leak ) ## r?f?rence (propri?t?)
#set( $monkey.Plan = $spindoctor.weave($web) ) ## r?f?rence ? une m?thode
#set( $monkey.Number = 123 ) ## nombre litt?ral
#set( $monkey.Say = ["Not", $my, "fault"] ) ## ArrayList
|
|
|
|
|
NOTE: Dans le dernier exemple, les ?l?ments d?finis avec l'op?rateur [..] sont accessibles en utilisant les m?thodes
d?finies dans la classe ArrayList. Ainsi, par exemple, on peut acc?der au premier ?l?ment en ?crivant
$monkey.Say.get(0)
Le membre de droite peut aussi ?tre une expression arithm?tique simple:
|
|
|
|
#set( $value = $foo + 1 )
#set( $value = $bar - 1 )
#set( $value = $foo * $bar )
#set( $value = $foo / $bar )
|
|
|
|
|
Si le membre de droite est une r?f?rence ? une m?thode ou ? une propri?t? dont la valeur est null, il ne
sera pas affect? au membre de gauche. Il n'est pas possible d'enlever une r?f?rence existante du contexte
par ce biais-l?. Ceci peut troubler les d?butants en Velocity. Par exemple:
|
|
|
|
#set( $result = $query.criteria("name") )
Le r?sultat de la premi?re requ?te est $result
#set( $result = $query.criteria("address") )
Le r?sultat de la seconde requ?te est $result
|
|
|
|
|
Si $query.criteria("name") renvoie la cha?ne "bill", et que $query.criteria("address") renvoie
null, le code VTL ci-dessus sera rendu de la mani?re suivante:
|
|
|
|
Le r?sultat de la premi?re requ?te est bill
Le r?sultat de la seconde requ?te est bill
|
|
|
|
|
Ceci induit en confusion les nouveaux venus, qui construisent des boucles #foreach qui tentent de faire
un #set sur une r?f?rence ? partir d'une r?f?rence ? une propri?t? ou une m?thode et testent imm?diatement
cette r?f?rence avec une directive #if. Par exemple:
|
|
|
|
#set( $criteria = ["name", "address"] )
#foreach( $criterion in $criteria )
#set( $result = $query.criteria($criterion) )
#if( $result )
Query was successful
#end
#end
|
|
|
|
|
Dans l'exemple ci-dessus, il ne serait pas avis? de se reposer sur l'?valuation de $result pour d?terminer
si une requ?te a ?t? couronn?e de succ?s. Une fois que $result a re?u une valeur par un #set
(et a donc ?t? ajout? au contexte), il ne peut pas recevoir la valeur null (et se trouver ainsi enlev? du
contexte). Les d?tails des directives #if et #foreach sont trait?s plus loin dans ce document.
Une solution ? ce probl?me serait de pr?-positionner $result ? false. Si l'appel ?
$query.criteria() ?choue, il est possible de faire la v?rification.
|
|
|
|
#set( $criteria = ["name", "address"] )
#foreach( $criterion in $criteria )
#set( $result = false )
#set( $result = $query.criteria($criterion) )
#if( $result )
La requ?te a abouti correctement
#end
#end
|
|
|
|
|
Contrairement ? d'autres directives Velocity, la directive #set n'a pas d'instruction #end.
Cha?nes de caract?res litt?rales
Lorsque vous utilisez la directive #set, les cha?nes de caract?res litt?rales d?limit?es par des guillements
sont interpr?t?es et rendues de la mani?re suivante:
|
|
|
|
#set( $directoryRoot = "www" )
#set( $templateName = "index.vm" )
#set( $template = "$directoryRoot/$templateName" )
$template
|
|
|
|
|
La sortie produite sera
Toutefois, lorsque la cha?ne de caract?res litt?rale est d?limit?e par des apostrophes, elle n'est pas interpr?t?e.
|
|
|
|
#set( $foo = "bar" )
$foo
#set( $blargh = '$foo' )
$blargh
|
|
|
|
|
Ce qui est rendu de la mani?re suivante:
Cette caract?ristique d'utilisation des apostrophes pour rendre du texte non interpr?t? est le comportement par d?faut
de Velocity. Ce comportement peut ?tre chang? en ?ditant le fichier velocity.properties et en y ?crivant
l'entr?e: stringliterals.interpolate=false.
|
|
|
Conditions
|
If / ElseIf / Else
La directive #if de Velocity permet ? du texte d'?tre inclus ? la g?n?ration d'une page web seulement si la
condition qui suit l'instruction if est v?rifi?e. Par exemple:
|
|
|
|
#if( $foo )
<strong>Velocity!</strong>
#end
|
|
|
|
|
La variable $foo est ?valu?e pour d?terminer si elle vaut true, ce qui se produit dans l'une des deux cas
suivants; (i) $foo est une variable bool?enne (true/false) dont la valeur est vrai (true), ou (ii) la valeur
de $foo est diff?rente de null. On se rappelle que le contexte de Velocity ne contient que des Objets,
et donc lorsqu'on dit un bool?en, il sera repr?sent? comme un objet de la classe Boolean contenant la valeur logique
appropri?e.
Ce qui est contenu entre l'instruction #if et l'instruction #end sera produit en sortie si la
condition est ?valu?e comme vraie. Dans l'exemple pr?c?dent, si $foo est true, la sortie sera: "Velocity!".
A l'inverse, si $foo a la valeur null, ou si c'est un bool?en de valeur false, l'instruction est ?valu?e
comme fausse, et il n'y a pas de sortie produite.
Un ?l?ment #elseif ou #else peut ?tre utilis? dans la directive #if.
Notez que le moteur Velocity (Velocity Template Engine) s'arr?tera ? la premi?re expression ?valu?e comme vraie.
Dans l'exemple suivant, supposons que $foo vaut 15 et que $bar vaut 6.
|
|
|
|
#if( $foo < 10 )
<strong>Go North</strong>
#elseif( $foo == 10 )
<strong>Go East</strong>
#elseif( $bar == 6 )
<strong>Go South</strong>
#else
<strong>Go West</strong>
#end
|
|
|
|
|
Dans cet exemple, $foo est plus grand que 10, donc les deux premi?res comparaisons ?chouent. Ensuite,
$bar est compar? ? 6, ce qui donne vrai, et dont la sortie produit est Go South.
Notez que pour l'instant, dans Velocity, les comparaisons num?riques sont restreintes aux comparaisons d'entiers
(Integers) -- tout le reste sera ?valu? comme faux. La seule exception est l'?galit? '==': dans ce cas Velocity teste
si les objets de chaque c?t? de '==' sont de la m?me classe.
Op?rateurs logiques et relationnels
Velocity utilise l'op?rateur d'?quivalence pour d?terminer les relations entre des variables. Voici un exemple simple pour illustrer la mani?re d'utiliser l'op?rateur d'?quivalence.
|
|
|
|
#set ($foo = "deoxyribonucleic acid")
#set ($bar = "ribonucleic acid")
#if ($foo == $bar)
Dans ce cas, il est clair qu'ils ne sont pas ?quivalents. Donc...
#else
Ils ne sont pas ?quivalents et c'est ceci qui sera produit en sortie.
#end
|
|
|
|
|
Velocity a aussi des op?rateurs ET, OU et NON. Pour plus d'informations, r?f?rez-vous au
VTL Reference Guide (en anglais).
Ci-dessous, quelques exemples illustrent l'utilisation des op?rateurs logiques ET, OU et NON.
|
|
|
|
##ET logique
#if( $foo && $bar )
<strong> Ceci ET cela.</strong>
#end
|
|
|
|
|
La directive #if() ne sera ?valu?e comme true que si $foo et $bar sont
true tous les deux. Si $foo est false, l'expression sera globalement ?valu?e comme
false et $bar ne sera pas ?valu?. Si $foo vaut true, le moteur Velocity testera
la valeur de $bar; si $bar vaut true, alors l'expression dans son enti?ret? vaut
true et la sortie Ceci ET cela est produite. Si $bar est false,
alors il n'y aura pas de sortie produite puisque l'expression enti?re est fausse.
Les op?rateurs logiques OU fonctionnent de la m?me mani?re, si ce n'est qu'une seule des r?f?rences doit ?tre ?valu?e
? true pour que l'expression enti?re soit consid?r?e comme vraie. Voyez l'exemple suivant:
|
|
|
|
##OU logique
#if( $foo || $bar )
<strong>Ceci OU cela</strong>
#end
|
|
|
|
|
Si $foo vaut true, le moteur Velocity n'a pas besoin d'?valuer $bar; que $bar
soit vrai ou faux ne change rien ? l'affaire, l'expression sera vraie, et Ceci OU cela sera produit
en sortie. Mais si $foo est false, la valeur de $bar doit ?tre v?rifi?e.
Dans ce cas, si $bar est faux lui aussi, l'expression sera fausse et il n'y aura pas de sortie produite.
Sinon, si $bar est vrai, alors l'expression enti?re est vraie, et la sortie est
Ceci OU cela.
Avec l'op?rateur logique NON, il n'y a qu'un seul argument :
|
|
|
|
##NON logique
#if( !$foo )
<strong>PAS ?a</strong>
#end
|
|
|
|
|
Cette fois, si $foo vaut true, alors !$foo est ?valu? comme false,
et il n'y a pas de sortie. Si $foo est false, alors !$foo est ?valu? ? true
et PAS ?a est produit en sortie. Attention ? ne pas confondre ceci avec la
r?f?rence silencieuse $!foo que nous avons d?j? rencontr?e et qui repr?sente quelque chose de compl?tement
diff?rent.
|
|
|
