File: user-guide_fr.xml

package info (click to toggle)
velocity 1.3.1-2
links: PTS
area: contrib
in suites: sarge
size: 4,164 kB
ctags: 2,922
sloc: java: 24,134; xml: 16,911; sh: 99; lisp: 53; makefile: 45
file content (1545 lines) | stat: -rw-r--r-- 71,765 bytes
parent folder | download | duplicates (2)
<?xml version="1.0" encoding="ISO-8859-1"?>

<document>
  <properties>
    <title>Guide de l'utilisateur Velocity</title>
    <author email="jvanzyl@zenplex.com">Velocity Documentation Team</author>
    <author email="jcastura@kw.igs.net">John Castura</author>
    <author email="jean-francois.elfouly@wanadoo.fr">Jean-Franois El Fouly</author>
  </properties>
<body>
    
<section name="Table des Matires">
      
<ol>
<li><a href="#A propos de ce document">A propos de ce document</a></li>
<li><a href="#Velocity, qu'est-ce que c'est?">Velocity, qu'est-ce que c'est?</a></li>
<li><a href="#Qu'est-ce que Velocity peut faire pour moi?">Qu'est-ce que Velocity peut faire pour moi?</a>
  <ol>
    <li><a href="#L'exemple de MudStore">L'exemple de MudStore</a></li>
  </ol>
</li>
<li><a href="#Introduction au Velocity Template Language (VTL)">Introduction au Velocity Template Language (VTL)</a></li>
<li><a href="#Hello Velocity World!">Hello Velocity World!</a></li>
<li><a href="#Les commentaires">Les commentaires</a></li>
<li><a href="#Les rfrences">Les rfrences</a>
  <ol>
    <li><a href="#Variables">Variables</a></li>
    <li><a href="#Proprits">Proprits</a></li>
    <li><a href="#Mthodes">Mthodes</a></li>
  </ol>
</li>
<li><a href="#Notation formelle des rfrences">Notation formelle des rfrences</a></li>
<li><a href="#Notation silencieuse des rfrences">Notation silencieuse des rfrences</a></li>
<li><a href="#Sortie littrale">Sortie littrale</a>
  <ol>
    <li><a href="#Devise">Devise</a></li>
    <li><a href="#Echapper des rfrences VTL valides">Echapper des rfrences VTL valides</a></li>
  </ol>
</li>
<li><a href="#Substitution de cas">Substitution de cas</a></li>
<li><a href="#Directives">Directives</a>
  <ol>
    <li><a href="#Set">Set</a></li>
    <li><a href="#Chanes de caractres littrales">Chanes de caractres littrales</a></li>
    <li><a href="#Conditions">Conditions</a>
      <ol>
        <li><a href="#Oprateurs relationnels et logiques">Oprateurs relationnels et logiques</a></li>
      </ol>
    </li>
    <li><a href="#Boucles">Boucles</a></li>
    <li><a href="#Include">Include</a></li>
    <li><a href="#Parse">Parse</a></li>
    <li><a href="#Stop">Stop</a></li>
    <li><a href="#Velocimacros">Velocimacros</a></li>
  </ol>
</li>
<li><a href="#Echappement des directives VTL">Echappement des directives VTL</a></li>
<li><a href="#VTL: Questions de format">VTL: Questions de format</a></li>
<li><a href="#Autres caractristiques et sujets divers">Autres caractristiques et sujets divers</a>
  <ol>
    <li><a href="#Math">Math</a></li>
    <li><a href="#Oprateur de porte (range)">Oprateur de porte (range)</a></li>
    <li><a href="#Questions pointues: Echappement et !">Questions pointues: Echappement et !</a></li>
    <li><a href="#Complments divers sur les Velocimacros">Complments divers sur les Velocimacros</a></li>
    <li><a href="#Concatnation de chanes">Concatnation de chanes</a></li>
  </ol>
</li>
<li><a href="#Donnez votre avis">Donnez votre avis</a></li>
</ol>
</section>

<section name="A propos de ce document">
  <p>
    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.
  </p>
  <p>Merci de choisir Velocity!</p>
</section>

<section name="Velocity, qu'est-ce que c'est?">
  <p>
    Velocity est un moteur de substitution, bas sur Java. Il permet aux concepteurs de pages web de faire rfrence
     des mthodes dfinies dans du code Java. Les concepteurs de pages peuvent travailler en quipe avec des
    programmeurs Java pour dvelopper des sites web dans l'architecture MVC (Modle-Vue-Contrleur), ce qui signifie
    que les infographistes peuvent se concentrer sur la cration d'un site au dsign attractif et les programmeurs
    peuvent se consacrer entirement  l'criture de code de qualit. Velocity spare le code Java des pages web,
    ce qui rend le site plus facile  maintenir dans le long terme et fournit une alternative raliste aux
    <a href="http://java.sun.com/products/jsp/">Java Server Pages</a> (JSPs) ou 
    <a href="http://www.php.net/">PHP</a>.
  </p>
  <p>
    Velocity peut tre utilis pour gnrer des pages web, du SQL, du Postcript et tout ce qui peut tre gnr  partir
    d'un gabarit. Vous pouvez l'utiliser comme un utilitaire indpendant pour gnrer du code source ou des tats
    imprims, ou bien comme un composant intgr dans d'autres systmes. A terme, Velocity fournira les services
    d'inclusion pour le framework d'applications web <a href="http://java.apache.org/turbine/">Turbine</a>.
    Velocity et Turbine fournissent un service d'inclusion qui permettra de dvelopper des applications web dans une
    vritable architecture MVC.
  </p>
</section>

<section name="Qu'est-ce que Velocity peut faire pour moi?">
  <subsection name="L'exemple de MudStore">
    <p>Supposons que vous soyez un concepteur de pages pour une boutique en ligne spcialise dans la vente de terre cuite. Appelons-la "The Online Mud Store". Les affaires marchent fort. Les clients passent commande pour diffrents types et diverses quantits 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 achtent rgulirement de la glaise Bright Red, que vous vendez aussi, bien sr, mais qui n'a pas autant la cote et qui se trouve d'habitude relgue dans les marges de vos pages. Les informations relatives  chaque client sont suivies dans votre base de donnes, et donc un jour la question se pose: pourquoi ne pas utiliser Velocity pour proposer des offres spciales  une clientle cible, celle qui est la plus intresse  un type de marchandise?</p>
    <p>Avec Velocity, il est trs facile de personnaliser les pages web pour certains visiteurs. En tant que concepteur de pages du MudRoom, vous voulez maintenant raliser la page d'accueil que verra votre client aprs s'tre identifi sur votre site. </p>
    <p>Vous tenez une runion avec les ingnieurs dveloppement de votre entreprise, et tout le monde s'accorde sur le fait que <em>$customer</em> contiendra les informations relatives au client qui s'est connect et <em>$mudsOnSpecial</em> tous les types de terre disponibles  la vente en ce moment. L'objet <em>$flogger</em> contient diffrentes mthodes pour aider  la promotion de certains produits. Pour la tche qui nous concerne, occupons-nous seulement de ces trois rfrences. Rappelez-vous que vous n'avez pas  vous soucier de la manire dont les dveloppeurs vont extraire les informations ncessaires de la base de donnes, vous supposez seulement que a fonctionne -- ce qui vous permet de vous occuper de votre part du boulot et les dveloppeurs de la leur.</p>
    <p>Vous pouvez inclure l'instruction VTL suivante dans votre page web:</p>
    <source><![CDATA[
<HTML>
<BODY>
Hello $customer.Name!
<table>
#foreach( $mud in $mudsOnSpecial )
   #if ( $customer.hasPurchased($mud) )
      <tr>
        <td>
          $flogger.getPromo( $mud )
        </td>
      </tr>
   #end
#end
</table>
]]>
    </source>
    <p>Les dtails prcis de l'instruction <em>foreach</em> seront dcrits 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 apprcie 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 affiche en tte et au centre. La flexibilit de Velocity est trs grande, limite seulement par votre crativit.</p>
    <p>Dans le manuel de rfrence du VTL, vous trouverez la documentation de beaucoup d'autres lments de Velocity, qui ensemble vous donnent la puissance et la souplesse dont vous avez besoin pour faire de votre site web une <em>prsence</em> sur le web. Lorsque vous deviendrez de plus en plus familiers avec ces lments, vous mettrez  votre service toute la puissance de Velocity.</p>
  </subsection>
</section>

<section name="Introduction au Velocity Template Language (VTL)">
  <p>Le Velocity Template Language (VTL) a t conu pour inclure du contenu dynamique dans une page web de la manire la plus facile, la plus simple et la plus propre. Mme 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.</p>
  <p>VTL utilise des <em>rfrences</em> pour embarquer du contenu dynamique dans un site web, et une variable est un type de rfrence. Une variable fait rfrence  quelque chose qui est dfini dans le code Java, ou elle peut prendre sa valeur d'une <em>instruction</em> VTL dans la page web. Voici un exemple d'instruction VTL</p>
  <source><![CDATA[
#set( $a = "Velocity" )
]]></source>
  <p>
    Cette instruction VTL -- comme toutes les instructions VTL d'ailleurs -- commence par le caractre <em>#</em> et
    contient une directive <em>set</em>. Quand un visiteur demande votre page web, le moteur de substitution Velocity
    (Velocity Templating Engine) recherche dans votre page tous les caractres <em>#</em>, dtermine lesquels marquent le
    dbut d'instructions VTL, et quels caractres <em>#</em> n'ont rien  voir avec le VTL.
  </p>
  <p>
    Le caractre <em>#</em>est suivi d'une directive, <em>set</em>. La directive <em>set</em>utilise une expression
    (entre parenthses) -- une quation qui assigne une <em>valeur</em> une <em>variable</em>. La variable est crite
     gauche et sa valeur  droite; les deux sont spars par un caractre <em>=</em>.
  </p>
  <p>
    Dans l'exemple ci-dessus, la variable est <em>$a</em>et la valeur est <em>Velocity</em>. Cette variable, comme toutes
    les rfrences, commence par le caractre <em>$</em>. Les valeurs sont toujours entoures d'apostrophes;
    dans Velocity, il n'y a jamais de confusion possible entre les types de donnes puisque seules des chanes de
    caractres (informations de type texte) peuvent tre passes  des variables.
  </p>
  <p>
    Le truc suivant peut tre utile pour mieux comprendre comment Velocity fonctionne :<strong>Les rfrences commencent
    par <em>$</em> et sont utilises pour rcuprer quelque chose. Les directives commencent par <em>#</em>et sont
    utilises pour faire quelque chose.</strong>
  </p>
  <p>
    Dans l'exemple ci-dessus, <em>#set</em>est utilis pour assigner une valeur  une variable. La variable, <em>$a</em>,
    peut alors tre utilise dans le gabarit pour produire "Velocity".
  </p>
</section>

<section name="Hello Velocity World!">
  <p>
    Une fois qu'une valeur a t assigne  une variable, vous pouvez faire rfrence  cette variable n'importe o dans
    votre document HTML. Dans l'exemple suivant, une valeur est assigne  <em>$foo</em> et rfrence plus loin.
  </p>
  <source><![CDATA[
<html>
<body>
#set( $foo = "Velocity" )
Hello $foo World!
</body>
</html>
]]></source>
  <p>Le rsultat est une page web o s'imprime "Hello Velocity World!".</p>
  <p>
    Pour rendre les instructions contenant des directives VTL plus lisibles, nous vous encourageons  dbuter chaque
    instruction VTL sur une nouvelle ligne -- mais vous n'tes pas oblig de procder ainsi. La directive <em>set</em>
    sera revue avec davantage de dtails plus loin.
  </p>
</section>

<section name="Les commentaires">
  <p>
    Les commentaires permettent d'inclure du texte descriptif qui ne sera pas report dans la sortie du moteur
    d'inclusion. Les commentaires sont une manire 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.
  </p>
  <source><![CDATA[
## Ceci est un commentaire d'une seule ligne.
]]></source>
  <p>
    Un commentaire d'une ligne commence par <em>##</em> 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 <em>#*</em> et se terminent par <em>*#</em>, sont l pour ce cas de figure.
  </p>
  <source><![CDATA[
Ceci est du texte  l'extrieur 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'extrieur du commentaire: il est visible.
]]></source>
  <p>Voici quelques exemples pour clarifier la manire dont les commentaires d'une et plusieurs lignes fonctionnent:</p>
  <source><![CDATA[
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'extrieur
du commentaire, il est donc visible.
## Ce texte n'est pas visible.
]]></source>
  <p>
    Il y a un troisime 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.
  </p>
  <source><![CDATA[
#**
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
*#
]]></source>
</section>

<section name="Les rfrences">
  <p>
    Il y a trois types de rfrences en VTL: les variables, les proprits et les mthodes. En tant que concepteur
    utilisant le VTL, vous et vos ingnieurs devez vous mettre d'accord sur les noms des rfrences, de manire  pouvoir
    les utiliser correctement dans vos gabarits de pages.
  </p>
  <p>
    Tout ce qui entre et sort d'une rfrence est trait comme un objet chane de caractres. S'il y a un objet qui
    reprsente <em>$foo</em>(un objet Integer par exemple), Velocity appellera sa mthode <code>.toString()</code>
    pour convertir l'objet en String.
  </p>
  <p>
    <a name="Variables"><strong>Variables</strong></a>
    <br/>
    La notation abrge pour une variable consiste en un caractre "$" initial suivi d'un <em>Identificateur</em>VTL.
    Un identificateur VTL doit commencer par une lettre (a .. z ou A .. Z). Le reste des caractres est limit aux types
    suivants:
  </p>
  <p>
    <ul>
      <li>lettre (a .. z, A .. Z)</li>
      <li>chiffre (0 .. 9)</li>
      <li>tiret ("-")</li>
      <li>trait de soulignement ("_")</li>
    </ul>
  </p>
  <p>Voici quelques exemples de rfrences valides en VTL: </p>
  <source><![CDATA[
$foo
$mudSlinger
$mud-slinger
$mud_slinger
$mudSlinger1
]]></source>
  <p>
    Lorsque VTL rfrence une variable, telle que <em>$foo</em>, la variable peut prendre sa valeur soit d'une directive
    <em>set</em> dans le gabarit, soit d'un programme Java. Par exemple, si la variable Java <em>$foo</em> a la valeur
    <em>bar</em>  la ligne  laquelle il est fait appel au gabarit, <em>bar</em> remplace toutes les instances de
    <em>$foo</em> dans la page web. Autrement, si j'inclus l'instruction
  </p>
  <source><![CDATA[
#set( $foo = "bar" )
]]></source>
  <p>la sortie sera la mme pour toutes les instances de <em>$foo</em> qui suivent cette directive.</p>
  <p>
    <a name="Proprits"><strong>Proprits</strong></a>
    <br/>Les proprits sont la seconde espce de rfrences en VTL et elles ont un format qui les distingue.
    La notation abrge consiste en un caractre <em>$</em> initial suivi d'un identifiant VTL, suivi d'un point (".")
    et d'un autre identifiant VTL. Quelques exemples de rfrences valides de proprits en VTL:
  </p>
  <source><![CDATA[
$customer.Address
$purchase.Total
]]></source>
  <p>
    Prenons le premier exemple, <em>$customer.Address</em>. Cette expression peut avoir deux significations.
    Elle peut signifier: "Regarde dans la table de hachage identifie par <em>customer</em> et renvoie la valeur associe
     la cl <em>Address</em>. Mais <em>$customer.Address</em> peut aussi faire rfrence  une mthode (les rfrences
    qui dsignent des mthodes seront discutes dans la section suivante); <em>$customer.Address</em> pourrait tre
    une manire abrge d'crire <em>$customer.getAddress()</em>. Quand quelqu'un demande votre page, Velocity va
    dterminer laquelle de ces deux possibilits a un sens, et retournera la valeur approprie.
  </p>
  <p>
    <a name="Mthodes"><strong>Mthodes</strong></a>
    <br/>Une mthode est dfinie dans le code Java et peut faire quelque chose d'utile, comme effectuer un calcul ou
    prendre une dcision. Les mthodes sont des rfrences qui consistent en un caractre "$" initial, suivi d'un
    identifiant VTL, suivi d'un <em>corps de mthode</em>. Un corps de mthode VTL consiste en un identifiant VTL
    suivi du caractre parenthse ouvrante ("("), ventuellement suivi d'une liste de paramtres, suivi du caractre
    parenthse fermante (")"). Quelques exemples de rfrences de mthodes valides en VTL:
  </p>
  <source><![CDATA[
$customer.getAddress()
$purchase.getTotal()
$page.setTitle( "My Home Page" )
$person.setAttributes( ["Strange", "Weird", "Excited"] )
]]></source>
  <p>
    Les deux premiers exemples -- <em>$customer.getAddress()</em> et 
    <em>$purchase.getTotal()</em> -- peuvent avoir l'air semblables  ceux utiliss dans la section prcdente,
    consacre aux Proprits, <em>$customer.Address</em> et
    <em>$purchase.Total</em>. Si vous avez devin que ces exemples sont lis entre eux d'une manire ou d'une autre,
    vous avez raison!
  </p>
  <p>
    Les proprits VTL peuvent tre utilises comme une notation abrge pour des mthodes VTL.
    La proprit <em>$customer.Address</em> a exactement le mme effet que l'utilisation de la mthode
    <em>$customer.getAddress()</em>. Il est gnralement prfrable d'utiliser une proprit lorsqu'il y en a une
    de disponible. La principale diffrence entre les Proprits et les Mthodes est que pour les mthodes, on peut
    spcifier une liste de paramtres.
  </p>
  <p>La notation abrge peut tre utilise pour les mthodes suivantes</p>
  <source><![CDATA[
$sun.getPlanets()
$annelid.getDirt()
$album.getPhoto()
]]></source>
  <p>
    On s'attend logiquement  ce que ces mthodes retournent les noms des plantes 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 mthodes suivantes:
  </p>
  <source><![CDATA[
$sun.getPlanet( ["Earth", "Mars", "Neptune"] )
## On ne peut pas passer une liste de paramtres 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 paramtres
]]></source>
  <p>
    <a name="Notation formelle des rfrences"><strong>Notation formelle des rfrences</strong></a>
    <br/>Dans les exemples ci-dessus, nous avons utilis la notation abrge pour les rfrences, mais il y a aussi
    une notation formelle pour les rfrences, illustre ci-dessous:
  </p>
  <source><![CDATA[
${mudSlinger}
${customer.Address}
${purchase.getTotal()}
]]></source>
  <p>
    Dans presque tous les cas, vous utiliserez pour les rfrences la notation abrge, mais dans certains cas
    la notation formelle est requise pour une excution correcte.
  </p>
  <p>
    Supposons que vous soyez en train de construire dynamiquement une phrase dans laquelle <em>$vice</em> 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 rsultats suivants:
    "Jacques est pyromane" ou "Jacques est cleptomane".
    L'utilisation de la notation abrge ne convient pas pour cette tche. Considrons en effet l'exemple suivant:
  </p>
  <source><![CDATA[
Jacques est un $vicemane.
]]></source>
  <p>
    La syntaxe est ici ambigu, et Velocity suppose que <em>$vicemane</em>, et non <em>$vice</em>, est l'identifiant
    que vous pensiez utiliser. Ne trouvant pas de valeur pour <em>$vicemane</em>, il renverra <em>$vicemane</em>.
    L'utilisation de la notation formelle peut rsoudre ce problme.
  </p>
  <source><![CDATA[
Jacques est un ${vice}mane.
]]></source>
  <p>
    Cette fois Velocity sait que <em>$vice</em>, et non <em>$vicemane</em>, est la rfrence. La notation formelle est
    souvent utile quand les rfrences sont directement adjacentes  du texte au sein d'un gabarit.
  </p>
  <p>
    <a name="Notation silencieuse des rfrences"><strong>Notation silencieuse des rfrences</strong></a>
    <br/>Lorsque Velocity rencontre une rfrence non dfinie, son comportement normal est de produire une image de la
    rfrence. Par exemple, supposons que la rfrence suivante apparaisse dans un gabarit VTL:
  </p>
  <source><![CDATA[
<input type="text" name="email" value="$email"/>
]]></source>
  <p>
    Quand le formulaire est charg pour la premire fois, la variable rfrence par <em>$email</em> n'a pas de valeur,
    mais vous prfreriez un champ de texte vide  la valeur "$email". L'utilisation de la notation silencieuse contourne
    le comportement normal de Velocity; au lieu d'utiliser <em>$email</em> dans le code VTL, utilisez <em>$!email</em>.
    L'exemple prcdent ressemblerait donc  ceci:
  </p>
  <source><![CDATA[
<input type="text" name="email" value="$!email"/>
]]></source>
  <p>
    A prsent, quand le formulaire est charg pour la premire fois et que <em>$email</em> n'a toujours pas de valeur,
    une chane vide sera produite au lieu de "$email".
  </p>
  <p>La notation formelle et la notation silencieuse peuvent tre utilises ensemble, comme illustr ci-dessous.</p>
  <source><![CDATA[
<input type="text" name="email" value="$!{email}"/>
]]></source>
</section>

<section name="Sortie littrale">
  <p>
    VTL utilise des caractres spciaux, comme  <em>$</em> et <em>#</em> pour accomplir sa tche; il faut donc prendre
    quelques prcautions pour utiliser ces caractres dans vos gabarits. Cette section est consacre  l'chappement
    du caractre <em>$</em>.
  </p>
  <p>
    <a name="Devise"><strong>Devise</strong></a>
    <br/>Il n'y a pas de problme 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 rfrence.
  </p>
  <p>
    <a name="Echapper des rfrences VTL valides"><strong>Echapper des rfrences VTL valides</strong></a>
    <br/>Il peut se produire dans certains cas que Velocity se trouve induit en confusion. <em>Echapper</em> les
    caractres spciaux est le meilleur moyen de traiter les caractres spciaux du VTL dans vos gabarits, et ceci se
    fait en utilisant le caractre backslash (<em>\</em>).
  </p>
  <source><![CDATA[
#set( $email = "foo" )
$email
]]></source>
  <p>
    Lorsque Velocity rencontre une rfrence  <em>$email</em> dans votre gabarit VTL, il cherche dans le contexte la
    valeur correspondante. Ici, la sortie sera <em>foo</em>, parce que <em>$email</em> est dfini. Si <em>$email</em>
    n'tait pas dfini, la sortie serait <em>$email</em>.
  </p>
  <p>
    Supposons que <em>$email</em> soit dfini (par exemple, cette rfrence a la valeur <em>foo</em>)
    et que vous vouliez produire <em>$email</em>. Il y a diffrentes manires de le faire, mais la plus simple est
    d'utiliser le caractre d'chappement.
  </p>
  <source><![CDATA[
## La ligne qui suit dfinit $email dans ce gabarit:
#set( $email = "foo" )
$email
\$email
\\$email
\\\$email
]]></source>
  <p>sera rendu comme:</p>
  <source><![CDATA[
foo
$email
\foo
\$email
]]></source>
  <p>
    Notez que le caractre <em>\</em> s'applique au <em>$</em>  partir de la gauche. Cette rgle d'application
     partir de la gauche fait que <em>\\\$email</em> est rendu comme <em>\\$email</em>. Comparons maintenant ces examples
     ce qui se passe lorsque <em>$email</em> n'est pas dfini.
  </p>
  <source><![CDATA[
$email
\$email
\\$email
\\\$email
]]></source>
  <p>sera rendu comme:</p>
  <source><![CDATA[
$email
\$email
\\$email
\\\$email
]]></source>
  <p>
    Remarquez comment Velocity traite les rfrences dfinies diffremment de celles qui n'ont pas t dfinies.
    Voici par exemple une directive set qui donne  <em>$foo</em> la valeur <em>gibbous</em>.
  </p>
  <source><![CDATA[
#set( $foo = "gibbous" )
$moon = $foo
]]></source>
  <p>
    La sortie sera: <em>$moon = gibbous</em> -- o <em>$moon</em> est rendu littralement puisqu'il n'est pas dfini,
    alors que <em>gibbous</em> est rendu au lieu de <em>$foo</em>.
  </p>
  <p>Il est aussi possible d'chapper les directives VTL; ceci est dcrit plus en dtail dans la section Directives.</p>
</section>

<section name="Substitution de cas">
  <p>
    Maintenant que les rfrences vous sont familires, vous pouvez commencer  les mettre en pratique dans vos propres
    gabarits. Les rfrences, dans Velocity, tirent avantage de certains principes Java que les concepteurs de gabarits
    vont trouver commodes. Par exemple:
  </p>
  <source><![CDATA[
$foo

$foo.getBar()
## est quivalent 
$foo.Bar

$data.getUser("jon")
## est quivalent 
$data.User("jon")

$data.getRequest().getServerName()
## est quivalent 
$data.Request.ServerName
## est quivalent 
${data.Request.ServerName}
]]></source>
  <p>
    Ces exemples illustrent diffrentes manires d'utiliser les mmes rfrences. Velocity tire parti de l'introspection
    Java et des caractristiques des beans pour rsoudre les noms de rfrence en objets du contexte et aussi en leurs
    mthodes. Il est possible d'inclure et d'valuer des rfrences  peu prs partout dans votre gabarit.
  </p>
  <p>
    Velocity utilise comme modles les spcifications des Beans telles qu'elles ont t dfinies par Sun Microsystems;
    il est donc sensible  la casse (majuscules/minuscules); les dveloppeurs se sont toutefois battus pour intercepter
    et corriger les erreurs des utilisateurs chaque fois que c'est possible. Lorsque la mthode <em>getFoo()</em> est
    rfrence dans un gabarit par <code>$bar.foo</code>, Velocity essayera d'abord <code>$getfoo</code>. Si ceci choue,
    Velocity essayera <code>$getFoo</code>. De mme, si un gabarit fait rfrence  <code>$bar.Foo</code>,
    Velocity essayera d'abord <em>$getFoo()</em> et ensuite <em>getfoo()</em>.
  </p>
  <p>
    Note: <em>Dans un gabarit, les rfrences  des variables d'instance ne sont pas rsolues.</em> Il n'y a que les
    rfrences quivalentes aux attributs des accesseurs (getter / setter) des JavaBeans qui sont rsolues
    (autrement dit <code>$foo.Name</code> est rsolu par l'appel de la mthode d'instance <code>getName()</code>
    de la classe Foo, mais pas en une variable d'instance publique <code>Name</code> de cette classe Foo).
  </p>
</section>

<section name="Directives">
  <p>
    Les rfrences permettent aux concepteurs de pages de gnrer du contenu dynamique pour des sites web alors que les
    <em>directives</em> -- des lments de script, faciles  utiliser, qui peuvent tre mis en oeuvre pour manipuler de
    manire crative la sortie d'un code Java -- permet aux concepteurs de vraiment prendre en charge l'apparence et le
    contenu du site web.
  </p>
  <a name="Set"><strong>#set</strong></a>
  <p>
    La directive <em>#set</em> s'utilise pour donner une valeur  une rfrence. Une valeur peut tre assigne soit  une
    rfrence de type variable, soit  une rfrence de type proprit, et ceci toujours entre parenthses, comme montr
    ici:
  </p>
  <source><![CDATA[
#set( $primate = "monkey" )
#set( $customer.Behavior = $primate )
]]></source>
  <p>
    Le ct gauche (left hand side -- LHS) de l'assignation doit tre une rfrence variable ou proprit. Le membre de
    droite (right hand side -- RHS) peut tre de l'un des types suivants:
  </p>
  <p>
    <ul>
      <li>Une rfrence (variable)</li>
      <li>Une chane de caractres littrale</li>
      <li>Une rfrence (proprit)</li>
      <li>Une rfrence  une mthode</li>
      <li>Un nombre littral</li>
      <li>Une ArrayList</li>
    </ul>
  </p>
  <p>Les exemples suivants montrent chacun des types susmentionns:</p>
  <source><![CDATA[
#set( $monkey = $bill ) ## rfrence (variable)
#set( $monkey.Friend = "monica" ) ## chane de caractres littrale
#set( $monkey.Blame = $whitehouse.Leak ) ## rfrence (proprit)
#set( $monkey.Plan = $spindoctor.weave($web) ) ## rfrence  une mthode
#set( $monkey.Number = 123 ) ## nombre littral
#set( $monkey.Say = ["Not", $my, "fault"] ) ## ArrayList
]]></source>
  <p>
    NOTE: Dans le dernier exemple, les lments dfinis avec l'oprateur [..] sont accessibles en utilisant les mthodes
    dfinies dans la classe ArrayList. Ainsi, par exemple, on peut accder au premier lment en crivant
    $monkey.Say.get(0)
  </p>
  <p>Le membre de droite peut aussi tre une expression arithmtique simple:</p>
  <source><![CDATA[
#set( $value = $foo + 1 )
#set( $value = $bar - 1 )
#set( $value = $foo * $bar )
#set( $value = $foo / $bar )
]]></source>
  <p>
    Si le membre de droite est une rfrence  une mthode ou  une proprit dont la valeur est <em>null</em>, il ne
    sera <b>pas</b> affect au membre de gauche. Il n'est pas possible d'enlever une rfrence existante du contexte
    par ce biais-l. Ceci peut troubler les dbutants en Velocity. Par exemple:
  </p>
  <source><![CDATA[
#set( $result = $query.criteria("name") )
Le rsultat de la premire requte est $result

#set( $result = $query.criteria("address") )
Le rsultat de la seconde requte est $result
]]></source>
  <p>
     Si <em>$query.criteria("name")</em> renvoie la chane "bill", et que  <em>$query.criteria("address")</em> renvoie
     <em>null</em>, le code VTL ci-dessus sera rendu de la manire suivante:
  </p>
  <source><![CDATA[
Le rsultat de la premire requte est bill

Le rsultat de la seconde requte est bill
]]></source>
  <p>
    Ceci induit en confusion les nouveaux venus, qui construisent des boucles <em>#foreach</em> qui tentent de faire
    un <em>#set</em> sur une rfrence  partir d'une rfrence  une proprit ou une mthode et testent immdiatement
    cette rfrence avec une directive <em>#if</em>. Par exemple:
  </p>
  <source><![CDATA[
#set( $criteria = ["name", "address"] )

#foreach( $criterion in $criteria )

    #set( $result = $query.criteria($criterion) )

    #if( $result )
        Query was successful
    #end

#end
]]></source>
  <p>
    Dans l'exemple ci-dessus, il ne serait pas avis de se reposer sur l'valuation de <em>$result</em> pour dterminer
    si une requte a t couronne de succs. Une fois que <em>$result</em> a reu une valeur par un <em>#set</em>
    (et a donc t ajout au contexte), il ne peut pas recevoir la valeur <em>null</em> (et se trouver ainsi enlev du
    contexte). Les dtails des directives <em>#if</em> et <em>#foreach</em> sont traits plus loin dans ce document.
  </p>
  <p>
    Une solution  ce problme serait de pr-positionner <em>$result</em>  <em>false</em>. Si l'appel 
    <em>$query.criteria()</em> choue, il est possible de faire la vrification.
  </p>
  <source><![CDATA[
#set( $criteria = ["name", "address"] )

#foreach( $criterion in $criteria )

    #set( $result = false )
    #set( $result = $query.criteria($criterion) )

    #if( $result )
        La requte a abouti correctement
    #end

#end
]]></source>
  <p>Contrairement  d'autres directives Velocity, la directive <em>#set</em> n'a pas d'instruction <em>#end</em>.</p>
  <a name="Chanes de caractres littrales"><strong>Chanes de caractres littrales</strong></a>
  <p>
    Lorsque vous utilisez la directive <em>#set</em>, les chanes de caractres littrales dlimites par des guillements
    sont interprtes et rendues de la manire suivante:
  </p>
  <source><![CDATA[
#set( $directoryRoot = "www" )
#set( $templateName = "index.vm" )
#set( $template = "$directoryRoot/$templateName" )
$template
]]></source>
  <p>La sortie produite sera</p>
  <source><![CDATA[
www/index.vm
]]></source>
  <p>Toutefois, lorsque la chane de caractres littrale est dlimite par des apostrophes, elle n'est pas interprte.</p>
  <source><![CDATA[
#set( $foo = "bar" )
$foo
#set( $blargh = '$foo' )
$blargh
]]></source>
  <p>Ce qui est rendu de la manire suivante:</p>
  <source><![CDATA[
  bar
  $foo
]]></source>
  <p>
    Cette caractristique d'utilisation des apostrophes pour rendre du texte non interprt est le comportement par dfaut
    de Velocity. Ce comportement peut tre chang en ditant le fichier <code>velocity.properties</code> et en y crivant
    l'entre: <code>stringliterals.interpolate=false</code>.
  </p>
</section>

<section name="Conditions">
  <strong>If / ElseIf / Else</strong>
  <p>
    La directive <em>#if</em> de Velocity permet  du texte d'tre inclus  la gnration d'une page web seulement si la
    condition qui suit l'instruction if est vrifie. Par exemple:
  </p>
  <source><![CDATA[
#if( $foo )
   <strong>Velocity!</strong>
#end
]]></source>
  <p>
    La variable <em>$foo</em> est value pour dterminer si elle vaut true, ce qui se produit dans l'une des deux cas
    suivants; (i) <em>$foo</em> est une variable boolenne (true/false) dont la valeur est vrai (true), ou (ii) la valeur
    de <em>$foo</em> est diffrente de null. On se rappelle que le contexte de Velocity ne contient que des Objets,
    et donc lorsqu'on dit un boolen, il sera reprsent comme un objet de la classe Boolean contenant la valeur logique
    approprie.
  </p>
  <p>
    Ce qui est contenu entre l'instruction <em>#if</em> et l'instruction <em>#end</em> sera produit en sortie si la
    condition est value comme vraie. Dans l'exemple prcdent, si <em>$foo</em> est true, la sortie sera: "Velocity!".
    A l'inverse, si <em>$foo</em> a la valeur null, ou si c'est un boolen de valeur false, l'instruction est value
    comme fausse, et il n'y a pas de sortie produite.
  </p>
  <p>
    Un lment <em>#elseif</em> ou <em>#else</em> peut tre utilis dans la directive <em>#if</em>.
    Notez que le moteur Velocity (Velocity Template Engine) s'arrtera  la premire expression value comme vraie.
    Dans l'exemple suivant, supposons que  <em>$foo</em> vaut 15 et que <em>$bar</em> vaut 6.
  </p>
  <source><![CDATA[
#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
]]></source>
  <p>
    Dans cet exemple, <em>$foo</em> est plus grand que 10, donc les deux premires comparaisons chouent. Ensuite,
    <em>$bar</em> est compar  6, ce qui donne vrai, et dont la sortie produit est <strong>Go South</strong>.
  </p>
  <p>
    Notez que pour l'instant, dans Velocity, les comparaisons numriques 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 ct de '==' sont de la <em>mme classe</em>.
  </p>
  <p><a name="Oprateurs logiques et relationnels"><strong>Oprateurs logiques et relationnels</strong></a></p>
  <p>Velocity utilise l'oprateur d'quivalence pour dterminer les relations entre des variables. Voici un exemple simple pour illustrer la manire d'utiliser l'oprateur d'quivalence.</p>
  <source><![CDATA[
#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
]]></source>
  <p>
    Velocity a aussi des oprateurs ET, OU et NON. Pour plus d'informations, rfrez-vous au
    <a href="vtl-reference-guide.html">VTL Reference Guide</a> (en anglais).
    Ci-dessous, quelques exemples illustrent l'utilisation des oprateurs logiques ET, OU et NON.
  </p>
  <source><![CDATA[
##ET logique

#if( $foo && $bar )
   <strong> Ceci ET cela.</strong>
#end

]]></source>
  <p>
    La directive <em>#if()</em> ne sera value comme <em>true</em> que si <em>$foo</em> et <em>$bar</em> sont
    <em>true</em> tous les deux. Si <em>$foo</em> est <em>false</em>, l'expression sera globalement value comme
    <em>false</em> et <em>$bar</em> ne sera pas valu. Si <em>$foo</em> vaut <em>true</em>, le moteur Velocity testera
    la valeur de <em>$bar</em>; si <em>$bar</em> vaut <em>true</em>, alors l'expression dans son entiret vaut
    <em>true</em> et la sortie <strong>Ceci ET cela</strong> est produite. Si <em>$bar</em> est <em>false</em>,
    alors il n'y aura pas de sortie produite puisque l'expression entire est fausse.
  </p>
  <p>
    Les oprateurs logiques OU fonctionnent de la mme manire, si ce n'est qu'une seule des rfrences doit tre value
     <em>true</em> pour que l'expression entire soit considre comme vraie. Voyez l'exemple suivant:
  </p>
  <source><![CDATA[
##OU logique

#if( $foo || $bar )
    <strong>Ceci OU cela</strong>
#end
]]></source>
  <p>
    Si <em>$foo</em> vaut <em>true</em>, le moteur Velocity n'a pas besoin d'valuer <em>$bar</em>; que <em>$bar</em>
    soit vrai ou faux ne change rien  l'affaire, l'expression sera vraie, et <strong>Ceci OU cela</strong> sera produit
    en sortie. Mais si <em>$foo</em> est false, la valeur de <em>$bar</em> doit tre vrifie.
    Dans ce cas, si <em>$bar</em> est faux lui aussi, l'expression sera fausse et il n'y aura pas de sortie produite.
    Sinon, si <em>$bar</em> est vrai, alors l'expression entire est vraie, et la sortie est
    <strong>Ceci OU cela</strong>.
  </p>
  <p>Avec l'oprateur logique NON, il n'y a qu'un seul argument :</p>
  <source><![CDATA[
##NON logique

#if( !$foo )
  <strong>PAS a</strong>
#end
]]></source>
  <p>
    Cette fois, si <em>$foo</em> vaut <em>true</em>, alors  <em>!$foo</em> est valu comme <em>false</em>, 
    et il n'y a pas de sortie. Si <em>$foo</em> est <em>false</em>, alors <em>!$foo</em> est valu  <em>true</em>
    et <strong>PAS a</strong> est produit en sortie. Attention  ne pas confondre ceci avec la
    <em>rfrence silencieuse $!foo</em> que nous avons dj rencontre et qui reprsente quelque chose de compltement
    diffrent.
  </p>
</section>

<section name="Boucles">
  <strong>Boucle Foreach</strong>
  <p>L'lment <em>#foreach</em> permet d'itrer. Par exemple:</p>
  <source><![CDATA[
<ul>
#foreach( $product in $allProducts )
    <li>$product</li>
#end
</ul>
]]></source>
  <p>
    Cette boucle <em>#foreach</em> parcourt un  un tous les produits (cibles) de la liste <em>$allProducts</em> (objet).
    A chaque passage dans la boucle, une valeur de <em>$allProducts</em> est place dans la variable <em>$product</em>.
  </p>
  <p>
    Le contenu de la variable <em>$allProducts</em> est un vecteur (Vector), une table de hachage (Hashtable)
    ou un tableau (Array). La valeur assigne  <em>$product</em> est un objet Java, et peut tre rfrence en tant
    que telle par une variable. Par exemple, si <em>$product</em> est en effet une classe Product en Java,
    son nom peut tre rcupr en rfrenant la mthode <em>$product.Name</em> (c'est--dire <em>$Product.getName()</em>).
  </p>
  <p>
    Supposons que <em>$allProducts</em> soit une Hashtable. Si vous voulez retrouver les valeurs des cls et les objets
    de la Hashtable, vous pouvez utiliser un bout de code comme celui-ci:
  </p>
  <source><![CDATA[
<ul>
#foreach( $key in $allProducts.keySet() )
    <li>Key: $key -> Value: $allProducts.get($key)</li>
#end
</ul>
]]></source>
  <p>
    Velocity fournit un moyen simple de connatre le compteur de boucle, de sorte qu'on puisse faire quelque chose comme:
  </p>
  <source><![CDATA[
<table>
#foreach( $customer in $customerList )
    <tr><td>$velocityCount</td><td>$customer.Name</td></tr>
#end
</table>
]]></source>
  <p>
    Le nom par dfaut de la variable/rfrence du compteur de bouche est spcifi dans le fichier
    <code>velocity.properties</code>. Par dfaut le compteur dmarre  1, mais ceci aussi peut tre paramtr ( 0 ou 1)
    dans le fichier <code>velocity.properties</code>. Voici  quoi ressemble la section Proprits du compteur de boucle
    dans le fichier <code>velocity.properties</code>:
  </p>
  <source><![CDATA[
# Default name of the loop counter
# variable reference.
directive.foreach.counter.name = velocityCount

# Default starting value of the loop
# counter variable reference.
directive.foreach.counter.initial.value = 1
]]></source>
</section>

<section name="Include">
  <p>
    L'lment de script <em>#include</em> permet au concepteur de gabarits d'importer un fichier local, qui est alors
    insr  l'endroit o la directive <em>#include</em> est dfinie. Le contenu du fichier n'est pas rendu en passant
    par le moteur de substitution. Pour des raisons de scurit, le fichier  inclure ne peut se trouver que sous
    TEMPLATE_ROOT.
  </p>
  <source><![CDATA[
#include( "one.txt" )
]]></source>
  <p>
    Le fichier auquel la directive <em>#include</em> fait rfrence est inclus entre des guillemets.
    Si plusieurs fichiers doivent tre inclus, leurs noms doivent tre spars par des virgules.
  </p>
  <source><![CDATA[
#include( "one.gif","two.txt","three.htm" )
]]></source>
  <p>
    Le fichier  inclure ne doit pas ncessairement tre appel par son nom; en fait, il est souvent prfrable
    d'utiliser une variable plutt qu'un nom de fichier. Ce qui peut tre utile pour cibler ce qui est produit en
    fonction de critres dtermins au moment o la page est demande. Voici un exemple qui utilise  la fois un nom
    de fichier et une variable.
  </p>
  <source><![CDATA[
#include( "greetings.txt", $seasonalstock )
]]></source>
</section>

<section name="Parse">
  <p>
    L'lment de script <em>#parse</em> permet au concepteur de gabarits d'importer un fichier local contenant du VTL.
    Velocity va alors interprter le VTL et rendre le gabarit spcifi.
  </p>
  <source><![CDATA[
#parse( "me.vm" )
]]></source>
  <p>
    Comme la directive <em>#include</em>, <em>#parse</em> peut prendre en argument une variable plutt qu'un nom
    de gabarit. Tous les gabarits auxquels il est fait rfrence par <em>#parse</em> doivent se trouver
    sous TEMPLATE_ROOT. Contrairement  la directive <em>#include</em>, <em>#parse</em> ne peut prendre qu'un seul
    argument.
  </p>
  <p>
    Les gabarits VTL peuvent contenir des instructions <em>#parse</em> faisant rfrence  des gabarits qui  leur tour
    contiennent des <em>#parse</em>. Par dfaut  10, la ligne <em>parse_directive.maxdepth</em> du fichier
    <code>velocity.properties</code> permet aux utilisateurs de personnaliser le nombre de rfrences <em>#parse</em>
    que l'on peut rencontrer dans un gabarit. (Note: Si la proprit <em>parse_directive.maxdepth</em> est absente du
    fichier <code>velocity.properties</code>, Velocit positionne cette valeur par dfaut  10).
    La rcursion est permise; par exemple si le gabarit <code>dofoo.vm</code> contient les lignes suivantes:
  </p>
  <source><![CDATA[
Count down.
#set( $count = 8 )
#parse( "parsefoo.vm" )
All done with dofoo.vm!
]]></source>
  <p>Il fait rfrence au gabarit <code>parsefoo.vm</code>, qui peut contenir le VTL suivant:</p>
  <source><![CDATA[
$count
#set( $count = $count - 1 )
#if( $count > 0 )
    #parse( "parsefoo.vm" )
#else
    All done with parsefoo.vm!
#end
]]></source>
  <p>
    Aprs que "Count down." soit affich, Velocity passe par <code>parsefoo.vm</code>, comptant  rebours  partir de 8.
    Lorsque le compte  rebours atteint 0, il affiche le message "All done with parsefoo.vm!".
    A ce stade, Velocity va retourner  <code>dofoo.vm</code> et produire le message "All done with dofoo.vm!".
  </p>
</section>

<section name="Stop">
  <p>
    L'lment de script <em>#stop</em> permet au concepteur de gabarits d'arrter l'excution du moteur de substitution.
    Cette directive peut tre utile pour le dbogage.
  </p>
  <source><![CDATA[
#stop
]]></source>
</section>

<section name="Velocimacros">
  <p>
    L'lment de script <em>#macro</em> permet aux concepteurs de dfinir un segment rptable d'un gabarit VTL.
    Les "Velocimacros" sont trs utiles dans un grand nombre de scnarios, simples ou complexes.
    Une Velocimacro, crite dans le seul but de s'conomiser un peu de frappe et de minimiser les fautes,
    servira d'introduction au concept de Velocimacro.
  </p>
  <source><![CDATA[
#macro( d )
<tr><td></td></tr>
#end
]]></source>
  <p>
    La Velocimacro dfinie dans cet exemple est <em>d</em>; elle peut tre appele d'une manire semblable  toute autre
    directive VTL:
  </p>
  <source><![CDATA[
#d()
]]></source>
  <p>Lorsque ce gabarit est appel, Velocity remplace <em>#d()</em> par une ligne contenant une cellule de donnes vide.</p>
  <p>
    Une Velocimacro peut prendre n'importe quel nombre d'arguments -- mme zro, comme on l'a vu dans l'exemple --
    mais lorsque la macro est appele, elle doit l'tre avec le mme nombre d'arguments que dans la dfinition.
    Beaucoup de Velocimacros sont plus sophistiques que celle dfinie ci-dessus; voici une Velocimacro qui prend deux
    arguments, une couleur et un tableau.
  </p>
  <source><![CDATA[
#macro( tablerows $color $somelist )
#foreach( $something in $somelist )
    <tr><td bgcolor=$color>$something</td></tr>
#end
#end
]]></source>
  <p>
    La Velocimacro dfinie dans cet exemple, <em>tablerows</em>, prend deux arguments. Le premier argument prend la place
    de <em>$color</em> et le second argument prend la place de <em>$somelist</em>.
  </p>
  <p>
    Tout ce qui peut tre mis dans un gabarit VTL peut aussi trouver place dans le corps d'une Velocimacro.
    La Velocimacro <em>tablerows</em> contient une instruction <em>foreach</em>. On remarquera qu'il y a deux
    instructions <em>#end</em> dans la dfinition de la Velocimacro <em>#tablerows</em>; la premire termine
    le <em>#foreach</em>, la seconde termine la dfinition de la Velocimacro.
  </p>
  <source><![CDATA[
#set( $greatlakes = ["Superior","Michigan","Huron","Erie","Ontario"] )
#set( $color = "blue" )
<table>
    #tablerows( $color $greatlakes )
</table>
]]></source>
  <p>
    Notez que  <em>$greatlakes</em> prend la place de <em>$somelist</em>. Quand la Velocimacro <em>#tablerows</em>
    est appele dans ce contexte, la sortie suivante est produite:
  </p>
  <source><![CDATA[
<table>
    <tr><td bgcolor="blue">Superior</td></tr>
    <tr><td bgcolor="blue">Michigan</td></tr>
    <tr><td bgcolor="blue">Huron</td></tr>
    <tr><td bgcolor="blue">Erie</td></tr>
    <tr><td bgcolor="blue">Ontario</td></tr>
</table>
]]></source>
  <p>
    Les Velocimacros peuvent tre dfinies <i>inline</i> dans un gabarit Velocity; elles ne sont pas disponibles dans
    ce cas pour d'autres gabarits Velocity sur le mme site web. Dfinir une Velocimacro pour qu'elle puisse tre partage
    par tous les gabarits a des avantages vidents: cela rduit le besoin de redfinir la Velocimacro dans de nombreux
    gabarits, cela conomise du travail et rduit les occasions de se tromper, cela assure qu'un chagement fait une seule
    fois dans une macro est aussitt disponible dans tous les gabarits.
  </p>
  <p>
    Si la Velocimacro <em>#tablerows($color $list)</em> avait t dfinie dans une bibliothque de gabarits Velocimacros,
    cette macro aurait pu tre utilise dans n'importe lequel des gabarits usuels. Elle pourrait tre utilise de
    nombreuses fois et dans des buts diffrents. Dans le gabarit <code>mushroom.vm</code> consacr  toute espce de
    champignons, la Velocimacro <em>#tablerows</em> pourrait tre appele pour donner la liste des parties
    d'un champignon typique.
  </p>
  <source><![CDATA[
#set( $parts = ["volva","stipe","annulus","gills","pileus"] )
#set( $cellbgcol = "#CC00FF" )
<table>
#tablerows( $cellbgcol $parts )
</table>
]]></source>
  <p>
    Lors de l'excution d'une requte pour <code>mushroom.vm</code>, Velocity trouverait la Velocimacro
    <em>#tablerows</em> dans la bibliothque de gabarits (dfinie dans le fichier <code>velocity.properties</code>)
    et produirait la sortie suivante:
  </p>
  <source><![CDATA[
<table>
    <tr><td bgcolor="#CC00FF">volva</td></tr>
    <tr><td bgcolor="#CC00FF">stipe</td></tr>
    <tr><td bgcolor="#CC00FF">annulus</td></tr>
    <tr><td bgcolor="#CC00FF">gills</td></tr>
    <tr><td bgcolor="#CC00FF">pileus</td></tr>
</table>
]]></source>
  <strong>Arguments d'une Velocimacro</strong>
  <p>Les Velocimacros peuvent prendre comme argument tout lment VTL parmi les suivants:</p>
  <ul>
    <li>Rfrence: tout ce qui commence par '$'</li>
    <li>Chane de caractres littrale: quelque chose comme "$foo" ou 'hello'</li>
    <li>Nombre littral:  1, 2 etc</li>
    <li>Intervalle d'entiers (IntegerRange) : [ 1..2] ou [$foo .. $bar]</li>
    <li>ObjectArray : [ "a", "b", "c"]</li>
    <li>Valeur boolenne true</li>
    <li>Valeur boolenne false</li>
  </ul>
  <p>
    Lorsqu'on passe des rfrences comme arguments  des Velocimacros, notez que ces rfrences sont passes "par nom".
    Ce qui veut dire que leur valeur est "gnre"  chaque utilisation  l'intrieur d'une Velocimacro.
    Cette particularit vous permet de passer des rfrences contenant des appels de mthodes et que la mthode soit
    appele  chaque fois. Par exemple, en appelant la Velocimacro suivante comme indiqu:
  </p>
  <source><![CDATA[
     #macro( callme $a )
         $a $a $a
     #end

     #callme( $foo.bar() )
   ]]></source>
  <p>le rsultat est que la mthode bar() de la rfrence $foo est appele trois fois.</p>
  <p>
    A premire vue, cette particularit est surprenante mais si vous considrez la raison d'tre originelle des
    Velocimacros (liminer la duplication par couper/coller de VTL d'usage courant), a a bien sr un sens.
    Cela vous permet de faire des choses tonnantes telles que passer  la Velocimacro des objets ayant un tat,
    comme un objet qui gnre des couleurs en squences rptes pour colorer les lignes d'un tableau.
  </p>
  <p>
    Si vous prouvez le besoin de contourner ce comportement, vous pouvez toujours assigner la valeur reue de la mthode
     une nouvelle rfrence et passer cette rfrence:
  </p>
  <source><![CDATA[
     #set( $myval = $foo.bar() )
     #callme( $myval )
  ]]></source>
  <strong>Proprits des Velocimacros</strong>
  <p>
    Plusieurs entres du fichier <code>velocity.properties</code> permettent une implmentation flexible des Velocimacros.
    Ces lignes sont commentes en dtail dans le <a href="developer-guide.html">Developer Guide</a> (en anglais).
  </p>
  <p>
    <code>velocimacro.library</code> - Une liste (dlimite par des virgules, de toutes les bibliothques de gabarits
    Velocimacro. Par dfaut, Velocity ne recherche qu'une bibliothque: <em>VM_global_library.vm</em>.
    Le chemin de gabarits donn ici est utilis pour trouver les bibliothques de Velocimacros.
  </p>
  <p>
    <code>velocimacro.permissions.allow.inline</code> - Cette proprit, qui peut prendre les valeurs true ou false,
    dtermine si les Velocimacros peuvent tre dfinies dans des gabarits ordinaires.
    La valeur par dfaut, true, permet aux concepteurs de gabarits de dfinir des Velocimacros dans les gabarits eux-mmes.
  </p>
  <p>
    <code>velocimacro.permissions.allow.inline.to.replace.global</code> - Les valeurs possibles sont true ou false,
    pour cette proprit qui permet  l'utilisateur de spcifier si une Velocimacro dfinie en ligne dans un gabarit
    peut remplacer un gabarit dfini globalement, celui qui a t dfini au dmarrage par la proprit
    <code>velocimacro.library</code>. La valeur par dfaut, <code>false</code>, empche les Velocimacros dfines
    <i>inline</i> dans un gabarit de remplacer  celles qui sont dfinies dans les bibliothques de gabarits charges
    au dmarrage.
  </p>
  <p>
    <code>velocimacro.permissions.allow.inline.local.scope</code> - Cette proprit, qui peut prendre les valeurs true
    ou false (false par dfaut), contrle si les Velocimacros dfinies <i>inline</i> ont leur visibilit limite au
    gabarit qui les dfinit. En d'autres mots, avec cette proprit dfinie  true, un gabarit peut dfinir des
    Velocimacros <i>inline</i> qui ne seront utilisables que par le gabarit qui les dfinit. Vous pouvez utiliser
    cette possibilit pour concocter quelques artifices amusants: si une VM globale appelle une autre VM globale,
    dfinie <i>inline</i>, un gabarit peut dfinir une implmentation "prive" de la seconde VM, qui sera appelle
    par la premire VM quand celle-ci est appele elle-mme dans le gabarit. Aucun autre gabarit n'est affect.
  </p>
  <p>
    <code>velocimacro.context.localscope</code> - Cette proprit peut valoir true ou false, la valeur par dfaut est
    false. Quand elle vaut true, toute modification du contexte via #set()  l'intrieur d'une Velocimacro est considre
    'locale'  cette Velocimacro et n'affectera pas le contexte de faon permanente.
  </p>
  <p>
    <code>velocimacro.library.autoreload</code> - Cette proprit contrle le chargement automatique de la bibliothque
    de Velocimacro. La valeur par dfaut est <code>false</code>. Quand elle est positionne  <code>true</code>
    la bibliothque source appele pour une Velocimacro sera vrifie pour voir si elle a chang et sera recharge
    si ncessaire. Ceci vous permet de modifier et de tester des bibliothques de Velocimacro sans avoir  redmarrer
    votre application ou votre moteur de servlets, exactement comme vous pouvez le faire pour des gabarits ordinaires.
    Ce mode ne fonctionne que quand le cache est dsactiv dans les  <i>resource loaders</i>
    (par exemple <code>file.resource.loader.cache = false</code>). Cette possibilit a t conue pour le dveloppement,
    pas pour la production.
  </p>
  <strong>Autres remarques sur les Velocimacros</strong>
  <p>
    A ce stade, les Velocimacros doivent tre dfinies avant d'tre utilises dans un gabarit.
    Cela signifie que vos dclarations #macro() doivent prcder l'usage des Velocimacros.
  </p>
  <p>
    Il est important de s'en souvenir si l'on essaye d'interprter (#parse()) un gabarit contenant des directives #macro()
    <i>inline</i>. Puisque l'interprtation se fait au moment de l'excution, et que l'interprteur dcide au moment de
    l'interprtation si, dans un gabarit, un lment qui a l'air d'une VM en est vraiment une, #parse()-er un ensemble de
    dclarations de VM ne produira pas le rsultat escompt. Pour contourner ce problme potentiel, on peut utiliser la
    proprit <code>velocimacro.library</code> pour que Velocity charge vos VMs au dmarrage.
  </p>
</section>

<section name="Echappement des directives VTL">
  <p>
    Les directives VTL peuvent tre chappes avec le caractre barre de fraction inverse ("\"), de la mme manire que
    les rfrences VTL valides.
  </p>
  <source><![CDATA[
## #include( "a.txt" ) renders as <contents of a.txt>
#include( "a.txt" )

## \#include( "a.txt" ) renders as \#include( "a.txt" )
\#include( "a.txt" )

## \\#include ( "a.txt" ) renders as \<contents of a.txt>
\\#include ( "a.txt" )
]]></source>
  <p>
    Il faut prendre des prcautions particulires lorsqu'on chappe des directives VTL qui contiennent plusieurs lments
    de script en une seule directive (comme dans le cas d'une instruction conditionnelle if-else-end).
    Voici un exemple typique d'instruction VTL if:
  </p>
  <source><![CDATA[
#if( $jazz )
    Vyacheslav Ganelin
#end
]]></source>
  <p>Si <em>$jazz</em> est vrai, la sortie produite est:</p>
  <source><![CDATA[
Vyacheslav Ganelin
]]></source>
  <p>
    Si <em>$jazz</em>, il n'y a pas de sortie produite. Echapper des lments de script modifie la sortie.
    Considrons le cas suivant:
  </p>
  <source><![CDATA[
\#if( $jazz )
    Vyacheslav Ganelin
\#end
]]></source>
  <p>Que <em>$jazz</em> soit vrai ou faux, la sortie sera:</p>
  <source><![CDATA[
 #if($ jazz )
     Vyacheslav Ganelin
 #end
]]></source>
  <p>
    En fait, puisque tous les lments de script sont chapps, <em>$jazz</em> n'est jamais valu en vue d'en connatre
    la valeur logique. Supposons que les barres de fraction inverses prcdent les lments de script qui sont
    lgitimement chapps:
  </p>
  <source><![CDATA[
\\#if( $jazz )
   Vyacheslav Ganelin
\\#end
]]></source>
  <p>Dans ce cas, si <em>$jazz</em> est vrai, la sortie est</p>
  <source><![CDATA[
\ Vyacheslav Ganelin
\
]]></source>
  <p>
    Pour comprendre, notons que le  <code>#if( arg ) </code>, lorsqu'il est termin par un retour  la ligne, omettra
    ce retour  la ligne de la sortie produite. Donc, le corps du bloc <code>#if()</code> suit la premire barre '\',
    rendue par le '\\' qui prcde <code>#if()</code>. Le dernier \ est sur une ligne diffrente du texte qui prcde
    parce qu'il y a un retour chariot aprs 'Ganelin', et donc le \\ final, qui prcde le <code>#end</code> fait partie
    du corps du bloc.
  </p>
  <p>
    Si <em>$jazz</em> est faux, il n'y a pas de sortie produite. Notons que les choses vont commencer  mal se passer
    si des lments de script ne sont pas chapps correctement.
  </p>
  <source><![CDATA[
\\\#if( $jazz )
    Vyacheslave Ganelin
\\#end
]]></source>
  <p>
    Ici le <em>#if</em> est chapp, mais il y a un <em>#end</em> qui reste l, et trop de terminaisons vont causer
    une erreur dans l'interprtation.
  </p>
</section>

<section name="VTL: Questions de format">
  <p>
    Bien que le VTL soit souvent montr dans ce guide de l'utilisateur avec des sauts de ligne et des espaces,
    le VTL ci-dessous:
  </p>
  <source><![CDATA[
#set( $imperial = ["Munetaka","Koreyasu","Hisakira","Morikune"] )
#foreach( $shogun in $imperial )
    $shogun
#end
]]></source>
  <p>
    est tout aussi valide que le bout de code suivant, post par Geir Magnusson Jr.  la liste de diffusion Velocity
    (pour illustrer un point sans rapport avec notre sujet):
  </p>
  <source><![CDATA[
Send me #set($foo = ["$10 and ","a cake"])#foreach($a in $foo)$a #end please.
]]></source>
  <p>Velocity digre les blancs inutiles. La directive qui prcde peut donc s'crire de la manire suivante:</p>
  <source><![CDATA[
Send me
#set( $foo = ["$10 and ","a cake"] )
#foreach( $a in $foo )
$a
#end
please.
]]></source>
  <p>ou encore:</p>
  <source><![CDATA[
Send me
#set($foo       = ["$10 and ","a cake"])
                 #foreach           ($a in $foo )$a
         #end please.
]]></source>
  <p>Dans tous les cas, la sortie sera identique.</p>
</section>

<section name="Autres caractristiques et sujets divers">
  <subsection name="Math">
    <p>
      Velocity a quelques fonctions mathmatiques intgres, fonctions que l'on peut utiliser dans les gabarits
      avec la directive <em>set</em>. Les quations suivantes sont des exemples d'addition, soustraction, multiplication
      et division respectivement:
    </p>
    <source><![CDATA[
#set( $foo = $bar + 3 )
#set( $foo = $bar - 4 )
#set( $foo = $bar * 6 )
#set( $foo = $bar / 2 )
]]></source>
    <p>
      Lorsqu'une opration de division est excute, le rsultat sera un entier. Le reste ventuel de la division peut 
      tre obtenu en utilisant l'oprateur modulo (<em>%</em>).
    </p>
    <source><![CDATA[
#set( $foo = $bar % 5 )
]]></source>
    <p>
      Seuls les entiers  (...-2, -1, 0, 1, 2...) sont admis comme oprandes des quations mathmatiques en Velocity;
      lorsqu'un non-entier est rencontr, cela est signal et null sera renvoy dans la sortie produite.
    </p>
  </subsection>
  
  <subsection name="Oprateur d'intervalle (range)">
    <p>
      L'oprateur d'intervalle peut tre utilis en conjonction avec les instructions <em>#set</em> et
      <em>#foreach</em>. C'est assez commode pour produire un tableau d'objets contenant des entiers;
      l'oprateur d'intervalle est construit comme ceci:
    </p>
    <source><![CDATA[
[n..m]
]]></source>
    <p>
      <em>n</em> et <em>m</em> doivent tous deux tre ou renvoyer des entiers. Que <em>m</em> soit plus grand ou plus
      petit que <em>n</em> importe peu, si cela se produit le tableau dcompte. Voici quelques exemples de l'oprateur
      de porte:
    </p>
    <source><![CDATA[
Premier exemple:
#foreach( $foo in [1..5] )
$foo
#end

Second exemple:
#foreach( $bar in [2..-2] )
$bar
#end

Troisime exemple:
#set( $arr = [0..1] )
#foreach( $i in $arr )
$i
#end

Quatrime exemple:
[1..3]
]]></source>
    <p>Produit la sortie suivante:</p>
    <source><![CDATA[
Premier exemple:
1 2 3 4 5

Second exemple:
2 1 0 -1 -2

Troisime exemple:
0 1

Quatrime exemple:
[1..3]
]]></source>
    <p>
      Il est  noter que l'oprateur d'intervalle ne produit le tableau qu'utilis en conjonction avec les directives
      <em>#set</em> et <em>#foreach</em>, comme dmontr dans le quatrime exemple.
    </p>
    <p>
      Les concepteurs de pages web soucieux de construire des tables de taille standard, mais dans lequelles il n'y a
      pas assez de donnes pour remplir la table, trouveront cet oprateur d'intervalle particulirement utile.
    </p>
  </subsection>
  
  <subsection name="Questions pointues: Echappement et !">
    <p>
      Lorsqu'une rfrence est annule par le caractre <em>!</em> et que ce caractre 
      <em>!</em> est prcd par un caractre d'chappement <em>\</em>, la rfrence est traite de manire particulire.
      A noter: les diffrences entre l'chappement ordinaire et le cas particulier o <em>\</em> prcde <em>!</em>
      comme ici:
    </p>
    <source><![CDATA[
#set( $foo = "bar" )
$\!foo
$\!{foo}
$\\!foo
$\\\!foo
]]></source>
    <p>Ceci produit la sortie suivante:</p>
    <source><![CDATA[
$!foo
$!{foo}
$\!foo
$\\!foo
]]></source>
    <p>A comparer avec l'chappement ordinaire, o <em>\</em> prcde <em>$</em>:</p>
    <source><![CDATA[
\$foo
\$!foo
\$!{foo}
\\$!{foo}
]]></source>
    <p>Ce qui produit la sortie suivante:</p>
    <source><![CDATA[
\$foo
\$!foo
\$!{foo}
\bar
]]></source>
  </subsection>
  
  <subsection name="Complments divers sur les Velocimacros">
    <p>
      Cette section est une mini-FAQ sur diffrents sujets relatifs aux Velocimacros.
      Cette section voluera au fil du temps, et cela vaudra donc la peine d'y revenir occasionnellement pour y
      chercher de nouvelles informations.
    </p>
    <p>Note: tout au long de cette section, 'Velocimacro' sera habituellement abrg en 'VM'.</p>
    <strong>Puis-je utiliser une directive ou une autre VM comme argument d'une VM?</strong>
    <p>Exemple : <code>#center( #bold("hello") )</code></p>
    <p>
      Non. Une directive n'est pas un argument valide d'une directive, et en pratique, pour l'essentiel,
      une VM est une directive.
    </p>
    <p>
      <i>Pourtant...</i>, il y a des choses que vous pouvez faire. Une solution, simple, est de tirer avantage du fait
      que l'apostrophe (") restitue son contenu. Vous pouvez donc crire quelque chose comme
    </p>
    <source><![CDATA[
#set($stuff = "#bold('hello')" )
#center( $stuff )
]]></source>
    <p>Vous pouvez mme vous pargner une tape...</p>
    <source><![CDATA[
#center( "#bold( 'hello' )" )
]]></source>
    <p>
      Mais il est  noter, dans ce dernier exemple, que l'argument est valu <i> l'intrieur</i> de la VM, pas au niveau
      de l'appel. En d'autres termes, l'argument pass  la VM est pass dans son intgralit et valu dans la VM 
      laquelle il a t pass. Ceci permet d'crire des choses comme:
    </p>
    <source><![CDATA[
#macro( inner $foo )
  inner : $foo
#end

#macro( outer $foo )
   #set($bar = "outerlala")
   outer : $foo
#end

#set($bar = 'calltimelala')
#outer( "#inner($bar)" )
]]></source>
    <p>La sortie produite est</p>
    <source><![CDATA[
Outer : inner : outerlala
]]></source>
    <p>
      puisque l'valuation de "#inner($bar)" se produit  l'intrieur de  #outer(), et c'est donc la valeur $bar
      positionne  l'intrieur de  #outer() qui est utilise.
    </p>
    <p>
      Ceci est tout  fait intentionnel, et c'est une caractristique jalousement garde - les arguments sont passs
      'par nom' aux VM, de sorte qu'on puisse passer aux VM un genre de "rfrences avec tat" telles que
    </p>
    <source><![CDATA[
#macro( foo $color )
  <tr bgcolor=$color><td>Hi</td></tr>
  <tr bgcolor=$color><td>There</td></tr>
#end

#foo( $bar.rowColor() )
]]></source>
    <p>
      et appeler rowColor() plusieurs fois, plutt qu'une fois. Pour viter cela, il faut appeler la mthode hors de la VM
      et passer la valeur  la VM.
    </p>
    <source><![CDATA[
#set($color = $bar.rowColor())
#foo( $color )
]]></source>
    <strong>Peut-on enregistrer des Velocimacros avec #parse() ?</strong>
    <p>
      Pour l'instant, les Velocimacros doivent tre dfinies avant d'tre utilises dans un gabarit.
      Ce qui signifie que les dclarations #macro() doivent prcder l'usage des Velocimacros.
    </p>
    <p>
      Il est important de s'en souvenir si l'on essaye d'interprter avec #parse() un gabarit qui contient des directives
      #macro() dfinies <i>inline</i>. Puisque le #parse() a lieu au moment de l'excution, et que l'interprteur dcide
       ce moment si quelque chose qui ressemble syntaxiquement  une VM dans le gabarit en est vraiment une au moment de
      l'interprtation, #parse()-r un ensemble de dclarations de VM ne fonctionnera pas comme on pourrait le prvoir.
      Pour contourner ce comportement, il suffit d'utiliser <code>velocimacro.library</code> pour que Velocity charge
      vos VM's au dmarrage.
    </p>
    <strong>Qu'est-ce que le <i>Velocimacro Autoreloading</i>?</strong>
    <p>Il existe une proprit, conue pour le <i>dveloppement</i>, pas pour la production:</p>
    <p><code>velocimacro.library.autoreload</code></p>
    <p>dont la valeur par dfaut est <i>false</i>. Lorsque cette proprit est positionne  <i>true</i>, en mme temps que</p>
    <p><code>&lt;type&gt;.resource.loader.cache = false</code></p>
    <p>
      (o &lt;type&gt; est le nom du chargeur de ressources que vous utilisez, par exemple 'file'), le moteur Velocity va
      automatiquement prendre en compte les changements apports  vos fichiers de bibliothques Velocimacro, au fur et 
      mesure que vous les modifiez, de sorte que vous n'ayez pas  arrter le moteur de servlet (ou l'application) ou avoir
      recours  tout autre subterfuge de ce genre pour recharger vos Velocimacros.
    </p>
    <p>Voici  quoi peut ressembler un ensemble simple de proprits.</p>
    <source><![CDATA[
    file.resource.loader.path = templates
    file.resource.loader.cache = false
    velocimacro.library.autoreload = true
    ]]></source>
    <p>Ne gardez pas cette configuration en production.</p>
  </subsection>
  
  <subsection name="Concatnation de chanes">
    <p>
      Une question habituelle parmi les dveloppeurs est:
      <i>Comment concatner des chanes de caractres? Y a-t'il quelque chose de semblable  l'oprateur '+' en Java?</i>.
    </p>
    <p>
      Pour concatner des rfrences en VTL, il suffit de les 'mettre ensemble'. Le contexte dans lequel vous voulez les
      assembler ainsi a une certaine importance, il faut donc illustrer notre propos par quelques exemples.
    </p>
    <p>Dans le flux habituel d'un gabarit (lorsqu'on mlange les rfrences avec du contenu ordinaire):</p>
    <source><![CDATA[
       #set( $size = "Big" )
       #set( $name = "Ben" )

      Cette horloge sonne comme $size$name.
   ]]></source>
    <p>
      produira 'Cette horloge sonne comme BigBen'. Pour prendre des exemples plus intressants, lorsqu'on veut concatner
      des chanes pour les passer  une mthode ou les assigner  une nouvelle rfrence, il suffit d'crire:
    </p>
    <source><![CDATA[
      #set( $size = "Big" )
      #set( $name = "Ben" )

      #set($clock = "$size$name" )

      Cette horloge sonne comme $clock.
    ]]></source>
    <p>
      Ce qui produit le mme rsultat. Dernier exemple, lorsqu'on veut mlanger des chanes "statiques" avec des
      rfrences, il peut tre ncessaire d'utiliser les "rfrences formelles" rencontres plus haut:
    </p>
    <source><![CDATA[
      #set( $size = "Big" )
      #set( $name = "Ben" )

      #set($clock = "${size}Tall$name" )

      Cette horloge sonne comme $clock.
    ]]></source>
    <p>
      Et maintenant le rsultat produit est 'Cette horloge sonne comme BigTallBen'.
      La notation formelle est requise pour que l'interprteur comprenne que l'on souhaite utiliser '$size' et non
      '$sizeTall', ce qui serait le cas si les accolades n'taient pas prsentes.
    </p>
  </subsection>
</section>

<section name="Donnez votre avis">
  <p>
    Si vous rencontrez des erreurs dans le manuel (autres que des erreurs de traduction), ou si vous voulez faire part de
    votre avis sur le Guide de l'utilisateur Velocity,
    envoyez un mail  la <a href="mailto:velocity-user@jakarta.apache.org">Velocity user list</a>.
    Merci!
  </p>
</section>
</body>
</document>