<!DOCTYPE html SYSTEM "about:legacy-compat">
<html lang="fr"><head><META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta content="width=device-width, initial-scale=1" name="viewport">
<!--
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
              This file is generated from xml source: DO NOT EDIT
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
      -->
<title>mod_rewrite - Serveur HTTP Apache Version 2.4</title>
<link href="../style/css/manual.css" rel="stylesheet" media="all" type="text/css" title="Main stylesheet">
<link href="../style/css/manual-loose-100pc.css" rel="alternate stylesheet" media="all" type="text/css" title="No Sidebar - Default font size">
<link href="../style/css/manual-print.css" rel="stylesheet" media="print" type="text/css"><link rel="stylesheet" type="text/css" href="../style/css/prettify.css">
<script src="../style/scripts/prettify.min.js">
</script>

<link href="../images/favicon.png" rel="shortcut icon"></head>
<body>
<div id="page-header">
<p class="menu"><a href="../mod/">Modules</a> | <a href="../mod/quickreference.html">Directives</a> | <a href="https://cwiki.apache.org/confluence/display/httpd/FAQ">FAQ</a> | <a href="../glossary.html">Glossaire</a> | <a href="../sitemap.html">Plan du site</a> | <a href="https://bz.apache.org/bugzilla/enter_bug.cgi?product=Apache%20httpd-2">Signaler un bug</a></p>
<p class="apache">Serveur HTTP Apache Version 2.4</p>
<img alt="" src="../images/feather.png"></div>
<div class="up"><a href="./"><img title="<-" alt="<-" src="../images/left.gif"></a></div>
<div id="path">
<a href="https://www.apache.org/">Apache</a> &gt; <a href="https://httpd.apache.org/">Serveur HTTP</a> &gt; <a href="https://httpd.apache.org/docs/">Documentation</a> &gt; <a href="../">Version 2.4</a> &gt; <a href="./">Modules</a></div>
<div id="page-content">
<div id="preamble"><h1>Module Apache mod_rewrite</h1>
<button aria-label="Toggle language list" class="lang-toggle"><svg xmlns="http://www.w3.org/2000/svg" stroke-width="2" stroke="currentColor" fill="none" viewBox="0 0 24 24" height="16" width="16"><circle r="10" cy="12" cx="12"/><line y2="12" x2="22" y1="12" x1="2"/><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/></svg></button>
<div class="toplang">
<p><span>Langues Disponibles: </span><a href="../en/mod/mod_rewrite.html" hreflang="en" rel="alternate" title="English">&nbsp;en&nbsp;</a> |
<a href="../fr/mod/mod_rewrite.html" title="Fran&ccedil;ais">&nbsp;fr&nbsp;</a></p>
</div>
<div class="outofdate">Cette traduction peut &ecirc;tre p&eacute;rim&eacute;e. V&eacute;rifiez la version
            anglaise pour les changements r&eacute;cents.</div>
<table class="module"><tr><th><a href="module-dict.html#Description">Description:</a></th><td>Ce module fournit un moteur de r&eacute;&eacute;criture &agrave; base de
r&egrave;gles permettant de r&eacute;&eacute;crire les URLs des requ&ecirc;tes
&agrave; la vol&eacute;e</td></tr>
<tr><th><a href="module-dict.html#Status">Statut:</a></th><td>Extension</td></tr>
<tr><th><a href="module-dict.html#ModuleIdentifier">Identificateur&nbsp;de&nbsp;Module:</a></th><td>rewrite_module</td></tr>
<tr><th><a href="module-dict.html#SourceFile">Fichier&nbsp;Source:</a></th><td>mod_rewrite.c</td></tr></table>
<h3>Sommaire</h3>

      <p>Le module <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> utilise un moteur de
      r&eacute;&eacute;criture &agrave; base de r&egrave;gles, bas&eacute; sur un interpr&eacute;teur
      d'expressions rationnelles PCRE, pour r&eacute;&eacute;crire les URLs &agrave; la vol&eacute;e. Par
      d&eacute;faut, <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> met en correspondance une URL
      avec le syst&egrave;me de fichiers. Cependant, on peut aussi l'utiliser
      pour rediriger une URL vers une autre URL, ou pour invoquer une
      requ&ecirc;te interne &agrave; destination du mandataire.</p>
      <p><code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> fournit une m&eacute;thode souple et
      puissante pour manipuler les URLs en utilisant un nombre illimit&eacute;
      de r&egrave;gles. Chaque r&egrave;gle peut &ecirc;tre associ&eacute;e &agrave; un nombre illimit&eacute; de
      conditions, afin de vous permettre de r&eacute;&eacute;crire les URLs en
      fonction de variables du serveur, de variables d'environnement,
      d'en-t&ecirc;tes HTTP, ou de rep&egrave;res temporels.</p>
      <p><code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> agit sur la totalit&eacute; de l'URL, y
      compris la partie chemin. Une r&egrave;gle de r&eacute;&eacute;criture peut &ecirc;tre
      invoqu&eacute;e dans <code>httpd.conf</code> ou dans un fichier
      <code>.htaccess</code>. Le chemin g&eacute;n&eacute;r&eacute; par une r&egrave;gle de
      r&eacute;&eacute;criture peut inclure une cha&icirc;ne de param&egrave;tres, ou peut renvoyer
      vers un traitement secondaire interne, une redirection vers une
      requ&ecirc;te externe ou vers le mandataire interne.</p>

      <p>Une expression rationnelle ne n&eacute;cessite des guillemets que si elle
      contient des espaces non prot&eacute;g&eacute;es, auquel cas les guillemets simples ou
      doubles sont &eacute;quivalents.</p>

      <p>Vous trouverez d'avantage de d&eacute;tails, discussions et exemples
      dans la
      <a href="../rewrite/">documentation d&eacute;taill&eacute;e
      sur mod_rewrite</a>.</p>
</div>
<div id="quickview"><h3>Sujets</h3>
<ul id="topics">
<li><img alt="" src="../images/down.gif"> <a href="#logging">Journalisation</a></li>
</ul><h3 class="directives">Directives</h3>
<ul id="toc">
<li><img alt="" src="../images/down.gif"> <a href="#rewritebase">RewriteBase</a></li>
<li><img alt="" src="../images/down.gif"> <a href="#rewritecond">RewriteCond</a></li>
<li><img alt="" src="../images/down.gif"> <a href="#rewriteengine">RewriteEngine</a></li>
<li><img alt="" src="../images/down.gif"> <a href="#rewritemap">RewriteMap</a></li>
<li><img alt="" src="../images/down.gif"> <a href="#rewriteoptions">RewriteOptions</a></li>
<li><img alt="" src="../images/down.gif"> <a href="#rewriterule">RewriteRule</a></li>
</ul>
<h3>Traitement des bugs</h3><ul class="seealso"><li><a href="https://www.apache.org/dist/httpd/CHANGES_2.4">Journal des modifications de httpd</a></li><li><a href="https://bz.apache.org/bugzilla/buglist.cgi?bug_status=__open__&amp;list_id=144532&amp;product=Apache%20httpd-2&amp;query_format=specific&amp;order=changeddate%20DESC%2Cpriority%2Cbug_severity&amp;component=mod_rewrite">Probl&egrave;mes connus</a></li><li><a href="https://bz.apache.org/bugzilla/enter_bug.cgi?product=Apache%20httpd-2&amp;component=mod_rewrite">Signaler un bug</a></li></ul></div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif"></a></div>
<div class="section">
<h2 id="logging">Journalisation <a title="Lien permanent" href="#logging" class="permalink">&para;</a></h2>

    <p><code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> offre une journalisation d&eacute;taill&eacute;e
    de ses actions aux niveaux de journalisation <code>trace1</code> &agrave;
    <code>trace8</code>. Le niveau de journalisation peut &ecirc;tre d&eacute;fini de
    mani&egrave;re sp&eacute;cifique &agrave; <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> via la directive
    <code class="directive"><a href="../mod/core.html#loglevel">LogLevel</a></code> : jusqu'au niveau
    <code>debug</code> aucune action n'est journalis&eacute;e, alors qu'elles
    le sont pratiquement toutes au niveau <code>trace8</code>.</p>

    <div class="note">
      L'utilisation d'un niveau de journalisation &eacute;lev&eacute; pour
      <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> va ralentir votre serveur HTTP Apache
      de mani&egrave;re dramatique ! N'utilisez un niveau de journalisation
      sup&eacute;rieur &agrave; <code>trace2</code> qu'&agrave; des fins de d&eacute;bogage !
    </div>

    <div class="example"><h3>Exemple</h3><pre class="prettyprint lang-config">LogLevel alert rewrite:trace3</pre>
</div>

    <div class="note"><h3>RewriteLog</h3>
      <p>Ceux qui sont familiers avec les versions pr&eacute;c&eacute;dentes de
      <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> vont probablement rechercher en vain les
      directives <code>RewriteLog</code> et
      <code>RewriteLogLevel</code>. Elles ont &eacute;t&eacute; en effet remplac&eacute;es
      par une configuration de la journalisation par module, comme
      mentionn&eacute; plus haut.
      </p>

      <p>Pour extraire les traces sp&eacute;cifiques &agrave;
      <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code>, affichez le fichier journal en
      redirigeant la sortie vers grep :</p>
    <div class="example"><p><code>
    tail -f error_log|fgrep '[rewrite:'
    </code></p></div>
    </div>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif"></a></div>
<div class="directive-section"><h2 id="rewritebase">Directive <span id="RewriteBase">RewriteBase</span> <a title="Lien permanent" href="#rewritebase" class="permalink">&para;</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>D&eacute;finit l'URL de base pour les r&eacute;&eacute;critures au niveau
r&eacute;pertoire</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>RewriteBase <em>chemin_URL</em></code></td></tr>
<tr><th><a href="directive-dict.html#Default">D&eacute;faut:</a></th><td><code>Pas de valeur par d&eacute;faut</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>r&eacute;pertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">Surcharges autoris&eacute;es:</a></th><td>FileInfo</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Extension</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_rewrite</td></tr>
</table>
      <p>La directive <code class="directive">RewriteBase</code> permet de
      sp&eacute;cifier le pr&eacute;fixe d'URL &agrave; utiliser dans un contexte de
      r&eacute;pertoire (htaccess) pour les directives
      <code class="directive"><a href="#rewriterule">RewriteRule</a></code> qui r&eacute;&eacute;crivent vers un chemin
      relatif.</p>
      <p>Cette directive est <em>obligatoire</em> si vous utilisez un
      chemin relatif dans une substitution, et dans un contexte de
      r&eacute;pertoire (htaccess), sauf si au moins une de ces conditions est
      v&eacute;rifi&eacute;e :</p>
      <ul>
          <li>La requ&ecirc;te initiale, ainsi que la substitution, se
	  situent par raport &agrave; la valeur de la directive
	  <code class="directive"><a href="../mod/core.html#documentroot">DocumentRoot</a></code> (c'est &agrave;
	  dire que pour y acc&eacute;der, il n'est pas n&eacute;cessaire d'utiliser
	  une directive telle qu'<code class="directive"><a href="../mod/mod_alias.html#alias">Alias</a></code>).</li>
          <li>Le chemin du syst&egrave;me de fichiers vers le r&eacute;pertoire
	  contenant la <code class="directive"><a href="#rewriterule">RewriteRule</a></code>, suffix&eacute; par
	  la substitution relative est aussi valide en tant qu'URL sur
	  le serveur (ce qui est rare).</li>
	  <li>A partir de la version 2.4.16 du serveur HTTP Apache,
	  cette directive peut &ecirc;tre omise lorsque la requ&ecirc;te est mise en
	  correspondance avec le syst&egrave;me de fichiers via la directive
	  <code class="directive"><a href="../mod/mod_alias.html#alias">Alias</a></code> ou le module
	  <code class="module"><a href="../mod/mod_userdir.html">mod_userdir</a></code>.</li>
      </ul>

<p>Dans l'exemple ci-dessous, la directive
<code class="directive">RewriteBase</code> est n&eacute;cessaire afin d'&eacute;viter une
r&eacute;&eacute;criture en http://example.com/opt/myapp-1.2.3/welcome.html car la
ressource n'&eacute;tait pas relative &agrave; la racine des documents. Cette erreur
de configuration aurait conduit le serveur &agrave; rechercher un r&eacute;pertoire
"opt" &agrave; la racine des documents.</p>

<pre class="prettyprint lang-config">DocumentRoot "/var/www/example.com"
AliasMatch "^/myapp" "/opt/myapp-1.2.3"
&lt;Directory "/opt/myapp-1.2.3"&gt;
 RewriteEngine On
    RewriteBase "/myapp/"
    RewriteRule "^index\.html$"  "welcome.html"
&lt;/Directory&gt;</pre>



</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif"></a></div>
<div class="directive-section"><h2 id="rewritecond">Directive <span id="RewriteCond">RewriteCond</span> <a title="Lien permanent" href="#rewritecond" class="permalink">&para;</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>D&eacute;finit une condition qui devra &ecirc;tre satisfaite pour que
la r&eacute;&eacute;criture soit effectu&eacute;e
</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code> RewriteCond
      <em>cha&icirc;ne_de_test</em> <em>expression_de_comparaison</em> [<em>drapeaux</em>]</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration globale, serveur virtuel, r&eacute;pertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">Surcharges autoris&eacute;es:</a></th><td>FileInfo</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Extension</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_rewrite</td></tr>
</table>
      <p>La directive <code class="directive">RewriteCond</code> permet de d&eacute;finir une
      condition d'ex&eacute;cution d'une r&egrave;gle. Une ou plusieurs conditions
      <code class="directive">RewriteCond</code> peuvent pr&eacute;c&eacute;der une
      directive <code class="directive"><a href="#rewriterule">RewriteRule</a></code>. La r&egrave;gle de r&eacute;&eacute;criture correspondante n'est
      ainsi ex&eacute;cut&eacute;e que si ces conditions sont satisfaites,
      <strong>et</strong> si l'URI correspond au mod&egrave;le sp&eacute;cifi&eacute; dans la
      r&egrave;gle.</p>

      <p><em>TestString</em> est une cha&icirc;ne qui peut contenir les
      extensions suivantes en plus du texte simple :</p>

      <ul>
        <li>
          <strong>r&eacute;f&eacute;rences arri&egrave;res de r&egrave;gle de r&eacute;&eacute;criture</strong> :
	  ce sont des r&eacute;f&eacute;rences arri&egrave;res de la forme
	  <strong><code>$N</code></strong> (0 &lt;= N &lt;= 9). $1 &agrave; $9
	  permettent d'acc&eacute;der aux parties regroup&eacute;es (entre
	  parenth&egrave;ses) du mod&egrave;le, issues de la <code>RewriteRule</code>
	  concern&eacute;e par le jeu de conditions <code>RewriteCond</code>
	  courant. $0 donne acc&egrave;s &agrave; l'ensemble de la cha&icirc;ne
	  correspondant au mod&egrave;le.</li>
        <li>
          <strong>R&eacute;f&eacute;rences arri&egrave;res de condition de r&eacute;&eacute;criture
	  </strong> : ce sont des r&eacute;f&eacute;rences arri&egrave;res de la forme
	  <strong><code>%N</code></strong> (0 &lt;= N &lt;= 9). %1 &agrave; %9
	  permettent d'acc&eacute;der aux parties regroup&eacute;es (entre
	  parenth&egrave;ses) du mod&egrave;le, issues de la derni&egrave;re
	  condition <code>RewriteCond</code> satisfaite du jeu de conditions <code>RewriteCond</code>
	  courant. %0 donne acc&egrave;s &agrave; l'ensemble de la cha&icirc;ne
	  correspondant au mod&egrave;le.</li>
        <li>
          <strong>extensions de table de r&eacute;&eacute;criture</strong> :
	  ce sont des extensions de la forme <strong><code>${nomTable:cl&eacute;|d&eacute;faut}</code></strong>. Voir la <a>href="#mapfunc"&gt;documentation sur RewriteMap</a>
	   pour plus de d&eacute;tails.
        </li>
        <li>
          <strong>Variables du serveur</strong> :
	  ce sont des variables de la forme
	  <strong><code>%{</code> <em>NAME_OF_VARIABLE</em> <code>}</code></strong>,
            o&ugrave; <em>NOM_DE_VARIABLE</em> peut contenir une cha&icirc;ne issue
	    de la liste suivante :

          <table>
          
            <tr>
              <th>En-t&ecirc;tes HTTP :</th> <th>connexion &amp; requ&ecirc;te:</th> <th></th>
	    </tr>

            <tr>
	      <td>
		 HTTP_ACCEPT<br>
                 HTTP_COOKIE<br>
                 HTTP_FORWARDED<br>
                 HTTP_HOST<br>
                 HTTP_PROXY_CONNECTION<br>
                 HTTP_REFERER<br>
                 HTTP_USER_AGENT<br>
              </td>

              <td>
                 AUTH_TYPE<br>
		 CONN_REMOTE_ADDR<br>
		 CONTEXT_PREFIX<br>
                 CONTEXT_DOCUMENT_ROOT<br>
                 IPV6<br>
                 PATH_INFO<br>
                 QUERY_STRING<br>
                 REMOTE_ADDR<br>
                 REMOTE_HOST<br>
		 REMOTE_IDENT<br>
                 REMOTE_PORT<br>
                 REMOTE_USER<br>
                 REQUEST_METHOD<br>
                 SCRIPT_FILENAME<br>
              </td>

	      <td></td>
            </tr>

            <tr>
              <th>variables internes au serveur :</th> <th>date et heure :</th> <th>sp&eacute;ciaux :</th>
	    </tr>

            <tr>
	      <td>
	         DOCUMENT_ROOT<br>
		 SCRIPT_GROUP<br>
                 SCRIPT_USER<br>
                 SERVER_ADDR<br>
                 SERVER_ADMIN<br>
                 SERVER_NAME<br>
                 SERVER_PORT<br>
                 SERVER_PROTOCOL<br>
                 SERVER_SOFTWARE<br>
              </td>

              <td>
                 TIME_YEAR<br>
                 TIME_MON<br>
                 TIME_DAY<br>
                 TIME_HOUR<br>
                 TIME_MIN<br>
                 TIME_SEC<br>
                 TIME_WDAY<br>
                 TIME<br>
              </td>

              <td>
                 API_VERSION<br>
		 CONN_REMOTE_ADDR<br>
                 HTTPS<br>
		 IS_SUBREQ<br>
		 REMOTE_ADDR<br>
                 REQUEST_FILENAME<br>
                 REQUEST_SCHEME<br>
                 REQUEST_URI<br>
                 THE_REQUEST<br>
              </td>
            </tr>
          </table>

		<p>Ces variables correspondent toutes aux en-t&ecirc;tes MIME HTTP de
		m&ecirc;mes noms, au variables C du serveur HTTP Apache, ou aux champs
		<code>struct tm</code> du syst&egrave;me Unix. La plupart d'entre elles
		sont document&eacute;es dans la <a href="../expr.html#vars">documentation des expressions</a>, dans
		la <a href="../env.html">documentation des variables
		d'environnement</a> ou dans la <a href="http://www.ietf.org/rfc/rfc3875">sp&eacute;cification de
		CGI</a>.</p>

		<p>SERVER_NAME et SERVER_PORT d&eacute;pendent respectivement
		des valeurs des directives <code class="directive"><a href="../mod/core.html#usecanonicalname">UseCanonicalName</a></code> et <code class="directive"><a href="../mod/core.html#usecanonicalphysicalport">UseCanonicalPhysicalPort</a></code>.</p>

		<p>Parmi les variables
		sp&eacute;cifiques &agrave; <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code>, ou trouve les suivantes :</p>
        
                <dl>
                  <dt><code>API_VERSION</code></dt>

                  <dd>C'est la version de l'API des modules Apache httpd
		  (l'interface interne entre le serveur et les modules)
		  pour la construction courante de httpd, telle qu'elle
		  est d&eacute;finie dans include/ap_mmn.h. La version de l'API
		  des modules correspond &agrave; la version du serveur Apache
		  httpd
		  utilis&eacute; (par exemple, pour la version 1.3.14 d'Apache
		  httpd,
		  il s'agit de la version 19990320:10), mais int&eacute;resse
		  principalement les auteurs de modules.</dd>

                  <dt><code>CONN_REMOTE_ADDR</code></dt>

		  <dd>A partir de la version 2.4.8 : l'adresse IP distante de
		  la connexion (voir le module
		  <code class="module"><a href="../mod/mod_remoteip.html">mod_remoteip</a></code>).</dd>

		  <dt><code>HTTPS</code></dt>

                  <dd>Contient le texte "on" si la connexion
		  utilise SSL/TLS, "off" dans le cas contraire
		  (Cette variable peut &ecirc;tre utilis&eacute;e sans probl&egrave;me, que
		  <code class="module"><a href="../mod/mod_ssl.html">mod_ssl</a></code> soit charg&eacute; ou non).</dd>

		  <dt><code>IS_SUBREQ</code></dt>

                  <dd>Contient le texte "true" si la requ&ecirc;te en cours
		  de traitement est une sous-requ&ecirc;te, "false" dans le
		  cas contraire. Une sous-requ&ecirc;te est g&eacute;n&eacute;r&eacute;e quand un
		  module a besoin de se r&eacute;f&eacute;rer &agrave; des fichiers ou URIs
		  addidionnels pour pouvoir mener &agrave; bien sa t&acirc;che.</dd>

		  <dt><code>REMOTE_ADDR</code></dt>
                  <dd>L'adresse IP de l'h&ocirc;te distant (se r&eacute;f&eacute;rer au
		  module <code class="module"><a href="../mod/mod_remoteip.html">mod_remoteip</a></code>).</dd>

                  <dt><code>REQUEST_FILENAME</code></dt>

                  <dd>Le chemin complet local au syst&egrave;me de fichiers
		  du fichier ou du script correspondant
		  &agrave; la requ&ecirc;te, s'il a d&eacute;j&agrave; &eacute;t&eacute; d&eacute;termin&eacute; par le serveur
		  au moment o&ugrave; on y fait r&eacute;f&eacute;rence. Dans le cas
		  contraire, et en particulier dans le cas d'un serveur
		  virtuel, <code>REQUEST_FILENAME</code> contient la
		  valeur de <code>REQUEST_URI</code>. En fonction de la
		  valeur de la directive <code class="directive"><a href="../mod/core.html#acceptpathinfo">AcceptPathInfo</a></code>, le serveur
		  peut n'utiliser que certains &eacute;l&eacute;ments de t&ecirc;te du
		  <code>REQUEST_URI</code> pour d&eacute;terminer &agrave; quel
		  fichier correspond la requ&ecirc;te.</dd>

		  <dt><code>REQUEST_SCHEME</code></dt>

                  <dd>Contient le protocole de la requ&ecirc;te (en g&eacute;n&eacute;ral
		  "http" ou "https"). La valeur peut &ecirc;tre modifi&eacute;e par
		  la directive <code class="directive"><a href="../mod/core.html#servername">ServerName</a></code>.</dd>

		  <dt><code>REQUEST_URI</code></dt>

		  <dd>La partie chemin de l'URI de la requ&ecirc;te, comme
		  "/index.html". Ceci exclut en particulier la cha&icirc;ne de
		  param&egrave;tres de la requ&ecirc;te qui est contenue dans la
		  variable <code>QUERY_STRING</code>. La valeur renvoy&eacute;e pour
		  <code>REQUEST_URI</code> a d&eacute;j&agrave; &eacute;t&eacute; %-d&eacute;cod&eacute;e ; pour la
		  recoder, passez-la &agrave; la <a href="#mapfunc">fonction de
		  mappage</a> "escape".
		  </dd>

                  <dt><code>THE_REQUEST</code></dt>

                  <dd>La ligne de requ&ecirc;te HTTP compl&egrave;te envoy&eacute;e par le
		  navigateur au serveur (par exemple, "<code>GET
                  /index.html HTTP/1.1</code>"), &agrave; l'exclusion de tout
		  en-t&ecirc;te ajout&eacute; par le navigateur. Cette
		  valeur n'a pas &eacute;t&eacute; d&eacute;s&eacute;chapp&eacute;e (d&eacute;cod&eacute;e), &agrave; la
		  diff&eacute;rence de la plupart des variables suivantes.</dd>
                </dl>

        </li>
      </ul>

      <p>Si la <em>cha&icirc;ne_de_test</em> contient la valeur sp&eacute;ciale
      <code>expr</code>, <em>expression_de_comparaison</em> sera trait&eacute;
      en tant qu'expression rationnelle de type <a href="../expr.html">ap_expr</a>. Si des en-t&ecirc;tes HTTP sont
      r&eacute;f&eacute;renc&eacute;s dans l'expression rationnelle, et si le drapeau
      <code>novary</code> n'est pas activ&eacute;, ils seront ajout&eacute;s &agrave;
      l'en-t&ecirc;te Vary.</p>

      <p>Autres points &agrave; conna&icirc;tre ::</p>
      <ol>
        <li>
        <p>Les variables <code>SCRIPT_FILENAME</code> et
	<code>REQUEST_FILENAME</code> contiennent toutes deux la valeur
	du champ <code>filename</code> de la
	structure interne <code>request_rec</code>du serveur HTTP Apache.
	Le premier nom correspond au nom de variable bien connu CGI,
	alors que le second est l'&eacute;quivalent de REQUEST_URI (qui
	contient la valeur du champ <code>uri</code> de
	<code>request_rec</code>).</p>
        <p>Si une substitution intervient et si la r&eacute;&eacute;criture se
	poursuit, la valeur des deux variables sera mise &agrave; jour en
	cons&eacute;quence.</p>
        <p>Dans le contexte du serveur principal (c'est &agrave; dire avant que
	la requ&ecirc;te ne soit mise en correspondance avec le syst&egrave;me de
	fichiers), SCRIPT_FILENAME et REQUEST_FILENAME  ne peuvent pas
	contenir le chemin entier dans le syst&egrave;me de fichiers local car
	ce chemin b'est pas connu &agrave; ce stade du traitement. Dans ce cas,
	les deux variables contiendront la valeur de REQUEST_URI. Pour
	obtenir le chemin complet de la requ&ecirc;te dans le syst&egrave;me de
	fichiers local dans le contexte du serveur principal, utilisez une
	r&eacute;f&eacute;rence avant &agrave; base d'URL
	<code>%{LA-U:REQUEST_FILENAME}</code> pour d&eacute;terminer la valeur
	finale de REQUEST_FILENAME.</p></li>


        <li>
	<code>%{ENV:<em>variable</em>}</code>, o&ugrave; <em>variable</em> peut
	correspondre &agrave; une variable d'environnement quelconque.</li>
	<li>
        <code>%{ENV:variable}</code> est aussi disponible, o&ugrave;
	<em>variable</em> peut correspondre &agrave; toute variable
	d'environnement. Peut &ecirc;tre consult&eacute; via des structures internes
	d'Apache httpd et (si on ne les trouve pas ici) via la fonction
	<code>getenv()</code> &agrave; partir du processus du serveur Apache
	httpd.</li>

        <li>Que <code class="module"><a href="../mod/mod_ssl.html">mod_ssl</a></code> soit charg&eacute; ou non, on peut
	utiliser <code>%{SSL:variable}</code>, o&ugrave; <em>variable</em>
	peut &ecirc;tre remplac&eacute; par le nom d'une
	<a href="mod_ssl.html#envvars">variable
	d'environnement SSL</a> . Si <code class="module"><a href="../mod/mod_ssl.html">mod_ssl</a></code> n'est pas
	charg&eacute;, cette variable contiendra toujours une cha&icirc;ne vide.
	Exemple : <code>%{SSL:SSL_CIPHER_USEKEYSIZE}</code> pourra
	contenir la valeur <code>128</code>. Ces variables sont
	disponibles m&ecirc;me si l'option <code>StdEnvVars</code> de la
	directive <code class="directive"><a href="../mod/mod_ssl.html#ssloptions">SSLOptions</a></code> n'a
	pas &eacute;t&eacute; d&eacute;finie.</li>

	<li>
        On peut utiliser <code>%{HTTP:en-t&ecirc;te}</code>, o&ugrave;
	<em>en-t&ecirc;te</em> peut correspondre &agrave; tout nom d'en-t&ecirc;te MIME
	HTTP, pour extraire la valeur d'un en-t&ecirc;te envoy&eacute; dans la
	requ&ecirc;te HTTP. Par exemple, <code>%{HTTP:Proxy-Connection}</code>
	contiendra la valeur de l'en-t&ecirc;te HTTP
	"<code>Proxy-Connection:</code>".
	Si on utilise un en-t&ecirc;te HTTP
	dans une condition, et si cette condition est &eacute;valu&eacute;e &agrave;
	<code>vrai</code> pour la requ&ecirc;te, cet en-t&ecirc;te sera ajout&eacute; &agrave; l'en-t&ecirc;te Vary de
	la r&eacute;ponse. Il ne le sera pas si la condition est &eacute;valu&eacute;e &agrave;
	<code>faux</code>. L'ajout de l'en-t&ecirc;te HTTP &agrave; l'en-t&ecirc;te Vary
	est n&eacute;cessaire &agrave; une mise en cache appropri&eacute;e.
	<p>Il faut garder &agrave; l'esprit que les conditions suivent une
	logique de cout-circuit si le drapeau
	'<strong><code>ornext|OR</code></strong>' est utilis&eacute;, et que de
	ce fait, certaines d'entre elles ne seront pas &eacute;valu&eacute;es.</p>
	</li>

        <li>A des fins de r&eacute;f&eacute;rence avant, on peut utiliser,
	<a id="LA-U" name="LA-U"><code>%{LA-U:variable}</code></a>, qui
	permet d'effectuer une sous-requ&ecirc;te interne &agrave; base d'URL, afin
	de d&eacute;terminer la valeur finale de <em>variable</em>. Ceci permet
	d'acc&eacute;der &agrave; la valeur d'une variable pour la r&eacute;&eacute;criture inconnue
	&agrave; ce stade du traitement, mais qui sera d&eacute;finie au
	cours d'une phase ult&eacute;rieure.
	<p>Par exemple, pour effectuer une r&eacute;&eacute;criture d&eacute;pendant de la
	variable <code>REMOTE_USER</code> dans le contexte du serveur
	principal (fichier <code>httpd.conf</code>), vous devez utiliser
	<code>%{LA-U:REMOTE_USER}</code> - cette variable est d&eacute;finie
	par la phase d'autorisation qui intervient <em>apr&egrave;s</em> la
	phase de traduction d'URL (pendant laquelle <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code>
	op&egrave;re).</p>
        <p>Par contre, comme <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> impl&eacute;mente son contexte de
	r&eacute;pertoire (fichier <code>.htaccess</code>) via la phase Fixup
	de l'API, et comme la phase d'autorisation intervient
	<em>avant</em> cette derni&egrave;re, vous pouvez vous contenter
	d'utiliser <code>%{REMOTE_USER}</code> dans ce contexte.</p></li>

        <li>
        <code>%{LA-F:variable}</code> peut &ecirc;tre utilis&eacute;e pour effectuer
	une sous-requ&ecirc;te interne (bas&eacute;e sur le nom de fichier), afin de
	d&eacute;terminer la valeur finale de <em>variable</em>. La plupart du
	temps, elle est identique &agrave; LA-U (voir ci-dessus).</li>
      </ol>


      <p><em>expression_de_comparaison</em> est une expression
      rationnelle qui est appliqu&eacute;e &agrave; l'instance actuelle de
      <em>cha&icirc;ne_de_test</em>. <em>cha&icirc;ne_de_test</em> est d'abord
      &eacute;valu&eacute;e, puis compar&eacute;e &agrave;
      l'<em>expression_de_comparaison</em>.</p>

      <p><em>expression_de_comparaison</em> est en g&eacute;n&eacute;ral une
      <em>expression rationnelle compatible perl</em>, mais vous
      disposez des syntaxes suppl&eacute;mentaires suivantes pour effectuer
      d'autres tests utiles sur <em>cha&icirc;ne_de_test</em> :
      </p>

      <ol>
        <li>Vous pouvez pr&eacute;fixer l'expression avec un caract&egrave;re
	'<code>!</code>' (point d'exclamation) pour inverser le r&eacute;sultat
	de la condition, quelle que soit l'<em>expression de
	comparaison</em> utilis&eacute;e.</li>

        <li>Vous pouvez effectuer des comparaisons lexicographiques de
	cha&icirc;nes	:

         <dl>
            <dt><strong>&lt;expression</strong></dt>
	    <dd>inf&eacute;rieur au sens lexicographique<br>
	    Traite l'<em>expression</em> comme une cha&icirc;ne de
	    caract&egrave;res et la compare lexicographiquement &agrave;
	    <em>cha&icirc;ne_de_test</em>. La condition est satisfaite si
	    <em>cha&icirc;ne_de_test</em> est inf&eacute;rieure au sens
	    lexicographique &agrave; l'<em>expression</em>.</dd>

            <dt><strong>&gt;expression</strong></dt>
	    <dd>sup&eacute;rieur au sens lexicographique<br>
	    Traite l'<em>expression</em> comme une cha&icirc;ne de
	    caract&egrave;res et la compare lexicographiquement &agrave;
	    <em>cha&icirc;ne_de_test</em>. La condition est satisfaite si
	    <em>cha&icirc;ne_de_test</em> est sup&eacute;rieure au sens
	    lexicographique &agrave; l'<em>expression</em>.</dd>

            <dt><strong>=expression</strong></dt>
	    <dd>&eacute;gal au sens lexicographique<br>
	    Traite l'<em>expression</em> comme une cha&icirc;ne de
	    caract&egrave;res et la compare lexicographiquement &agrave;
	    <em>cha&icirc;ne_de_test</em>. La condition est satisfaite si
	    <em>cha&icirc;ne_de_test</em> est &eacute;gale au sens
	    lexicographique &agrave; l'<em>expression</em> (les deux cha&icirc;nes
	    sont exactement identiques, caract&egrave;re pour caract&egrave;re). Si
	    <em>expression</em> est <code>""</code> (deux guillemets),
	    <em>cha&icirc;ne_de_test</em> est compar&eacute;e &agrave; la
	    cha&icirc;ne vide.</dd>

	    <dt><strong>&lt;=expression de comparaison</strong></dt>
	    <dd>inf&eacute;rieur ou &eacute;gal &agrave; au sens lexicographique<br>
            Consid&egrave;re l'<em>expression_de_comparaison</em> comme une
	    cha&icirc;ne de caract&egrave;res et la compare au sens lexicographique &agrave;
	    la <em>cha&icirc;ne_de_test</em>. Vrai si <em>cha&icirc;ne_de_test</em>
	    pr&eacute;c&egrave;de lexicographiquement <em>expression_de_comparaison</em>, ou est
	    &eacute;gale &agrave; <em>expression_de_comparaison</em> (les deux cha&icirc;nes
	    sont identiques, caract&egrave;re pour caract&egrave;re).</dd>

            <dt><strong>&gt;=expression de comparaison</strong></dt>
	    <dd>sup&eacute;rieur ou &eacute;gal &agrave; au sens lexicographique<br>
            Consid&egrave;re l'<em>expression_de_comparaison</em> comme une
	    cha&icirc;ne de caract&egrave;res et la compare au sens lexicographique &agrave;
	    la <em>cha&icirc;ne_de_test</em>. Vrai si <em>cha&icirc;ne_de_test</em>
	    suit lexicographiquement <em>expression_de_comparaison</em>, ou est
	    &eacute;gale &agrave; <em>expression_de_comparaison</em> (les deux cha&icirc;nes
	    sont identiques, caract&egrave;re pour caract&egrave;re).</dd>
        </dl>
	<div class="note"><h3>Note</h3>
        L'op&eacute;rateur de comparaison de cha&icirc;nes fait partie des arguments de la
	<em>CondPattern</em> et doit par cons&eacute;quent se trouver entre les
	guillemets s'ils sont pr&eacute;sents. Exemple :
	        
        <pre class="prettyprint lang-config">RewriteCond %{HTTP_USER_AGENT} "=This Robot/1.0"</pre>

        </div>

	</li>

        <li>
          Vous pouvez effectuer des comparaisons d'entiers :
          <dl>

            <dt><strong>-eq</strong></dt>
	    <dd>est num&eacute;riquement &eacute;gal &agrave;<br>
            La <em>cha&icirc;ne_de_test</em> est consid&eacute;r&eacute;e comme un entier,
	    et est compar&eacute;e num&eacute;riquement &agrave; l'<em>expression de
	    comparaison</em>. Vrai si les deux expressions sont
	    num&eacute;riquement &eacute;gales.</dd>

            <dt><strong>-ge</strong></dt>
	    <dd>est num&eacute;riquement sup&eacute;rieur ou &eacute;gal &agrave;<br>
            La <em>cha&icirc;ne_de_test</em> est consid&eacute;r&eacute;e comme un entier,
	    et est compar&eacute;e num&eacute;riquement &agrave; l'<em>expression de
	    comparaison</em>. Vrai si <em>cha&icirc;ne_de_test</em> est
	    num&eacute;riquement sup&eacute;rieure ou &eacute;gale &agrave;
	    <em>expression_de_comparaison</em>.</dd>

             <dt><strong>-gt</strong></dt>
	     <dd>est num&eacute;riquement sup&eacute;rieur &agrave;<br>
            La <em>cha&icirc;ne_de_test</em> est consid&eacute;r&eacute;e comme un entier,
	    et est compar&eacute;e num&eacute;riquement &agrave; l'<em>expression de
	    comparaison</em>. Vrai si <em>cha&icirc;ne_de_test</em> est
	    num&eacute;riquement
	    sup&eacute;rieure &agrave; <em>expression_de_comparaison</em>.</dd>

            <dt><strong>-le</strong></dt>
	    <dd>est num&eacute;riquement inf&eacute;rieur ou &eacute;gal &agrave;<br>
            La <em>cha&icirc;ne_de_test</em> est consid&eacute;r&eacute;e comme un entier,
	    et est compar&eacute;e num&eacute;riquement &agrave; l'<em>expression de
	    comparaison</em>. Vrai si <em>cha&icirc;ne_de_test</em> est
	    num&eacute;riquement
	    inf&eacute;rieure ou &eacute;gale &agrave; <em>expression_de_comparaison</em>.
	    Attention &agrave; la confusion avec le drapeau <strong>-l</strong>
	    en utilisant la variante the <strong>-L</strong> ou
	    <strong>-h</strong>.</dd>

             <dt><strong>-lt</strong></dt>
	     <dd>est num&eacute;riquement inf&eacute;rieur &agrave;<br>
            La <em>cha&icirc;ne_de_test</em> est consid&eacute;r&eacute;e comme un entier,
	    et est compar&eacute;e num&eacute;riquement &agrave; l'<em>expression de
	    comparaison</em>. Vrai si <em>cha&icirc;ne_de_test</em> est
	    num&eacute;riquement
	    inf&eacute;rieure &agrave; <em>expression_de_comparaison</em>.
	    Attention &agrave; la confusion avec le drapeau <strong>-l</strong>
	    en utilisant la variante the <strong>-L</strong> ou
	    <strong>-h</strong>.</dd>

            <dt><strong>-ne</strong></dt>
            <dd>Est num&eacute;riquement <strong>n</strong>on <strong>&eacute;</strong>gal &agrave;<br>
	     La <em>Cha&icirc;ne de test</em> est consid&eacute;r&eacute;e comme un entier et est
	     num&eacute;riquement compar&eacute;e &agrave; l'<em>expression de comparaison</em>. Vrai
	     si les deux &eacute;l&eacute;ments compar&eacute;s sont num&eacute;riquement diff&eacute;rents.
	     Equivalent &agrave; <code>!-eq</code>.</dd>	    

           </dl>
        </li>

        <li>Vous pouvez effectuer diff&eacute;rents tests sur les attributs de
	fichier :
          <dl>

            <dt><strong>-d</strong></dt>
	    <dd>est un <strong>r</strong>&eacute;pertoire<br>
	    Traite <em>cha&icirc;ne_de_test</em> comme un chemin et v&eacute;rifie
	    s'il existe ou pas, et s'il s'agit d'un r&eacute;pertoire.</dd>

            <dt><strong>-f</strong></dt>
	    <dd>est un <strong>f</strong>ichier r&eacute;gulier<br>
	    Traite <em>cha&icirc;ne_de_test</em> comme un chemin et v&eacute;rifie
	    s'il existe ou pas, et s'il s'agit d'un fichier r&eacute;gulier.</dd>

            <dt><strong>-F</strong></dt>
	    <dd>test de l'existence d'un fichier via une sous-requ&ecirc;te<br>
	    V&eacute;rifie si <em>cha&icirc;ne_de_test</em> est un fichier valide,
	    accessible &agrave; travers tous les contr&ocirc;les d'acc&egrave;s du serveur
	    actuellement configur&eacute;s pour ce chemin. C'est une
	    sous-requ&ecirc;te interne qui effectue cette v&eacute;rification - &agrave;
	    utiliser avec pr&eacute;cautions car les performances du serveur
	    peuvent s'en trouver affect&eacute;es !</dd>

	    <dt><strong>-h</strong></dt>
	    <dd>est un lien symbolique, selon la convention bash<br>
            Voir <strong>-l</strong>.</dd>

            <dt><strong>-l</strong></dt>
	    <dd>est un <strong>l</strong>ien symbolique<br>
            Consid&egrave;re la <em>cha&icirc;ne_de_test</em> comme un chemin et
	    v&eacute;rifie son existence et si elle est un lien symbolique. On
	    peut aussi utiliser la convention bash <strong>-L</strong>
	    ou <strong>-h</strong> lorsqu'il y a risque de confusion
	    avec les tests <strong>-lt</strong> ou <strong>-le</strong>.</dd>

            <dt><strong>-L</strong></dt>
	    <dd>est un lien symbolique, selon la convention bash<br>
            Voir <strong>-l</strong>.</dd>

            <dt><strong>-s</strong></dt>
	    <dd>est un fichier r&eacute;gulier d'une certaine taille<br>
            Consid&egrave;re la <em>cha&icirc;ne_de_test</em> comme un chemin et
	    v&eacute;rifie son existence et si elle est un fichier r&eacute;gulier
	    d'une taille sup&eacute;rieure &agrave; z&eacute;ro.</dd>

            <dt><strong>-U</strong></dt>
	    <dd><p>test de l'existence d'une
	    URL via une sous-requ&ecirc;te<br>
	    V&eacute;rifie si <em>cha&icirc;ne_de_test</em> est une URL valide,
	    accessible &agrave; travers tous les contr&ocirc;les d'acc&egrave;s du serveur
	    actuellement configur&eacute;s pour ce chemin. C'est une
	    sous-requ&ecirc;te interne qui effectue cette v&eacute;rification - &agrave;
	    utiliser avec pr&eacute;cautions car les performances du serveur
	    peuvent s'en trouver affect&eacute;es !</p>
	    <p>Ce drapeau ne renvoie <em>que</em> des informations
	    concernant le contr&ocirc;le d'acc&egrave;s, l'authentification et
	    l'autorisation. Il ne renvoie <em>pas</em> d'informations
	    concernant le code d'&eacute;tat que le gestionnaire configur&eacute;
	    (static file, CGI, proxy, etc...) aurait, quant &agrave; lui,
	    retourn&eacute;.</p></dd>

	  <dt><strong>-x</strong></dt>
	  <dd>a l'attribut d'ex&eacute;cution positionn&eacute;<br>
            Consid&egrave;re la <em>cha&icirc;ne_de_test</em> comme un chemin et
	    v&eacute;rifie son existence et si elle a son attribut d'ex&eacute;cution
	    positionn&eacute;. Ce positionnement est d&eacute;termin&eacute; en fonction de
	    l'OS sous-jacent.</dd>

	    </dl>

	    Par exemple:

        <pre class="prettyprint lang-config">RewriteCond /var/www/%{REQUEST_URI} !-f
RewriteRule ^(.+) /other/archive/$1 [R]</pre>


        </li>

	<li>
           <p>Si la <em>cha&icirc;ne_de_test</em> contient la valeur sp&eacute;ciale
	   <code>expr</code>, la <em>cha&icirc;ne de comparaison</em> sera
	   trait&eacute;e en tant qu'expression rationnelle de type <a href="../expr.html">ap_expr</a>.</p>

	   <p>
            Dans l'exemple ci-dessous, on utilise <code>-strmatch</code>
	    pour comparer le <code>REFERER</code> avec le nom d'h&ocirc;te du
	    site afin de bloquer le hotlinking (r&eacute;f&eacute;rencement direct)
	    non d&eacute;sir&eacute;.
           </p>

           <pre class="prettyprint lang-config">           RewriteCond expr "! %{HTTP_REFERER} -strmatch '*://%{HTTP_HOST}/*'"
           RewriteRule "^/images" "-" [F]</pre>

        </li>
    </ol>

	<p>Vous pouvez aussi d&eacute;finir certains drapeaux pour
	l'<em>expression_de_comparaison</em> en ajoutant ces
	<strong><code>[</code><em>drapeaux</em><code>]</code></strong>
	comme troisi&egrave;me argument de la directive
	<code class="directive">RewriteCond</code>, o&ugrave; <em>drapeaux</em> est un
	sous-ensemble s&eacute;par&eacute; par des virgules des drapeaux suivants :</p>

      <ul>
        <li>'<strong><code>nocase|NC</code></strong>'
	(<strong>n</strong>o <strong>c</strong>ase)<br>
	Rend le test insensible &agrave; la casse - il n'est pas fait de
	distinction entre majuscules et minuscules, &agrave; la fois dans le
	d&eacute;veloppement de <em>cha&icirc;ne_de_test</em> et dans
	<em>expression_de_comparaison</em>. Ce drapeau n'est pris en
	compte que lors d'une comparaison entre <em>cha&icirc;ne_de_test</em>
	et <em>expression_de_comparaison</em>. Il ne l'est pas pour les
	v&eacute;rification par sous-requ&ecirc;tes ou sur le syst&egrave;me de
	fichiers.</li>

        <li>
          '<strong><code>ornext|OR</code></strong>'
	  (<strong>ou</strong> condition suivante)<br>
	  Permet de cha&icirc;ner les conditions de r&egrave;gles avec un OU au
	  lieu du AND implicite. Exemple typique :

<pre class="prettyprint lang-config">RewriteCond "%{REMOTE_HOST}"  "^host1"  [OR]
RewriteCond "%{REMOTE_HOST}"  "^host2"  [OR]
RewriteCond "%{REMOTE_HOST}"  "^host3"
RewriteRule ...r&egrave;gles concernant tous ces h&ocirc;tes...</pre>


          Sans ce drapeau, les paires
	  condition/r&egrave;gle devraient &ecirc;tre &eacute;crites trois fois.
        </li>

        <li>'<strong><code>novary|NV</code></strong>'
	(<strong>n</strong>o <strong>v</strong>ary)<br>
	Si la condition contient un en-t&ecirc;te HTTP, ce drapeau emp&ecirc;che
	ce dernier d'&ecirc;tre ajout&eacute; &agrave; l'en-t&ecirc;te Vary de la r&eacute;ponse. <br>
	L'utilisation de ce drapeau peut provoquer une mise en cache
	incorrecte de la r&eacute;ponse, si la repr&eacute;sentation de cette r&eacute;ponse
	varie avec la valeur de l'en-t&ecirc;te consid&eacute;r&eacute;. Ce drapeau ne
	devrait donc &ecirc;tre utilis&eacute; que si l'on ma&icirc;trise parfaitement le
	fonctionnement de l'en-t&ecirc;te Vary.
        </li>
      </ul>
      

      <p><strong>Exemple :</strong></p>

       <p>Pour r&eacute;&eacute;crire la page d'accueil d'un site en fonction de
       l'en-t&ecirc;te ``<code>User-Agent:</code>'' de la requ&ecirc;te, vous
       pouvez utiliser ce qui suit : </p>

<pre class="prettyprint lang-config">RewriteCond  "%{HTTP_USER_AGENT}"  "(iPhone|Blackberry|Android)"
RewriteRule  "^/$"               "/homepage.mobile.html"  [L]

RewriteRule  "^/$"                 "/homepage.std.html"  [L]</pre>


        <p>Explications : si vous utilisez un navigateur
	qui s'identifie comme un
	navigateur de plateforme mobile (notez que l'exemple est
	incomplet car il existe de nombreuses autres plateformes
	mobiles), c'est la version pour mobile de la page d'accueil qui
	sera renvoy&eacute;e. Dans le cas contraire, ce sera la page d'accueil
	standard.</p>

	<p>Par d&eacute;faut, plusieurs directives <code class="directive">RewriteCond</code>
	sont &eacute;valu&eacute;es de mani&egrave;re s&eacute;quentielle et combin&eacute;es &agrave; l'aide d'un
	<strong>ET</strong> logique. Si une condition n'est pas v&eacute;rifi&eacute;e et en
	l'absence d'un op&eacute;rateur logique <strong><code>OU</code></strong>,
	l'ensemble du jeu de r&egrave;gles est abandonn&eacute; et les conditions restantes ne
	sont pas &eacute;valu&eacute;es.
        </p>


</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif"></a></div>
<div class="directive-section"><h2 id="rewriteengine">Directive <span id="RewriteEngine">RewriteEngine</span> <a title="Lien permanent" href="#rewriteengine" class="permalink">&para;</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Active ou d&eacute;sactive l'ex&eacute;cution du
moteur de r&eacute;&eacute;criture</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>RewriteEngine on|off</code></td></tr>
<tr><th><a href="directive-dict.html#Default">D&eacute;faut:</a></th><td><code>RewriteEngine off</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration globale, serveur virtuel, r&eacute;pertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">Surcharges autoris&eacute;es:</a></th><td>FileInfo</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Extension</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_rewrite</td></tr>
</table>

      <p>La directive <code class="directive">RewriteEngine</code> active ou
      d&eacute;sactive l'ex&eacute;cution du moteur de r&eacute;&eacute;criture. Si sa valeur est
      <code>off</code>, ce module n'ex&eacute;cutera aucun traitement et ne
      mettra pas &agrave; jour les variables d'environnement
      <code>SCRIPT_URx</code>.</p>

      <p>Plut&ocirc;t que de commenter toutes les directives <code class="directive"><a href="#rewriterule">RewriteRule</a></code>, il est pr&eacute;f&eacute;rable
      d'utiliser cette directive si l'on souhaite d&eacute;sactiver les
      r&egrave;gles de r&eacute;&eacute;criture dans un contexte particulier.</p>

      <p>Notez que les  h&ocirc;tes virtuels n'h&eacute;ritent pas des
      configurations de r&eacute;&eacute;criture. Ceci implique que vous devez
      ins&eacute;rer une directive <code>RewriteEngine on</code> dans chaque
      h&ocirc;te virtuel pour lequel vous souhaitez utiliser des r&egrave;gles
      de r&eacute;&eacute;criture.</p>

      <p>Les directives <code class="directive"><a href="#rewritemap">RewriteMap</a></code> du type
      <code>prg</code> ne sont pas prises en compte au cours de
      l'initialisation du serveur si elle ont &eacute;t&eacute; d&eacute;finies dans un
      contexte o&ugrave; la directive <code class="directive">RewriteEngine</code> n'a
      pas &eacute;t&eacute; d&eacute;finie &agrave; <code>on</code>.</p>


</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif"></a></div>
<div class="directive-section"><h2 id="rewritemap">Directive <span id="RewriteMap">RewriteMap</span> <a title="Lien permanent" href="#rewritemap" class="permalink">&para;</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>D&eacute;finit une fonction de mise en correspondance pour la
recherche de mots-cl&eacute;s</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>RewriteMap <em>MapName</em> <em>MapType</em>:<em>MapSource</em> [<em>MapTypeOptions</em>]
</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration globale, serveur virtuel</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Extension</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_rewrite</td></tr>
<tr><th><a href="directive-dict.html#Compatibility">Compatibilit&eacute;:</a></th><td>Le troisi&egrave;me param&egrave;tre, MapTypeOptions, est disponible &agrave; partir
de la version 2.4.29 du serveur HTTP Apache</td></tr>
</table>
      <p>La directive <code class="directive">RewriteMap</code> d&eacute;finit une
      <em>Table de correspondance pour la r&eacute;&eacute;criture</em> que les
      fonctions de mise en correspondance
      peuvent utiliser dans les cha&icirc;nes de substitution des r&egrave;gles
      pour ins&eacute;rer/substituer des champs en recherchant des mots-cl&eacute;s.
      La source utilis&eacute;e pour cette recherche peut &ecirc;tre de plusieurs
      types.</p>

      <p><a id="mapfunc" name="mapfunc"><em>MapName</em></a> est le nom de la table de correspondance
      et servira &agrave; sp&eacute;cifier une fonction de mise en correspondance
      pour les cha&icirc;nes de substitution d'une r&egrave;gle de r&eacute;&eacute;criture selon
      une des constructions suivantes :</p>

      <p class="indent">
        <strong><code>${</code> <em>MapName</em> <code>:</code>
        <em>mot-cl&eacute;</em> <code>}</code><br>
         <code>${</code> <em>MapName</em> <code>:</code>
        <em>mot-cl&eacute;</em> <code>|</code> <em>valeur par d&eacute;faut</em>
        <code>}</code></strong>
      </p>

      <p>Lorsqu'une telle construction est rencontr&eacute;e, la table de
      correspondance <em>MapName</em> est consult&eacute;e
      et la cl&eacute; <em>mot-cl&eacute;</em> recherch&eacute;e. Si la cl&eacute; est trouv&eacute;e, la
      construction est remplac&eacute;e par
      la <em>valeur de remplacement</em>. Si la cl&eacute; n'est pas trouv&eacute;e,
      elle est remplac&eacute;e par la <em>valeur par d&eacute;faut</em>, ou par une
      cha&icirc;ne vide si aucune <em>valeur par d&eacute;faut</em> n'est
      sp&eacute;cifi&eacute;e. La valeur vide se comporte comme si la
      cl&eacute; &eacute;tait absente ; il est donc impossible de distinguer une
      valeur vide d'une absence de cl&eacute;.</p>

      <p>Par exemple, vous pouvez d&eacute;finir une directive
      <code class="directive">RewriteMap</code> comme suit </p>

      <pre class="prettyprint lang-config">RewriteMap map-exemple "txt:/chemin/vers/fichier/map.txt"</pre>


      <p>Vous pourrez ensuite utiliser cette table dans une
      directive <code class="directive"><a href="#rewriterule">RewriteRule</a></code> comme suit :</p>

      <pre class="prettyprint lang-config">RewriteRule "^/ex/(.*)" "${map-exemple:$1}"</pre>


      <p>La signification de l'argument <em>MapTypeOptions</em> d&eacute;pend du <em>MapType</em>
      sp&eacute;cifi&eacute;. Veuillez vous r&eacute;f&eacute;rer au document <a href="../rewrite/rewritemap.html">Utiliser RewriteMap</a> pour
      plus de d&eacute;tails.</p>

      <p>Les combinaisons suivantes pour <em>type de correspondance</em>
      et <em>MapSource</em>
      peuvent &ecirc;tre utilis&eacute;es :</p>

<dl>
    <dt>txt</dt>
        <dd>Un fichier texte contenant des paires cl&eacute;-valeur s&eacute;par&eacute;es
	par des espaces, une paire par ligne (<a href="../rewrite/rewritemap.html#txt">D&eacute;tails ...</a>).</dd>

    <dt>rnd</dt>
        <dd>S&eacute;lection al&eacute;atoire d'une entr&eacute;e depuis un fichier texte (<a href="../rewrite/rewritemap.html#rnd">D&eacute;tails ...</a>).</dd>

    <dt>dbm</dt>
        <dd>Recherche une entr&eacute;e dans un fichier dbm contenant des
	paires nom-valeur. Le condens&eacute; hash est &eacute;labor&eacute; &agrave; partir d'un
	format de fichier texte via l'utilitaire <code><a href="../programs/httxt2dbm.html">httxt2dbm</a></code> (<a href="../rewrite/rewritemap.html#dbm">D&eacute;tails ...</a>).</dd>

    <dt>int</dt>
        <dd>Une des quatre fonctions internes disponibles que fournit
	<code>RewriteMap</code>: toupper, tolower, escape ou unescape
	(<a href="../rewrite/rewritemap.html#int">D&eacute;tails ...</a>).</dd>

    <dt>prg</dt>
        <dd>Appelle un programme externe ou un script pour effectuer la
	r&eacute;&eacute;criture (<a href="../rewrite/rewritemap.html#prg">D&eacute;tails
	...</a>).</dd>

    <dt>dbd or fastdbd</dt>
        <dd>Une commande SQL SELECT &agrave; ex&eacute;cuter pour rechercher la cible
	de r&eacute;&eacute;criture (<a href="../rewrite/rewritemap.html#dbd">D&eacute;tails
	...</a>).</dd>
    </dl>

<p>Vous trouverez plus de d&eacute;tails et de nombreux exemples dans le <a href="../rewrite/rewritemap.html">RewriteMap HowTo</a>.</p>


</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif"></a></div>
<div class="directive-section"><h2 id="rewriteoptions">Directive <span id="RewriteOptions">RewriteOptions</span> <a title="Lien permanent" href="#rewriteoptions" class="permalink">&para;</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Configure certaines options sp&eacute;ciales
pour le moteur de r&eacute;&eacute;criture</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>RewriteOptions <var>Options</var></code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration globale, serveur virtuel, r&eacute;pertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">Surcharges autoris&eacute;es:</a></th><td>FileInfo</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Extension</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_rewrite</td></tr>
</table>

      <p>La directive <code class="directive">RewriteOptions</code> d&eacute;finit
      certaines options sp&eacute;ciales pour la configuration au niveau du
      serveur ou du r&eacute;pertoire. La cha&icirc;ne de caract&egrave;res <em>Option</em>
      ne peut actuellement prendre qu'une des valeurs suivantes :</p>

      <dl>
      <dt><code>Inherit</code></dt>
      <dd>

      <p>Ceci force la configuration locale &agrave; h&eacute;riter de la
      configuration du niveau sup&eacute;rieur. Dans le contexte des h&ocirc;tes
      virtuels, cela signifie que les correspondances, conditions et
      r&egrave;gles du serveur principal sont h&eacute;rit&eacute;es. Dans le contexte des
      r&eacute;pertoires, cela signifie que les conditions et r&egrave;gles de la
      configuration <code>.htaccess</code> ou les sections <code class="directive"><a href="../mod/core.html#directory">&lt;Directory&gt;</a></code> du r&eacute;pertoire
      parent sont h&eacute;rit&eacute;es. Les r&egrave;gles h&eacute;rit&eacute;es sont virtuellement
      copi&eacute;es dans la section o&ugrave; cette directive est utilis&eacute;e. Si elles
      sont utilis&eacute;es avec des r&egrave;gles locales, les r&egrave;gles h&eacute;rit&eacute;es sont
      plac&eacute;es apr&egrave;s ces derni&egrave;res. La place de cette directive - avant
      ou apr&egrave;s les r&egrave;gles locales - n'a aucune influence sur ce
      comportement. Si des r&egrave;gles locales ont forc&eacute; l'arr&ecirc;t de la
      r&eacute;&eacute;criture, les r&egrave;gles h&eacute;rit&eacute;es ne seront pas trait&eacute;es.</p>

      <div class="warning">
      Les r&egrave;gles h&eacute;rit&eacute;es du niveau parent sont appliqu&eacute;es
      <strong>after</strong> apr&egrave;s les r&egrave;gles sp&eacute;cifi&eacute;es dans le niveau
      enfant.
      </div>
      </dd>

      <dt><code>InheritBefore</code></dt>
      <dd>
      <p>M&ecirc;me effet que l'option <code>Inherit</code> ci-dessus, mais
      les r&egrave;gles sp&eacute;cifi&eacute;es dans le niveau parent s'appliquent
      <strong>avant</strong> les r&egrave;gles sp&eacute;cifi&eacute;es dans le niveau
      enfant.<br>
      Disponible depuis la version 2.3.10 du serveur HTTP Apache.</p>
      </dd>

      <dt><code>InheritDown</code></dt>
      <dd>

      <p>Si cette option est activ&eacute;e, toutes les configurations enfants
      h&eacute;riteront de la configuration courante. Il en est de m&ecirc;me si l'on
      sp&eacute;cifie <code>RewriteOptions Inherit</code> dans toutes les
      configurations enfants. Voir l'option <code>Inherit</code> pour
      plus de d&eacute;tails &agrave; propos de la mani&egrave;re dont les relations
      parent-enfants sont trait&eacute;es.<br>
      Cette option est disponible &agrave; partir
      de la version 2.4.8 du serveur HTTP Apache.</p>
      </dd>

      <dt><code>InheritDownBefore</code></dt>
      <dd>

      <p>L'effet de cette option est &eacute;quivalent &agrave; celui de l'option
      <code>InheritDown</code> ci-dessus, mais les r&egrave;gles de la
      configuration parente s'appliquent <strong>avant</strong> toute
      r&egrave;gle de la configuration enfant.<br>
      Cette option est disponible &agrave; partir
      de la version 2.4.8 du serveur HTTP Apache.</p>
      </dd>

      <dt><code>IgnoreInherit</code></dt>
      <dd>

      <p>Si cette option est activ&eacute;e, les configurations courante et
      enfants ignoreront toute r&egrave;gle h&eacute;rit&eacute;e d'une configuration parente
      via les options <code>InheritDown</code> ou
      <code>InheritDownBefore</code>.<br>
      Cette option est disponible &agrave; partir
      de la version 2.4.8 du serveur HTTP Apache.</p>
      </dd>
      
      <dt><code>AllowNoSlash</code></dt>
      <dd>
      <p>Par d&eacute;faut, <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> ignore les URLs qui
      correspondent &agrave; un r&eacute;pertoire sur disque, mais ne comportent pas
      de slash final, afin que le module <code class="module"><a href="../mod/mod_dir.html">mod_dir</a></code>
      redirige le client vers l'URL canonique avec un slash final.</p>
      
      <p>Lorsque la directive <code class="directive"><a href="../mod/mod_dir.html#directoryslash">DirectorySlash</a></code> est d&eacute;finie &agrave; off, il
      est possible de sp&eacute;cifier l'option <code>AllowNoSlash</code> pour
      s'assurer que les r&egrave;gles de r&eacute;&eacute;criture ne soient plus ignor&eacute;es.
      Si on le souhaite, cette option permet de faire s'appliquer des
      r&egrave;gles de r&eacute;&eacute;criture qui correspondent &agrave; un r&eacute;pertoire sans slash
      final au sein de fichiers .htaccess.<br>
      Elle est disponible &agrave;
      partir de la version 2.4.0 du serveur HTTP Apache.</p>
      </dd>

      <dt><code>AllowAnyURI</code></dt>
      <dd>

      <p>A partir de la version 2.2.22 de httpd, lorsqu'une directive <code class="directive"><a href="#rewriterule">RewriteRule</a></code> se situe dans un
      contexte de <code>serveur virtuel</code> ou de serveur principal,
      <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> ne traitera les r&egrave;gles de r&eacute;&eacute;criture
      que si l'URI de la requ&ecirc;te respecte la syntaxe d'un <a href="directive-dict.html#Syntax">chemin URL</a>. Ceci permet
      d'&eacute;viter certains probl&egrave;mes de s&eacute;curit&eacute; o&ugrave; des r&egrave;gles
      particuli&egrave;res pourraient permettre  des d&eacute;veloppements de mod&egrave;les
      inattendus (voir <a href="http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2011-3368">CVE-2011-3368</a>
      et <a href="http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2011-4317">CVE-2011-4317</a>).
      Pour s'affranchir de la restriction relative &agrave; la syntaxe des chemins URL, on peut
      utiliser l'option <code>AllowAnyURI</code>, afin de permettre &agrave;
      <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> d'appliquer le jeu de r&egrave;gles &agrave; toute
      cha&icirc;ne de requ&ecirc;te URI, sans v&eacute;rifier si cette derni&egrave;re respecte la
      grammaire des chemins URL d&eacute;finie dans la sp&eacute;cification HTTP.<br>
      Disponible depuis la version 2.4.3 du serveur HTTP Apache.</p>

      <div class="warning">
      <h3>Avertissement &agrave; propos de la s&eacute;curit&eacute;</h3> 

      <p>L'utilisation de cette option rendra le serveur vuln&eacute;rable &agrave;
      certains probl&egrave;mes de s&eacute;curit&eacute; si les r&egrave;gles de r&eacute;&eacute;critures
      concern&eacute;es n'ont pas &eacute;t&eacute; r&eacute;dig&eacute;es avec soin. Il est par cons&eacute;quent
      <strong>fortement recommand&eacute;</strong> de ne pas utiliser cette
      option. En particulier, pr&ecirc;tez attention aux cha&icirc;nes en entr&eacute;e contenant le
      caract&egrave;re '<code>@</code>', qui peuvent modifier l'interpr&eacute;tation
      de l'URI r&eacute;&eacute;crite, comme indiqu&eacute; dans les liens ci-dessus.</p>
      </div>
      </dd>

      <dt><code>MergeBase</code></dt>
      <dd>

      <p>Avec cette option, la valeur de la directive <code class="directive"><a href="#rewritebase">RewriteBase</a></code> est recopi&eacute;e depuis
      une valeur explicitement d&eacute;finie dans tout sous-r&eacute;pertoire qui ne
      d&eacute;finit pas sa propre directive <code class="directive"><a href="#rewritebase">RewriteBase</a></code>. Il s'agissait du
      comportement par d&eacute;faut avec les versions 2.4.0 &agrave; 2.4.3, et ce
      drapeau qui permet de retrouver ce comportement est disponible
      depuis la version 2.4.4 du serveur HTTP Apache.</p>
      </dd>

      <dt><code>IgnoreContextInfo</code></dt>
      <dd>

      <p>Lors d'une
      substitution relative dans un contexte de r&eacute;pertoire (htaccess),
      et si la directive <code class="directive"><a href="#rewritebase">RewriteBase</a></code> n'a pas &eacute;t&eacute; d&eacute;finie,
      ce module utilise des informations en provenance d'une extension
      d'URL et du contexte du syst&egrave;me de fichiers pour transformer la
      sustitution relative en URL. Par exemple, les modules
      <code class="module"><a href="../mod/mod_userdir.html">mod_userdir</a></code> et <code class="module"><a href="../mod/mod_alias.html">mod_alias</a></code>
      utilisent ces informations de contexte &eacute;tendu. Disponible &agrave; partir de la
      version 2.4.16 du serveur HTTP Apache.</p>
      </dd>

      <dt><code>LegacyPrefixDocRoot</code></dt>
      <dd>

      <p>Avant la version 2.4.26, si une substitution &eacute;tait une URL absolue qui
      correspondait au serveur virtuel courant, l'URL pouvait &ecirc;tre tout d'abord
      r&eacute;duite &agrave; sa partie chemin, puis enfin en chemin local. Comme l'URL peut
      &ecirc;tre r&eacute;duite en chemin local, le chemin doit &ecirc;tre pr&eacute;fix&eacute; par la
      valeur de la directive DocumentRoot, ce qui permet d'interdire l'acc&egrave;s &agrave;
      un fichier tel que /tmp/myfile suite &agrave; une requ&ecirc;te pour
      http://host/file/myfile avec la <code class="directive"><a href="#rewriterule">RewriteRule</a></code> suivante :</p>
      <pre class="prettyprint lang-config">RewriteRule /file/(.*) http://localhost/tmp/$1</pre>

      <p>Cette option permet de restaurer l'ancien comportement lorsqu'un chemin
      local obtenu &agrave; partir de la r&eacute;duction d'une URL n'est pas pr&eacute;fix&eacute; par la
      valeur de la directive DocumentRoot. Disponible &agrave; partir de la version
      2.4.26 du serveur HTTP Apache.</p>
      </dd>

      </dl>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif"></a></div>
<div class="directive-section"><h2 id="rewriterule">Directive <span id="RewriteRule">RewriteRule</span> <a title="Lien permanent" href="#rewriterule" class="permalink">&para;</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>D&eacute;finit les r&egrave;gles pour le moteur de r&eacute;&eacute;criture</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>RewriteRule
      <em>Mod&egrave;le</em> <em>Substitution</em> [<em>drapeaux</em>]</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration globale, serveur virtuel, r&eacute;pertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">Surcharges autoris&eacute;es:</a></th><td>FileInfo</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Extension</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_rewrite</td></tr>
</table>
      <p>La directive <code class="directive">RewriteRule</code> est le
      v&eacute;ritable cheval de trait de la r&eacute;&eacute;criture. La directive peut
      appara&icirc;tre plusieurs fois, chaque instance d&eacute;finissant une
      r&egrave;gle de r&eacute;&eacute;criture particuli&egrave;re. L'ordre dans lequel ces r&egrave;gles
      sont d&eacute;finies est important - il s'agit de l'ordre dans lequel
      les r&egrave;gles seront appliqu&eacute;es au cours du processus de
      r&eacute;&eacute;criture.</p>

      <p><a id="patterns" name="patterns"><em>Mod&egrave;le</em></a> est une
      <a id="regexp" name="regexp">expression rationnelle</a>
      compatible perl. Ce avec quoi ce mod&egrave;le est compar&eacute; d&eacute;pend de l'endroit o&ugrave;
      la directive <code class="directive">RewriteRule</code> est d&eacute;finie.</p>

<div class="note"><h3><a id="what_is_matched" name="what_is_matched">Qu'est-ce qui est compar&eacute; ?</a></h3>

<ul>
      <li><p>Dans un contexte de serveur virtuel <code class="directive"><a href="../mod/core.html#virtualhost">VirtualHost</a></code>, le <em>mod&egrave;le</em> est tout
      d'abord compar&eacute; &agrave; la portion de l'URL situ&eacute;e entre le nom d'h&ocirc;te
      &eacute;ventuellement accompagn&eacute; du port, et la cha&icirc;ne de param&egrave;tres (par
      exemple "/app1/index.html"). Il s'agit du <a href="directive-dict.html#Syntax">URL-path</a> d&eacute;cod&eacute; de sa valeur "%xx".</p></li>

      <li><p>Dans un contexte de r&eacute;pertoire (sections <code class="directive"><a href="../mod/core.html#directory">Directory</a></code> et fichiers .htaccess), le
      <em>Mod&egrave;le</em> est compar&eacute; avec une partie de chemin ; par exemple une
      requ&ecirc;te pour "/app1/index.html" entra&icirc;nera une comparaison avec
      "app1/index.html" ou "index.html" selon l'endroit o&ugrave; la directive
      <code class="directive">RewriteRule</code> est d&eacute;finie.</p>

      <p>Le chemin o&ugrave; la r&egrave;gle est d&eacute;fini est supprim&eacute; du chemin correspondant
      du syst&egrave;me de fichiers avant comparaison (jusqu'au slash final compris).
      En cons&eacute;quence de cette suppression, les r&egrave;gles d&eacute;finies dans
      ce contexte n'effectuent des comparaisons qu'avec la portion du chemin
      du syst&egrave;me de fichiers "en dessous" de l'endroit o&ugrave; la r&egrave;gle est d&eacute;finie.</p>

      <p>Le chemin correspondant actuel du syst&egrave;me de fichiers est d&eacute;termin&eacute; par
      des directives telles que <code class="directive"><a href="../mod/core.html#documentroot">DocumentRoot</a></code> et
      <code class="directive"><a href="../mod/mod_alias.html#alias">Alias</a></code>, ou m&ecirc;me le r&eacute;sultat de
      substitutions dans des r&egrave;gles <code class="directive">RewriteRule</code> pr&eacute;c&eacute;dentes.  
      </p>
      </li>

      <li><p>Si vous souhaitez faire une comparaison sur le nom
      d'h&ocirc;te, le port, ou la cha&icirc;ne de requ&ecirc;te, utilisez une
      directive <code class="directive"><a href="#rewritecond">RewriteCond</a></code>
      comportant respectivement les variables
      <code>%{HTTP_HOST}</code>, <code>%{SERVER_PORT}</code>, ou
      <code>%{QUERY_STRING}</code>.</p></li>
</ul>
      
</div>

<div class="note"><h3>R&eacute;&eacute;critures dans un contexte de r&eacute;pertoire</h3>
<ul>
<li>L'utilisation du moteur de r&eacute;&eacute;criture dans les
fichiers <a href="../howto/htaccess.html">.htaccess</a> et les sections
<code class="directive"><a href="../mod/core.html#directory">&lt;Directory&gt;</a></code> est un peu plus
complexe.</li>

<li>Pour activer le moteur de r&eacute;&eacute;criture dans ces contextes, vous devez
d&eacute;finir "<code>RewriteEngine On</code>" <strong>et</strong>
"<code>Options FollowSymLinks</code>". Si l'administrateur a d&eacute;sactiv&eacute;
la possibilit&eacute; de modifier l'option <code>FollowSymLinks</code> au
niveau du r&eacute;pertoire d'un utilisateur, vous ne pouvez pas utiliser le
moteur de r&eacute;&eacute;criture. Cette restriction a &eacute;t&eacute; instaur&eacute;e &agrave; des fins de
s&eacute;curit&eacute;.</li>

<li>Voir la directive
<code class="directive"><a href="#rewritebase">RewriteBase</a></code> pour plus de d&eacute;tails &agrave;
propos de l'ajout du pr&eacute;fixe apr&egrave;s les substitutions relatives.</li>

<li>Si vous souhaitez effectuer une comparaison en prenant en compte
l'int&eacute;gralit&eacute; du
chemin de l'URL dans un contexte de r&eacute;pertoire (htaccess), vous devez
utiliser la variable <code>%{REQUEST_URI}</code> dans la directive
<code class="directive"><a href="#rewritecond">RewriteCond</a></code>.</li>

<li>Le prefixe supprim&eacute; se termine toujours par un slash, ce qui
signifie que la comparaison s'effectue avec une cha&icirc;ne qui ne comporte
<em>jamais</em> de slash de d&eacute;but. Ainsi, un <em>mod&egrave;le</em> contenant
<code>^/</code> ne correspondra jamais dans un contexte de r&eacute;pertoire.</li>

<li>Bien que les r&egrave;gles de r&eacute;&eacute;criture soient permises du point de vue de
la syntaxe dans les sections <code class="directive"><a href="../mod/core.html#location">&lt;Location&gt;</a></code> et <code class="directive"><a href="../mod/core.html#files">&lt;Files&gt;</a></code> (y compris leurs versions sous forme
d'expression rationnelle), elles n'y sont pas prises en compte, et
n'y sont &agrave; priori d'aucune utilit&eacute;. Les substitutions
relatives sont une fonctionnalit&eacute; qui n'est, elle non-plus pas support&eacute;e
dans ce genre de contexte.</li>

<li>Les blocs <code class="directive"><a href="../mod/core.html#if">If</a></code> suivent les r&egrave;gles
du contexte de <em>r&eacute;pertoire</em>.</li>

<li>Par d&eacute;faut, mod_rewrite &eacute;crase les r&egrave;gles pr&eacute;c&eacute;dentes au sein de <a href="../sections.html#merging">sections combin&eacute;es</a> appartenant au m&ecirc;me
contexte. Pour modifier ce comportement, on peut utiliser la directive
<code class="directive"><a href="#rewriteoptions">RewriteOptions</a></code> pour d&eacute;finir par
exemple l'option <em>Inherit</em>.</li>

<li>La directive <code class="directive"><a href="#rewriteoptions">RewriteOptions</a></code>
permet aussi de contr&ocirc;ler le comportement des sections d&eacute;finies au m&ecirc;me niveau
d'imbrication dans la configuration. Dans l'exemple suivant, par d&eacute;faut seule la
r&egrave;gle RewriteRules d&eacute;finie dans le second bloc <code class="directive"><a href="../mod/core.html#if">If</a></code> est prise en compte car celle d&eacute;finie dans le
premier bloc est &eacute;cras&eacute;e. D&eacute;finir <code class="directive"><a href="#rewriteoptions">RewriteOptions</a></code> Inherit force mod_rewrite &agrave;
combiner les deux sections en prenant en compte les deux r&egrave;gles et pas seulement
la derni&egrave;re.</li>
</ul>
<div class="example"><pre class="prettyprint lang-config">&lt;If "true"&gt;
  # Sans RewriteOptions Inherit, cette r&egrave;gle est &eacute;cras&eacute;e par celle de la section
  # suivante et aucune redirection ne sera effectu&eacute;e pour les URIs contenant
  # 'foo'
  RewriteRule foo http://example.com/foo [R]
&lt;/If&gt;
&lt;If "true"&gt;
  RewriteRule bar http://example.com/bar [R]
&lt;/If&gt;</pre>
</div>
</div>

	<p>Pour quelques conseils &agrave; propos des <a class="glossarylink" href="../glossary.html#regex" title="voir glossaire">expressions rationnelles</a>, voir le
	document <a href="../rewrite/intro.html#regex">Introduction &agrave;
	mod_rewrite</a>.</p>

      <p>Dans <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code>, on peut aussi utiliser le caract&egrave;re
      NOT ('<code>!</code>') comme pr&eacute;fixe de mod&egrave;le. Ceci vous permet
      d'inverser la signification d'un mod&egrave;le, soit pour dire
      ``<em>si l'URL consid&eacute;r&eacute;e ne correspond <strong>PAS</strong> &agrave;
      ce mod&egrave;le</em>''. Le caract&egrave;re NON peut donc &ecirc;tre utilis&eacute; &agrave;
      titre exceptionnel, lorsqu'il est plus simple d'effectuer une
      comparaison avec le mod&egrave;le invers&eacute;, ou dans la derni&egrave;re r&egrave;gle
      par d&eacute;faut.</p>

<div class="note"><h3>Note</h3>
Si vous utilisez le caract&egrave;re NON pour inverser la signification d'un
mod&egrave;le, vous ne pouvez pas inclure de parties g&eacute;n&eacute;riques group&eacute;es dans
le mod&egrave;le. Ceci est d&ucirc; au fait que, lorsque le mod&egrave;le ne correspond
pas (autrement dit, sa n&eacute;gation correspond), les groupes sont vides.
Ainsi, si vous utilisez des mod&egrave;les invers&eacute;s, vous ne pouvez
pas vous r&eacute;f&eacute;rer aux groupes par <code>$N</code> dans la cha&icirc;ne de
substitution !
</div>

      <p>Dans une r&egrave;gle de r&eacute;&eacute;criture,
      <a id="rhs" name="rhs"><em>Substitution</em></a> est la cha&icirc;ne
      de caract&egrave;res qui remplace le chemin de l'URL original qui
      correspondait au <em>Mod&egrave;le</em>. <em>Substitution</em> peut
      &ecirc;tre :</p>

      <dl>

        <dt>un chemin du syst&egrave;me de fichiers</dt>

        <dd>Il indique alors la localisation dans le syst&egrave;me de
	fichiers de la ressource qui doit &ecirc;tre envoy&eacute;e au
	client. Les substitutions ne sont trait&eacute;es en tant que chemins du
	syst&egrave;me de fichiers que si la r&egrave;gle est configur&eacute;e dans un
	contexte de serveur (serveur virtuel), et si le premier
	composant du chemin dans la substitution existe dans le syst&egrave;me
	de fichiers.</dd>

        <dt>chemin d'URL</dt>

        <dd>Un chemin relatif &agrave; la valeur de <code class="directive"><a href="../mod/core.html#documentroot">DocumentRoot</a></code> vers la ressource qui
	doit &ecirc;tre servie. Notez que <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code>
	essaie de deviner si vous avez sp&eacute;cifi&eacute; un chemin du syst&egrave;me
	de fichiers ou un chemin d'URL en v&eacute;rifiant si la premi&egrave;re
	partie du chemin existe &agrave; la racine du syst&egrave;me de fichiers.
	Par exemple, si vous avez sp&eacute;cifi&eacute; comme cha&icirc;ne de
	<em>Substitution</em> <code>/www/file.html</code>, cette
	derni&egrave;re sera trait&eacute;e comme un chemin d'URL <em>&agrave; moins</em>
	qu'un r&eacute;pertoire nomm&eacute; <code>www</code> n'existe &agrave; la racine
	de votre syst&egrave;me de fichiers (ou dans le cas d'une
	r&eacute;&eacute;criture au sein d'un fichier <code>.htaccess</code>,
	relativement &agrave; la racine des documents), auquel cas la cha&icirc;ne de
	substitution sera trait&eacute;e comme un chemin du syst&egrave;me de
	fichiers. Si vous d&eacute;sirez que d'autres directives de
	correspondance d'URL (comme la directive <code class="directive"><a href="../mod/mod_alias.html#alias">Alias</a></code>) soient appliqu&eacute;es au
	chemin d'URL r&eacute;sultant, utilisez le drapeau <code>[PT]</code>
	comme d&eacute;crit ci-dessous.</dd>

        <dt>URL absolue</dt>

        <dd><p>Si une URL absolue est sp&eacute;cifi&eacute;e,
	<code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code> v&eacute;rifie si le nom d'h&ocirc;te
	correspond &agrave; celui de l'h&ocirc;te local. Si c'est le cas, le
	protocole et le nom d'h&ocirc;te sont supprim&eacute;s, et ce qui reste est
	trait&eacute; comme un chemin d'URL. Dans le cas contraire, une
	redirection externe vers l'URL indiqu&eacute;e est effectu&eacute;e. Pour
	forcer une redirection externe vers l'h&ocirc;te local, voir le
	drapeau <code>[R]</code> ci-dessous.</p>
	<p>Notez qu'une redirection (implicite ou non) qui utilise une URI
	absolue inclura la cha&icirc;ne de param&egrave;tres de la requ&ecirc;te ; pour &eacute;viter
	ceci, voir le drapeau <code>[QSD]</code> ci-dessous.</p></dd>

        <dt><code>-</code> (tiret)</dt>

        <dd>Un tiret indique qu'aucune substitution ne doit &ecirc;tre
	effectu&eacute;e (le chemin consid&eacute;r&eacute; est transmis sans changement).
	Ceci est utile quand un drapeau doit &ecirc;tre appliqu&eacute; sans
	modifier le chemin (voir ci-dessous).</dd>

      </dl>

      <p>En plus du texte, la cha&icirc;ne <em>Substitution</em> peut
      comporter :</p>

      <ol>
        <li>des r&eacute;f&eacute;rences arri&egrave;res (<code>$N</code>) vers le mod&egrave;le
	d'une directive RewriteRule</li>

        <li>des r&eacute;f&eacute;rences arri&egrave;res (<code>%N</code>) vers le dernier
	mod&egrave;le d'une directive RewriteCond qui correspondait</li>

        <li>des variables du serveur comme dans les cha&icirc;nes de test de
	condition d'une r&egrave;gle (<code>%{VARNAME}</code>)</li>

        <li>des appels de
	<a href="#mapfunc">fonctions de comparaison</a>
	(<code>${nom correspondance:cl&eacute;|d&eacute;faut}</code>)</li>
      </ol>

      <p>Les r&eacute;f&eacute;rences arri&egrave;res sont des identificateurs de la forme
      <code>$</code><strong>N</strong> (<strong>N</strong>=0..9), qui
      seront remplac&eacute;s par le contenu du <strong>N</strong>&egrave;me groupe
      du <em>Mod&egrave;le</em> qui correspondait. Les variables du serveur
      sont les m&ecirc;mes que dans la <em>Cha&icirc;ne_de_test</em> d'une
      directive <code class="directive"><a href="#rewritecond">RewriteCond</a></code>. Les
      fonctions de comparaison sont issues de la directive <code class="directive"><a href="#rewritemap">RewriteMap</a></code> dans la
      section de laquelle elles sont d&eacute;crites. Ces trois types de
      variables sont &eacute;valu&eacute;es dans l'ordre ci-dessus.</p>

       <p>Chaque r&egrave;gle de r&eacute;&eacute;criture s'applique au r&eacute;sultat de la r&egrave;gle
       pr&eacute;c&eacute;dente, selon l'ordre dans lequel elles ont &eacute;t&eacute; d&eacute;finies dans
       le fichier de configuration. Le chemin de l'URL ou du syst&egrave;me de fichier (voir
       ci-dessus <a href="#what_is_matched">Qu'est-ce qui est
       compar&eacute; ?</a>) est <strong>int&eacute;gralement
      remplac&eacute;e</strong> par la cha&icirc;ne de <em>Substitution</em> et le
      processus de r&eacute;&eacute;criture se poursuit jusqu'&agrave; ce que toutes les
      r&egrave;gles aient &eacute;t&eacute; appliqu&eacute;es, ou qu'il soit explicitement stopp&eacute;
      par un drapeau <a href="../rewrite/flags.html#flag_l"><code><strong>L</strong></code></a>,
      ou par un autre drapeau qui implique un arr&ecirc;t imm&eacute;diat, comme
      <code><strong>END</strong></code> ou
      <code><strong>F</strong></code>.</p>

     <div class="note"><h3>Modifier la cha&icirc;ne de requ&ecirc;te</h3>
      <p>Par d&eacute;faut, la cha&icirc;ne de requ&ecirc;te est transmise sans
      modification. Vous pouvez cependant cr&eacute;er dans la cha&icirc;ne de
      substitution des URLs dont une partie constitue une cha&icirc;ne de
      requ&ecirc;te. Pour cela, ajoutez simplement un point d'interrogation
      dans la cha&icirc;ne de substitution pour indiquer que le texte qui
      suit doit &ecirc;tre r&eacute;inject&eacute; dans la cha&icirc;ne de requ&ecirc;te. Pour
      supprimer une cha&icirc;ne de requ&ecirc;te, terminez simplement la cha&icirc;ne de
      substitution par un point d'interrogation. Pour combiner les
      nouvelles cha&icirc;nes de requ&ecirc;te avec les anciennes, utilisez le
      drapeau <code>[QSA]</code>.</p>
     </div>


      <p>En outre, vous pouvez sp&eacute;cifier des <a name="rewriteflags" id="rewriteflags">actions</a> sp&eacute;ciales &agrave; effectuer en ajoutant
      des
      <strong><code>[</code><em>drapeaux</em><code>]</code></strong>
      comme troisi&egrave;me argument de la directive
      <code class="directive">RewriteRule</code>. S&eacute;par&eacute;s par des virgules au sein d'une
      liste encadr&eacute;e par des crochets, les <em>drapeaux</em> peuvent
      &ecirc;tre choisis dans la table suivante. Vous trouverez plus de
      d&eacute;tails, et des exemples pour chaque drapeau dans le <a href="../rewrite/flags.html">document &agrave; propos des drapeaux de
      r&eacute;&eacute;criture.</a></p>

      <table class="bordered"><tr class="header"><th>Drapeaux et syntaxe</th>
        <th>Fonction</th>
    </tr>
<tr>
        <td>B</td>
        <td>Echappe les caract&egrave;res non-alphanum&eacute;riques dans les r&eacute;f&eacute;rences
	arri&egrave;res <em>avant</em> d'appliquer la transformation. Pour un
	&eacute;chappement similaire des variables du serveur, voir la <a href="#mapfunc">fonction de mappage</a> "escape".<em><a href="../rewrite/flags.html#flag_b">d&eacute;tails ...</a></em></td>
    </tr>
<tr class="odd">
        <td>BCTLS</td>
        <td>Identique &agrave; [B], mais n'&eacute;chappe que les espaces et les caract&egrave;res de
	contr&ocirc;le. <em><a href="../rewrite/flags.html#flag_bctls">d&eacute;tails ...</a></em></td>
    </tr>
<tr>
        <td>BNE</td>
	<td>Les caract&egrave;res de [B] ou [BCTLS] qui <strong>ne doivent pas</strong>
	&ecirc;tre &eacute;chapp&eacute;s.  <em><a href="../rewrite/flags.html#flag_bne">d&eacute;tails
	...</a></em></td>
    </tr>
<tr class="odd">
        <td>backrefnoplus|BNP</td>
        <td>Avec ce drapeau, si les r&eacute;f&eacute;rences arri&egrave;res sont &eacute;chapp&eacute;es,
	les espaces seront &eacute;chapp&eacute;s en %20 au lieu de +. Ceci s'av&egrave;re
	utile lorsqu'une r&eacute;f&eacute;rence arri&egrave;re est utilis&eacute;e dans la partie
	chemin, et non dans la cha&icirc;ne de param&egrave;tres de la requ&ecirc;te ;
	pour plus de d&eacute;tails, voir <em><a href="../rewrite/flags.html#flag_bnp">ici.</a></em></td>
    </tr>
<tr>        
	<td>chain|C</td>
        <td>La r&egrave;gle est cha&icirc;n&eacute;e avec la r&egrave;gle suivante. Si la r&egrave;gle
	&eacute;choue, la ou les r&egrave;gles avec lesquelles elle est est cha&icirc;n&eacute;e
	seront saut&eacute;es. <em><a href="../rewrite/flags.html#flag_c">d&eacute;tails ...</a></em></td>
    </tr>
<tr class="odd">
        <td>cookie|CO=<em>NAME</em>:<em>VAL</em></td>
        <td>D&eacute;finit un cookie au niveau du navigateur client. La syntaxe
	compl&egrave;te est :
	CO=<em>NAME</em>:<em>VAL</em>:<em>domain</em>[:<em>lifetime</em>[:<em>path</em>[:<em>secure</em>[:<em>httponly</em>[<em>samesite</em>]]]]] <em><a href="../rewrite/flags.html#flag_co">details ...</a></em>
	<em><a href="../rewrite/flags.html#flag_co">d&eacute;tails ...</a></em>
        </td>
    </tr>
<tr>
        <td>discardpath|DPI</td>
        <td>Supprime la partie PATH_INFO de l'URI r&eacute;&eacute;crit. <em><a href="../rewrite/flags.html#flag_dpi">d&eacute;tails
        ...</a></em></td>
    </tr>
<tr class="odd">
        <td>END</td>
        <td>Stoppe le processus de r&eacute;&eacute;criture imm&eacute;diatement et
	n'applique plus aucune r&egrave;gle. Emp&ecirc;che aussi l'application
	ult&eacute;rieure de r&egrave;gles de r&eacute;&eacute;criture dans les contextes de
	r&eacute;pertoire et de fichier .htaccess (disponible &agrave; partir de la
	version 2.3.9 du serveur HTTP Apache). <em><a href="../rewrite/flags.html#flag_end">d&eacute;tails ...</a></em></td>
    </tr>
<tr>    
        <td>env|E=[!]<em>VAR</em>[:<em>VAL</em>]</td>
        <td>D&eacute;finit la variable d'environnement <em>VAR</em> (&agrave; la valeur
	<em>VAL</em> si elle est fournie). La variante !<em>VAR</em>
	annule la d&eacute;finition de la variable <em>VAR</em>.<em><a href="../rewrite/flags.html#flag_e">d&eacute;tails ...</a></em></td>
    </tr>
<tr class="odd">
        <td>forbidden|F</td>
        <td>Renvoie une r&eacute;ponse 403 FORBIDDEN au navigateur client.
	<em><a href="../rewrite/flags.html#flag_f">d&eacute;tails ...</a></em></td>
    </tr>
<tr>
        <td>gone|G</td>
        <td>Renvoie un message d'erreur 410 GONE au navigateur client. <em><a href="../rewrite/flags.html#flag_g">d&eacute;tails ...</a></em></td>
    </tr>
<tr class="odd">
        <td>Handler|H=<em>Gestionnaire de contenu</em></td>
        <td>L'URI r&eacute;sultant est envoy&eacute; au <em>Gestionnaire de
	contenu</em> pour traitement. <em><a href="../rewrite/flags.html#flag_h">d&eacute;tails ...</a></em></td>
    </tr>
<tr>
        <td>last|L</td>
        <td>Arr&ecirc;te le processus de r&eacute;&eacute;criture imm&eacute;diatement et n'applique
	plus aucune r&egrave;gle. Pr&ecirc;tez une attention particuli&egrave;re aux mises
	en garde concernant les contextes de niveau r&eacute;pertoire et
	.htaccess (voir aussi le drapeau END). <em><a href="../rewrite/flags.html#flag_l">d&eacute;tails ...</a></em></td>
    </tr>
<tr class="odd">
        <td>next|N</td>
        <td>R&eacute;ex&eacute;cute le processus de r&eacute;&eacute;criture &agrave; partir de la premi&egrave;re
	r&egrave;gle, en utilisant le r&eacute;sultat du jeu de r&egrave;gles, sous r&eacute;serve
	qu'il y ait un point de d&eacute;part. <em><a href="../rewrite/flags.html#flag_n">d&eacute;tails
        ...</a></em></td>
    </tr>
<tr>
        <td>nocase|NC</td>
        <td>Rend la comparaison entre mod&egrave;les insensible &agrave; la casse.
	<em><a href="../rewrite/flags.html#flag_nc">d&eacute;tails ...</a></em></td>
    </tr>
<tr class="odd">
        <td>noescape|NE</td>
        <td>Emp&ecirc;che mod_rewrite d'effectuer un &eacute;chappement hexad&eacute;cimal
	des caract&egrave;res sp&eacute;ciaux dans le r&eacute;sultat des r&eacute;&eacute;critures qui aboutissent
	&agrave; une redirection. <em><a href="../rewrite/flags.html#flag_ne">d&eacute;tails ...</a></em></td>
    </tr>
<tr>
        <td>nosubreq|NS</td>
        <td>La r&egrave;gle est saut&eacute;e si la requ&ecirc;te courante est une
	sous-requ&ecirc;te interne. <em><a href="../rewrite/flags.html#flag_ns">d&eacute;tails ...</a></em></td>
    </tr>
<tr class="odd">
        <td>proxy|P</td>
        <td>Force l'envoi en interne de l'URL de substitution en tant
	que requ&ecirc;te mandataire. <em><a href="../rewrite/flags.html#flag_p">d&eacute;tails
        ...</a></em></td>
    </tr>
<tr>
        <td>passthrough|PT</td>
        <td>L'URI r&eacute;sultant est repass&eacute; au moteur de mise en
	correspondance des URLs pour y &ecirc;tre trait&eacute; par d'autres
	traducteurs URI-vers-nom de fichier, comme <code>Alias</code> ou
	<code>Redirect</code>. <em><a href="../rewrite/flags.html#flag_pt">d&eacute;tails ...</a></em></td>
    </tr>
<tr class="odd">
        <td>qsappend|QSA</td>
        <td>Ajoute toute cha&icirc;ne de param&egrave;tres pr&eacute;sente dans l'URL de la
	requ&ecirc;te originale &agrave; toute cha&icirc;ne de param&egrave;tres cr&eacute;&eacute;e dans la
	cible de r&eacute;&eacute;criture. <em><a href="../rewrite/flags.html#flag_qsa">d&eacute;tails ...</a></em></td>
    </tr>
<tr>
        <td>qsdiscard|QSD</td>
        <td>Supprime toute cha&icirc;ne de param&egrave;tres de l'URI entrant. <em><a href="../rewrite/flags.html#flag_qsd">d&eacute;tails
        ...</a></em></td>
    </tr>
<tr class="odd">
        <td>qslast|QSL</td>
        <td>Interpr&egrave;te le dernier (le plus &agrave; droite) point d'interrogation comme
	le d&eacute;limiteur de la cha&icirc;ne de param&egrave;tres de la requ&ecirc;te, au lieu du
	premier (le plus &agrave; gauche) comme c'est le cas habituellement. Disponble
	&agrave; partir de la version 2.4.19 du serveur HTTP Apache. <em><a href="../rewrite/flags.html#flag_qsl">d&eacute;tails ...</a></em></td>
    </tr>
<tr>
	<td>redirect|R[=<em>code</em>]</td>
        <td>Force une redirection externe, avec un code de statut HTTP
	optionnel. <em><a href="../rewrite/flags.html#flag_r">d&eacute;tails ...</a></em>
        </td>
    </tr>
<tr class="odd">
        <td>skip|S=<em>nombre</em></td>
        <td>Si la r&egrave;gle courante s'applique, le moteur de r&eacute;&eacute;criture
	doit sauter les <em>nombre</em> r&egrave;gles suivantes. <em><a href="../rewrite/flags.html#flag_s">d&eacute;tails ...</a></em></td>
    </tr>
<tr>
        <td>type|T=<em>MIME-type</em></td>
        <td>Force l'attribution du <a class="glossarylink" href="../glossary.html#type-mime" title="voir glossaire">Type-MIME</a>
	sp&eacute;cifi&eacute; au fichier cible. <em><a href="../rewrite/flags.html#flag_t">d&eacute;tails ...</a></em></td>
    </tr>
<tr class="odd">
        <td>UnsafeAllow3F</td>
        <td>Autorise les substitutions &agrave; partir d'URL potentiellement non
	fiables.
        <em><a href="../rewrite/flags.html#flag_unsafe_allow_3f">d&eacute;tails ...</a></em>
        </td>
    </tr>
<tr>
        <td>UnsafePrefixStat</td>
        <td>Autorise les substitutions potentiellement non fiables &agrave; partir
	d'une variable de t&ecirc;te ou d'une r&eacute;f&eacute;rence arri&egrave;re vers un chemin du
	syst&egrave;me de fichiers.
        <em><a href="../rewrite/flags.html#flag_unsafe_prefix_stat">d&eacute;tails ...</a></em><br>
        Disponible &agrave; partir de la version 2.4.60 du serveur HTTP Apache.
        </td>
    </tr>
<tr class="odd">
        <td>UNC</td>
        <td>
	Emp&ecirc;che la fusion des slashes de d&eacute;but multiples tels que ceux utilis&eacute;s
	dans les chemins UNC de Windows.
        <em><a href="../rewrite/flags.html#flag_unc">d&eacute;tails ...</a></em><br>
        Disponible &agrave; partir de la version 2.4.62 du serveur HTTP Apache.
        </td>
    </tr>
</table>

<div class="note"><h3>D&eacute;veloppement du r&eacute;pertoire home</h3>
<p> Quand la cha&icirc;ne de substitution commence par quelque chose comme
"/~user" (de mani&egrave;re explicite ou par r&eacute;f&eacute;rences arri&egrave;res), <code class="module"><a href="../mod/mod_rewrite.html">mod_rewrite</a></code>
d&eacute;veloppe le r&eacute;pertoire home sans tenir compte de la pr&eacute;sence ou de la
configuration du module <code class="module"><a href="../mod/mod_userdir.html">mod_userdir</a></code>.</p>

<p> Ce d&eacute;veloppement n'est pas effectu&eacute; si le drapeau <em>PT</em> est
utilis&eacute; dans la directive <code class="directive">RewriteRule</code></p>
</div>

     <p>Voici toutes les combinaisons de substitution et leurs
     significations :</p>

      <p><strong>Dans la configuration au niveau du serveur principal
      (<code>httpd.conf</code>)<br>
       pour la requ&ecirc;te ``<code>GET
      /chemin/infochemin</code>'':</strong><br>
      </p>

<table class="bordered"><tr class="header">
<th>R&egrave;gle</th>
<th>R&eacute;sultat de la substitution</th>
</tr>
<tr>
<td>^/un_chemin(.*) autre_chemin$1</td>
<td>invalide, non support&eacute;</td>
</tr>
<tr class="odd">
<td>^/un_chemin(.*) autre_chemin$1  [R]</td>
<td>invalide, non support&eacute;</td>
</tr>
<tr>
<td>^/un_chemin(.*) autre_chemin$1  [P]</td>
<td>invalide, non support&eacute;</td>
</tr>
<tr class="odd">
<td>^/un_chemin(.*) /autre_chemin$1</td>
<td>/autre_chemin/info_chemin</td>
</tr>
<tr>
<td>^/un_chemin(.*) /autre_chemin$1 [R]</td>
<td>http://cet_hote/autre_chemin/info_chemin via une redirection externe</td>
</tr>
<tr class="odd">
<td>^/un_chemin(.*) /autre_chemin$1 [P]</td>
<td>sans objet, non support&eacute;</td>
</tr>
<tr>
<td>^/un_chemin(.*) http://cet_hote/autre_chemin$1</td>
<td>/autre_chemin/info_chemin</td>
</tr>
<tr class="odd">
<td>^/un_chemin(.*) http://cet_hote/autre_chemin$1 [R]</td>
<td>http://cet_hote/autre_chemin/info_chemin via une redirection externe</td>
</tr>
<tr>
<td>^/un_chemin(.*) http://cet_hote/autre_chemin$1 [P]</td>
<td>sans objet, non support&eacute;</td>
</tr>
<tr class="odd">
<td>^/un_chemin(.*) http://autre_hote/autre_chemin$1</td>
<td>http://autre_hote/autre_chemin/info_chemin via une redirection externe</td>
</tr>
<tr>
<td>^/un_chemin(.*) http://autre_hote/autre_chemin$1 [R]</td>
<td>http://autre_hote/autre_chemin/info_chemin (le drapeau [R] est
redondant)</td>
</tr>
<tr class="odd">
<td>^/somepath(.*) http://otherhost/otherpath$1 [P]</td>
<td>http://otherhost/otherpath/pathinfo via internal proxy</td>
</tr>
</table>

      <p><strong>Dans une configuration de niveau r&eacute;pertoire pour
      <code>/chemin</code><br>
       (<code>/chemin/physique/vers/chemin/.htacccess</code>, avec
      <code>RewriteBase "/chemin"</code>)<br>
       pour la requ&ecirc;te ``<code>GET
      /chemin/chemin-local/infochemin</code>'':</strong><br>
     </p>

<table class="bordered"><tr class="header">
<th>R&egrave;gle</th>
<th>R&eacute;sultat de la substitution</th>
</tr>
<tr>
<td>^chemin-local(.*) autre-chemin$1</td>
<td>/chemin/autre-chemin/infochemin</td>
</tr>
<tr class="odd">
<td>^chemin-local(.*) autre-chemin$1  [R]</td>
<td>http://cet-h&ocirc;te/chemin/autre-chemin/infochemin via redirection
externe</td>
</tr>
<tr>
<td>^chemin-local(.*) autre-chemin$1  [P]</td>
<td>n'a pas lieu d'&ecirc;tre, non support&eacute;</td>
</tr>
<tr class="odd">
<td>^chemin-local(.*) /autre-chemin$1</td>
<td>/autre-chemin/infochemin</td>
</tr>
<tr>
<td>^chemin-local(.*) /autre-chemin$1 [R]</td>
<td>http://cet-h&ocirc;te/autre-chemin/infochemin via redirection externe</td>
</tr>
<tr class="odd">
<td>^chemin-local(.*) /autre-chemin$1 [P]</td>
<td>n'a pas lieu d'&ecirc;tre, non support&eacute;</td>
</tr>
<tr>
<td>^chemin-local(.*) http://cet-h&ocirc;te/autre-chemin$1</td>
<td>/autre-chemin/infochemin</td>
</tr>
<tr class="odd">
<td>^chemin-local(.*) http://cet-h&ocirc;te/autre-chemin$1 [R]</td>
<td>http://cet-h&ocirc;te/autre-chemin/infochemin via redirection externe</td>
</tr>
<tr>
<td>^chemin-local(.*) http://cet-h&ocirc;te/autre-chemin$1 [P]</td>
<td>n'a pas lieu d'&ecirc;tre, non support&eacute;</td>
</tr>
<tr class="odd">
<td>^chemin-local(.*) http://autre h&ocirc;te/autre-chemin$1</td>
<td>http://autre h&ocirc;te/autre-chemin/infochemin via redirection externe</td>
</tr>
<tr>
<td>^chemin-local(.*) http://autre h&ocirc;te/autre-chemin$1 [R]</td>
<td>http://autre h&ocirc;te/autre-chemin/infochemin via redirection externe
(le drapeau [R] est redondant)</td>
</tr>
<tr class="odd">
<td>^chemin-local(.*) http://autre h&ocirc;te/autre-chemin$1 [P]</td>
<td>http://autre h&ocirc;te/autre-chemin/infochemin via un mandataire interne</td>
</tr>
</table>

  
</div>
</div>
<div class="bottomlang">
<p><span>Langues Disponibles: </span><a href="../en/mod/mod_rewrite.html" hreflang="en" rel="alternate" title="English">&nbsp;en&nbsp;</a> |
<a href="../fr/mod/mod_rewrite.html" title="Fran&ccedil;ais">&nbsp;fr&nbsp;</a></p>
</div><div id="footer">
<p class="apache">Copyright 2026 The Apache Software Foundation.<br>Autoris&eacute; sous <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a>.</p>
<p class="menu"><a href="../mod/">Modules</a> | <a href="../mod/quickreference.html">Directives</a> | <a href="https://cwiki.apache.org/confluence/display/httpd/FAQ">FAQ</a> | <a href="../glossary.html">Glossaire</a> | <a href="../sitemap.html">Plan du site</a> | <a href="https://bz.apache.org/bugzilla/enter_bug.cgi?product=Apache%20httpd-2">Signaler un bug</a></p></div><script><!--//--><![CDATA[//><!--
if (typeof(prettyPrint) !== 'undefined') {
    prettyPrint();
}
var langToggle = document.querySelector('.lang-toggle');
var topLang = document.querySelector('.toplang');
if (langToggle && topLang) {
    langToggle.addEventListener('click', function() { topLang.classList.toggle('open'); });
}
var qv = document.getElementById('quickview');
if (qv) {
    document.body.appendChild(qv);
    var qvBtn = document.createElement('button');
    qvBtn.className = 'qv-toggle';
    qvBtn.setAttribute('aria-label', 'Toggle page navigation');
    qvBtn.innerHTML = '&#9776;';
    document.body.appendChild(qvBtn);
    qvBtn.addEventListener('click', function() {
        var isOpen = qv.classList.toggle('open');
        if (isOpen) {
            qv.style.top = window.scrollY + 10 + 'px';
        }
    });
    window.addEventListener('scroll', function() { qv.classList.remove('open'); });
}
//--><!]]></script>
</body></html>