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