smarty/docs/fr/programmers/api-variables.xml

<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision$ -->
    <chapter id="api.variables">
     <title>Variables</title>

     <sect1 id="variable.template.dir">
      <title>$template_dir</title>
      <para>
      C'est le nom par d<>faut du r<>pertoire des templates.
      Si vous ne sp<73>cifiez aucun chemin lors de l'utilisation de templates, Smarty
      les cherchera a cet emplacement.
      Par d<>faut, il s'agit de "./templates", ce qui signifie
      qu'il va chercher le r<>pertoire templates
      dans le r<>pertoire o<> se trouve le script PHP en cours d'ex<65>cution.
      </para>

	   <note>
		   <title>Note technique</title>
         <para>
         Il n'est pas conseill<6C> de mettre ce r<>pertoire
         dans l'arborescence Web.
         </para>
	  </note>
     </sect1>		
     <sect1 id="variable.compile.dir">
      <title>$compile_dir</title>
      <para>
      C'est le nom du r<>pertoire o<> se trouvent les templates
      compil<69>s. Par d<>faut, il s'agit de "./templates_c",
      ce qui signifie que Smarty va chercher ce r<>pertoire
      dans le m<>me r<>pertoire que le script PHP en cours d'ex<65>cution.
      </para>
	 <note>
	 <title>Note technique</title>
	 <para>
	 Ce r<>glage doit <20>tre soit un chemin absolu, soit un chemin
	 relatif. include_path n'est pas utilis<69> pour <20>crire des fichiers.
	 </para>
	 </note>
	 <note>
	 <title>Note technique</title>
	 <para>
	 Il n'est pas conseill<6C> de mettre ce r<>pertoire
    sous la racine de l'arborescence Web.
	 </para>
	 </note>
     </sect1>
     <sect1 id="variable.config.dir">
      <title>$config_dir</title>
      <para>
      Il s'agit du r<>pertoire utilis<69> pour stocker les
      fichiers de configuration utilis<69>s dans les templates.
      La valeur par d<>faut est "./configs", ce qui signifie
      que Smarty va chercher ce r<>pertoire
      dans le m<>me r<>pertoire que le script PHP qui s'ex<65>cute.
      </para>
	 <note>
	 <title>Note technique</title>
	 <para>
       Il n'est pas conseill<6C> de mettre ce r<>pertoire
      sous la racine de l'arborescence Web.
    </para>
	 </note>
     </sect1>
     <sect1 id="variable.plugins.dir">
      <title>$plugins_dir</title>
      <para>
      Ce sont les r<>pertoire dans lesquels Smarty ira chercher les plugins
      dont il a besoin. La valeur par d<>faut est "plugins" sous le
      r<>pertoire SMARTY_DIR. Si vous donnez un chemin relatif, Smarty
      regardera d'abord relativement au SMARTY_DIR, puis relativement au rtc (r<>pertoire
      de travail courant), puis relativement a chaque entr<74>e de votre r<>pertoire
      d'inclusion PHP.
      </para>
	  <note>
	  <title>Note technique</title>
	  <para>
	  Pour des raisons de performances, ne r<>glez pas votre plugins_dir
	  pour qu'il utilise votre include_path PHP. Utilisez un
	  chemin absolu ou un chemin relatif a SMARTY_DIR ou au rtc.
	  </para>
	  </note>
     </sect1>
     <sect1 id="variable.debugging">
      <title>$debugging</title>
      <para>
      Cela active la
      <link
        linkend="chapter.debugging.console">console de d<>bogage</link>.
      La console est une fen<65>tre javascript qui vous informe des templates
      inclus et des variables assign<67>es dans la page courante.
      </para>
     </sect1>
     <sect1 id="variable.debug.tpl">
      <title>$debug_tpl</title>
      <para>
      C'est le nom du fichier template utilis<69> pour la
      console de d<>buggage. Par d<>faut debug.tpl, il se situe dans <link
	   linkend="constant.smarty.dir">SMARTY_DIR</link>
      </para>
     </sect1>
     <sect1 id="variable.debugging.ctrl">
      <title>$debugging_ctrl</title>
      <para>
      Cela permet d'avoir diff<66>rents moyens pour activer
      le d<>bogage. URL signifie que si SMARTY_DEBUG se
      trouve dans QUERY_STRING, le d<>buggage
      est activ<69> a l'invocation du script. Si $debugging
      est a vrai, cette valeur est sans effet.
      </para>
     </sect1>
     <sect1 id="variable.global.assign">
      <title>$global_assign</title>
      <para>
      C'est une liste de variable qui sont toujours
      implicitement assign<67>es au moteur de templates.
      Ceci est commode pour rendre des variables globales
      ou des variables du serveur accessibles a tous les templates
      plut(t que de devoir les assigner a la main. Chaque <20>l<EFBFBD>ment
      de $global_assign doit <20>tre soit le nom de la variable
      globale, soit une paire clef/valeur, o<> clef est le
      nom du tableau global et valeur le tableau de variable
      assign<67>es depuis ce tableau global.
      $SCRIPT_NAME est globalement assign<67> par d<>faut depuis
      $HTTP_SERVER_VARS.
      </para>
	 <note>
	 <title>Note technique</title>
	 <para>
	 On peut acc<63>der aux variables du serveur avec la variable
	 $smarty, par exemple {$smarty.server.SCRIPT_NAME}.
	 Se reporter a la section sur la variable
	 <link linkend="language.variables.smarty">$smarty</link>.
	 </para>
	 </note>
     </sect1>
     <sect1 id="variable.undefined">
      <title>$undefined</title>
      <para>
      Cela r<>gle la valeur de $undefined, null par d<>faut.
      N'est actuellement utilis<69> que pour initialiser
      des variables non-d<>finies dans $global_assign a des
      valeurs par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.autoload.filters">
      <title>$autoload_filters</title>
      <para>
      Si vous d<>sirez charger des filtres a chaque invocation
      de templates, vous pouvez le sp<73>cifier en utilisant cette
      variable. Les types de filtres et les valeurs sont des
      tableaux comportant le nom des filtres.
       <informalexample>
        <programlisting>
$smarty-&gt;autoload_filters = array('pre' =&gt; array('trim', 'stamp'),
                                  'output' => array('convert')); 
        </programlisting>
       </informalexample> 
      </para>
     </sect1>
     <sect1 id="variable.compile.check">
      <title>$compile_check</title>
      <para>
      A chaque invocation de l'application PHP, Smarty fait
      un test pour voir si le template courant a <20>t<EFBFBD> modifi<66>
      (date de derni<6E>re modification diff<66>rente) depuis sa
      derni<6E>re compilation. S'il a chang<6E>, le template est recompil<69>.
      Si le template n'a pas encore <20>t<EFBFBD> compil<69>, il le sera
      quelle que soit la valeur ce r<>glage.
      Par d<>faut cette valeur est a vrai. Quand
      une application est mise en production (les templates
      ne changent plus), cette v<>rification n'est pas n<>cessaire.
      Assurez-vous de mettre $compile_check a "false" pour des performances
      maximales. Notez que si vous mettez ce param<61>tre a "false" et qu'un
      template est modifi<66>, vous ne verrez *pas* le changement
      car le template ne sera *pas* recompil<69>. Si le processus de cache
      est activ<69> et que $compile_check l'est aussi, alors les fichiers
      du cache seront reg<65>n<EFBFBD>r<EFBFBD>s si un template concern<72> ou un fichier de
      configuration concern<72> est modifi<66>. Voir aussi <link
	   linkend="variable.force.compile">$force_compile</link> ou <link
	   linkend="api.clear.compiled.tpl">clear_compiled_tpl</link>.
      </para>

     </sect1>
     <sect1 id="variable.force.compile">
      <title>$force_compile</title>
      <para>
      Cela oblige Smarty a (re)compiler les templates a chaque
      invocation. Ce r<>glage supplante $compile_check. Par d<>faut, il
      est d<>sactiv<69>. Ceci est commode pour le d<>veloppement et le
      d<>bogage mais ne devrait jamais <20>tre utilis<69> dans un environnment
      de production. Si le syst<73>me de cache est actif, les
      fichiers du cache seront reg<65>n<EFBFBD>r<EFBFBD>s a chaque appel.
      </para>
     </sect1>
     <sect1 id="variable.caching">
      <title>$caching</title>
      <para>
      Ce param<61>tre demande a Smarty de mettre ou non en cache la sortie des
      templates.
      Par d<>faut ce r<>glage est a 0 (d<>sactiv<69>). Si vos templates
      g<>n<EFBFBD>rent du contenu redondant, il est conseill<6C> d'activer le
      cache. Cela permettra un gain de performance cons<6E>quent.
      Vous pouvez aussi avoir de nombreux fichiers de cache pour un m<>me template.
      Une valeur de 1 ou 2 active le cache. 1 indique a Smarty d'utiliser
      la variable $cache_lifetime pour d<>terminer si le fichier de cache a expir<69>.
      Une valeur de 2 indique a Smarty d'utiliser la valeur
      $cache_lifetime sp<73>cifi<66>e a la g<>n<EFBFBD>ration du cache. Ainsi vous pouvez r<>gler
      la dur<75>e de vie d'un fichier de cache avant de r<>cup<75>rer le template pour avoir
      un certain contr(le quand ce fichier en particulier expire. Voir
      aussi <link linkend="api.is.cached">is_cached</link>.
      </para>
      <para>
      Si $compile_check est actif, le contenu du cache sera reg<65>n<EFBFBD>r<EFBFBD>
      si un des templates ou un des fichiers de configuration qui fait partie
      de ce fichier de cache a <20>t<EFBFBD> modifi<66>. Si $force_compile est actif, le contenu
      du cache est toujours reg<65>n<EFBFBD>r<EFBFBD>.
      </para>
     </sect1>
     <sect1 id="variable.cache.dir">
      <title>$cache_dir</title>
      <para>
      Il s'agit du nom du r<>pertoire o<> les caches des templates
      sont stock<63>s. Par d<>faut il s'agit de "./cache", ce qui signifie
      que Smarty va chercher ce r<>pertoire
      dans le m<>me r<>pertoire que le script PHP en cours d'ex<65>cution.
      </para>
	 <note>
	 <title>Note technique</title>
	 <para>
       Ce r<>glage doit <20>tre soit un chemin absolu, soit un chemin
	 relatif. include_path n'a aucune influence lors de l'<27>criture des fichiers.
      </para>
	  </note>
	  <note>
		  <title>Note technique</title>
		  <para>
         Il n'est pas conseill<6C> de mettre ce r<>pertoire
         dans l'arborescence Web.
    	  </para>
	  </note>
     </sect1>
     <sect1 id="variable.cache.lifetime">
      <title>$cache_lifetime</title>
      <para>
      Il s'agit de la dur<75>e en secondes pendant laquelle un cache de template
      est valide. Une fois cette dur<75>e d<>pass<73>e, le cache est reg<65>n<EFBFBD>r<EFBFBD>.
      $caching doit <20>tre a "true" pour que $cache_lifetime ait une
      quelconque utilit<69>. Avec une valeur de -1, le cache n'expire jamais.
      Avec une valeur de 0, le cache est toujours reg<65>n<EFBFBD>r<EFBFBD> (utile
      a des fins de tests seulement. Une meilleure faton de d<>sactiver
      le cache est de mettre <link
	   linkend="variable.caching">$caching</link> a "false").
      </para>
      <para>
      Si <link linkend="variable.force.compile">$force_compile</link> est
      activ<69>, les fichiers du cache seront reg<65>n<EFBFBD>r<EFBFBD>s a chaque fois,
      d<>sactivant ainsi le cache. Vous pouvez effacer tous les fichiers du cache
      avec la function
      <link linkend="api.clear.all.cache">clear_all_cache()</link>
      ou de faton individuelle (ou group<75>e)
      avec la fonction <link
	   linkend="api.clear.cache">clear_cache()</link>.
      </para>
	  <note>
	  <title>Note technique</title>
	  <para>
	  Si vous souhaitez donner a certains templates leur propre dur<75>e de vie
	  en cache, vous pouvez le faire en r<>glant
	  <link linkend="variable.caching">$caching</link> a 2,
	  puis $cache_lifetime a une unique valeur juste avant d'appeler
	  display ou fetch().
	  </para>
	  </note>
     </sect1>
     <sect1 id="variable.cache.handler.func">
      <title>$cache_handler_func</title>
      <para>
      Vous pouvez utiliser votre propre fonction de gestion du cache plut(t que
      d'utiliser celle livr<76>e avec Smarty.
      R<>f<EFBFBD>rez-vous a la section sur la fonction de gestion de cache
      personnalis<69>e pour plus de d<>tails.
      </para>
     </sect1>
     <sect1 id="variable.cache.modified.check">
      <title>$cache_modified_check</title>
      <para>
      Si cette variable est a vrai, Smarty respectera l'en-t<>te
      If-Modified-Since envoy<6F> par le client. Si la date de derni<6E>re
      modification du fichier de cache n'a pas chang<6E> depuis la derni<6E>re
      visite, alors un en-t<>te "304 Not Modified" sera envoy<6F> a la place
      du contenu. Cela ne fonctionne qu'avec du contenu mis en cache hors de la
      balise <command>insert</command>.
      </para>
     </sect1>
     <sect1 id="variable.config.overwrite">
      <title>$config_overwrite</title>
      <para>
      Si cette variable est a vrai, les variables lues dans les fichiers
      de configuration peuvent s'<27>craser entre elles. Sinon les variables
      seront mises dans un tableau. Tr<54>s utile si vous voulez stocker
      des tableaux de donn<6E>es dans des fichiers de configuration, listez
      simplement chaque <20>l<EFBFBD>ment plusieurs fois. Mise a faux par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.config.booleanize">
      <title>$config_booleanize</title>
      <para>
      Si cette variable est a vrai, les valeurs on/true/yes et off/false/no
      dans les fichiers de configuration sont automitiquement converties
      en bool<6F>en. De cette faton vous pouvez utiliser ces valeurs dans le
      template de la faton suivante : {if #foobar#} ... {/if}. Si foobar
      est a on, true ou yes, l'instruction {if} sera ex<65>cut<75>e. vrai
      par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.config.read.hidden">
      <title>$config_read_hidden</title>
      <para>
      Si cette variable est a vrai, les sections cach<63>s (dont les noms
      commencent par un point) dans les fichiers de configuration peuvent
      <20>tre lues depuis les templates. On laisse habituellement cela a faux, de
      cette faton vous pouvez stocker des donn<6E>es sensibles dans les fichiers
      de configuration, comme par exemple des param<61>tres de base de donn<6E>es,
      sans vous soucier de la faton dont les templates les chargent.
      Mise a faux par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.config.fix.newlines">
      <title>$config_fix_newlines</title>
      <para>
      Si cette variable est mise a vrai, les caract<63>res de nouvelles lignes mac et dos
      (\r et \r\n) sont convertis en \n quand ils sont analys<79>s. vrai par d<>faut.
      </para>
     </sect1>
     <sect1 id="variable.default.template.handler.func">
      <title>$default_template_handler_func</title>
      <para>
      Cette fonction est appel<65>e quand un template ne peut pas <20>tre
      obtenu avec sa ressource.
      </para>
     </sect1>
     <sect1 id="variable.php.handling">
      <title>$php_handling</title>
      <para>
      Indique a Smarty comment interpr<70>ter le code PHP
      int<6E>gr<67> dans les templates. Il y a quatre valeurs possibles, par
      d<>faut SMARTY_PHP_PASSTHRU. Notez que cela n'affecte PAS le code
      PHP entour<75> des balises
      <link linkend="language.function.php">{php}{/php}</link>
      dans le template.
      </para>
      <itemizedlist>
       <listitem><para>SMARTY_PHP_PASSTHRU - Smarty <20>crit les balises
       telles quelles.</para></listitem>
       <listitem><para>SMARTY_PHP_QUOTE - Smarty transforme les balises
       en entit<69>s HTML.</para></listitem>
       <listitem><para>SMARTY_PHP_REMOVE - Smarty supprime les balises
       des templates.</para></listitem>
       <listitem><para>SMARTY_PHP_ALLOW - Smarty ex<65>cute les balises
       comme du code PHP.</para></listitem>
      </itemizedlist>
      <para>
      NOTE : Int<6E>grer du code PHP dans les templates est vivement
      d<>conseill<6C>. Pr<50>f<EFBFBD>rez les
      <link linkend="language.custom.functions">fonctions utilisateurs</link>
      ou les <link linkend="language.modifiers">modificateurs de variables</link>.
      </para>
     </sect1>
     <sect1 id="variable.security">
      <title>$security</title>
      <para>
      Cette variable est a faux par d<>faut. $security est de rigueur
      quand vous n'Otes pas compl<70>tement svr des personnes qui <20>ditent les templates
      (par ftp par exemple) et que vous voulez r<>duire le risque que
      la s<>curit<69> du syst<73>me soit compromise par le language de template.
      Activer cette option de s<>curit<69> applique les r<>gles suivantes
      au langage de template, a moins que $security_settings ne sp<73>cifie
      le contraire :
      </para>
      <itemizedlist>
       <listitem><para>Si $php_handling est r<>gl<67>e a SMARTY_PHP_ALLOW,
         cela est implicitement chang<6E> a SMARTY_PHP_PASSTHRU.</para></listitem>
       <listitem><para>Les fonctions PHP ne sont pas autoris<69>es dans les
         instructions IF, a part celles d<>clar<61>es dans
         $security_settings.</para></listitem>
       <listitem><para>Les templates ne peuvent <20>tre inclus que depuis
         des r<>pertoires list<73>s dans le tableau $security_dir.</para></listitem>
       <listitem><para>Les fichiers locaux ne peuvent <20>tre r<>cup<75>r<EFBFBD>s que depuis
         les r<>pertoires list<73>s dans le tableau $security_dir en
         utilisant {fetch}.</para></listitem>
       <listitem><para>Les balises {php}{/php} ne sont pas autoris<69>es.</para></listitem>
       <listitem><para>Les fonctions PHP ne sont pas autoris<69>es en tant
         modificateurs, a part celles sp<73>cifi<66>es dans $security_settings.</para></listitem>
      </itemizedlist>
     </sect1>
     <sect1 id="variable.secure.dir">
      <title>$secure_dir</title>
      <para>
      Il s'agit d'un tableau contenant tous les r<>pertoires locaux qui sont
      consid<69>r<EFBFBD>s comme s<>curis<69>s. {include} et {fetch} l'utilisent quand
      la s<>curit<69> est activ<69>e.
      </para>
     </sect1>
     <sect1 id="variable.security.settings">
      <title>$security_settings</title>
      <para>
      Ces r<>glages servent <20> <20>craser ou sp<73>cifier les param<61>tres de s<>curit<69>
      quand celle-ci est activ<69>e. Les r<>glages possibles sont les suivants :
      </para>
      <itemizedlist>
       <listitem><para>PHP_HANDLING - true/false. Si vrai, le
       r<>glage $php_handling n'est pas v<>rifi<66>.</para></listitem>
       <listitem><para>IF_FUNCS - Le tableau des noms de fonctions
       PHP autoris<69>es dans les intructions IF.</para></listitem>
       <listitem><para>INCLUDE_ANY - true/false. Si vrai,
       les templates peuvent <20>tre inclus de n'importe o<>, quelque soit
       le contenu de $secure_dir.</para></listitem>
       <listitem><para>PHP_TAGS - true/false. Si vrai,
       les balises {php}{/php} sont autoris<69>es dans les templates.</para></listitem>
       <listitem><para>MODIFIER_FUNCS - Le tableau des noms de fonctions
       autoris<69>es a <20>tre utilis<69>es comme modificateurs de variables.</para></listitem>
      </itemizedlist>
     </sect1>
     <sect1 id="variable.trusted.dir">
      <title>$trusted_dir</title>
      <para>
      $trusted_dir n'est utilis<69>e lorsque $security est activ<69>e. C'est un
      tableau de tous les r<>pertoires qui peuvent <20>tre consid<69>r<EFBFBD>s comme svrs.
      Les r<>pertoires svrs sont ceux qui contiennent des scripts PHP qui
      sont ex<65>cut<75>s directement depuis les templates avec
      <link linkend="language.function.include.php">{include_php}</link>.
      </para>
     </sect1>
     <sect1 id="variable.left.delimiter">
      <title>$left_delimiter</title>
      <para>
      Il s'agit du d<>limiteur gauche utilis<69> par le moteur de templates. La
      valeur par d<>faut est "{".
      </para>
     </sect1>
     <sect1 id="variable.right.delimiter">
      <title>$right_delimiter</title>
      <para>
      Il s'agit du d<>limiteur droit utilis<69> par le moteur de templates.
      La valeur par d<>faut est "}".
      </para>
     </sect1>
     <sect1 id="variable.compiler.class">
      <title>$compiler_class</title>
      <para>
      Sp<53>cifie le nom de la classe du compilateur qui va <20>tre utilis<69>e pour
      compiler les templates. Le compilateur par d<>faut est
      'Smarty_Compiler'. R<>serv<72> aux utilisateurs avanc<6E>s.
      </para>
     </sect1>
     <sect1 id="variable.request.vars.order">
      <title>$request_vars_order</title>
      <para>
      L'ordre dans lequel les variables de requ<71>tes sont enregistr<74>es,
      identique a variables_order dans php.ini.
      </para>
     </sect1>
     <sect1 id="variable.compile.id">
      <title>$compile_id</title>
      <para>
      Identifiant persistant du compilateur. On peut passer le m<>me compile_id
      a chaque appel de fonction mais une alternative consiste a r<>gler ce
      compile_id, qui sera utilis<69> implicitement.
      </para>
     </sect1>
     <sect1 id="variable.use.sub.dirs">
      <title>$use_sub_dirs</title>
      <para>
      R<>gler cela a faux si votre environnement PHP n'autorise pas Smarty a cr<63>er
      des sous-r<>pertoires. Les sous-r<>pertoires sont efficaces, utilisez-les quand
      vous le pouvez.
      </para>
     </sect1>
     <sect1 id="variable.default.modifiers">
      <title>$default_modifiers</title>
      <para>
      Il s'agit d'un tableau de modificateurs utilis<69> pour assigner
      une valeur par d<>faut a chaque variable dans un template.
      Par exemple, pour par d<>faut <20>chapper les caract<63>res HTML de chaque variable,
      utilisez array('escape:"htmlall"'); Pour rendre une variable ind<6E>pendante
      des modificateurs par d<>faut, passez-lui en param<61>tre le modificateur
      "nodefaults" : {$var|nodefaults}.
      </para>
     </sect1>
</chapter>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"../../../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->