Implémentez la réécriture de l'URL à l'aide de .htaccess: supprimez les paramètres de requête et créez de belles URL

Cet article examine en profondeur comment utiliser le fichier .htaccess d'Apache pour la réécriture d'URL pour réaliser la conversion des URL avec des paramètres de requête (tels que? Q = quelque chose) en chemins simples et beaux (tels que / quelque chose). L'article analyse les erreurs de règle de réécriture communes en détail et les raisons des boucles de réécriture internes, et fournit la configuration de réécriture correcte pour éviter de faire correspondre les fichiers internes via des expressions régulières précises. Dans le même temps, il montre comment obtenir des paramètres en conjonction avec le code PHP, visant à aider les développeurs à construire une structure URL plus conviviale.

Comprendre les exigences d'embellissement et de réécriture de l'URL

Dans le développement Web, afin d'améliorer l'expérience utilisateur et l'optimisation des moteurs de recherche (SEO), nous devons souvent convertir des URL dynamiques contenant des chaînes de requête (telles que https://example.com/?q=somethinging) en formulaires URL statiques plus lisibles et sémantiques (tels que https://example.com/something). Cette conversion est généralement implémentée via le module de réécriture de l'URL côté serveur. L'outil le plus utilisé dans le serveur Apache est le fichier .htaccess et le module mod_rewrite.

Analyse des erreurs et causes de réécriture communes

De nombreux développeurs peuvent rencontrer un problème commun lorsque vous essayez d'implémenter de telles réécritures URL: les règles de réécriture provoquent des exceptions des pages, telles que toujours le contenu d'Index.php au lieu du contenu dynamique attendu. Cela est généralement dû au modèle de correspondance exagéré des règles de réécriture, résultant en une boucle de réécriture interne.

Un exemple de règle d'erreur commune est la suivante:

 Réécrire
Réécriture ^ (. *) Index \ .php? Q = 1 $

Le code PHP correspondant peut être le suivant:

 
  <adal>
    <meta charset="utf-8">
    <title> Document </title>
   head>
  
     php echo htmlSpecialChars ($ _ get ['q']); ?>
  
</adal>

Lorsque vous accédez à https://example.com/something en utilisant les règles .htaccess ci-dessus, il devrait le réécrire sur index.php? Q = quelque chose. Cependant, si vous visitez https://example.com/index.php, ou pendant la deuxième phase de traitement du moteur de réécriture interne, le modèle de réécriture ^ (. *) Correspondra à nouveau à index.php une fois la demande réécrite sur index.php. Cela provoque une réécriture interne d'index.php? Q = index.php, faisant ainsi la valeur de $ _get ['q'] devenue index.php, pas quelque chose que nous attendons. Ce phénomène est particulièrement évident lorsqu'il est utilisé dans les fichiers .htaccess (contexte du répertoire), car le moteur de réécriture d'Apache peut effectuer plusieurs cycles de traitement des demandes de réécriture interne.

La bonne solution

Pour éviter la boucle de réécriture interne ci-dessus, nous avons besoin d'une expression régulière plus précise qui correspond au chemin d'URL "propre" que nous attendons tout en excluant le nom de fichier réel (en particulier index.php) et les ressources statiques avec des extensions de fichiers (par exemple .css, .js, .jpg, etc.).

Une solution efficace consiste à utiliser la réécriture comme suit:

 Réécrire
REWRITREULE ^ ([^.] *) $ Index.php? Q = 1 $ [l]

Explication détaillée des règles

Analyserons les différentes parties de cette règle en détail:

• Réécriture de la conduite sur: activer le moteur de réécriture d'Apache.
• REWRITREULE: Définit une règle de réécriture.
  • ^ ([^.] *) $: Ceci est le modèle d'appariement (expression régulière) pour réécrire les règles.
    • ^: Faites correspondre le début du chemin d'URL.
    • ([^.] *): Il s'agit d'un groupe de capture qui correspond à zéro ou plusieurs fois de tout caractère sauf le point (.).
      • [^.]: Faites correspondre tout caractère qui n'est pas un point.
      • *: Faites correspondre le caractère précédent zéro ou plusieurs fois.
    • $: Faites correspondre la fin du chemin d'URL. Ce modèle garantit que seuls les chemins complets qui ne contiennent pas de points (par exemple / quelque chose) seront appariés, tandis que les chemins de fichier comme index.php ou style.css ne seront pas appariés, évitant ainsi les boucles de réécriture internes.
  • index.php? Q = 1 $: Ceci est la chaîne de remplacement. Lorsque le modèle d'appariement réussit, la demande d'origine sera réécrite sur ce chemin interne.
    • index.php? Q =: Il s'agit du fichier cible fixe et du nom du paramètre de requête.
    • 1 $: Il s'agit d'une référence qui fait référence à ce qui est capturé par le premier groupe de capture (c'est-à-dire ([^.] *)) Dans le modèle d'appariement. Par exemple, si la demande est / quelque chose, la valeur de 1 $ est quelque chose. Remarque: Dans la chaîne de remplacement, le point (.) Ne nécessite pas d'échappement de barre arrière car il est considéré comme un caractère normal.
  • [L]: Il s'agit d'un drapeau qui signifie "dernier" (dernière règle). Cela signifie que si le réécriture actuelle correspond avec succès et que la réécriture est effectuée, mod_rewrite cessera de traiter les règles de réécriture ultérieures. Ceci est crucial pour empêcher la gestion inutile des règles et les boucles de réécriture potentielles.

Prise en charge du code PHP

Dans le fichier index.php, vous pouvez utiliser $ _get ['q'] pour obtenir la valeur du paramètre réécrit:

  Php
// index.php
$ query_param = isset ($ _ get ['q'])? $ _Get ['q']: 'default_value';
?>


  <adal>
    <meta charset="utf-8">
    <title> URL REWRITE Exemple 
   head>
  </title>
    <h1> Les paramètres demandés actuels sont:  Php Echo htmlSpecialCars ($ query_param); ?> </h1>
    <p> accéder / quelque chose affiche "quelque chose" </p>
    <p> Accès / une autre page affichera "une autre page" </p>
  
</adal>

Lors de l'accès à https://example.com/something, index.php recevra $ _get ['q'] comme quelque chose.

Notes et meilleures pratiques

1. L'importance du drapeau [l] : envisagez toujours d'utiliser le drapeau [l] dans la réécriture, en particulier dans l'environnement .htaccess, pour vous assurer que le moteur de réécriture arrête le traitement après le succès du match et évite un comportement inattendu.
2. La précision des expressions régulières : ^ ([^.] *) $ Cette expression régulière suppose que votre beau chemin d'URL ne contient pas de nombres de points. Si vos chemins URL peuvent contenir des nombres de points (par exemple /my.Document), mais que vous voulez toujours qu'ils soient remplacés, vous avez besoin d'expressions régulières plus complexes ou d'utiliser des conditions dans REWRITECOND pour exclure des fichiers ou des répertoires qui existent réellement.
   • Par exemple, vous pouvez utiliser RewriteCond pour vérifier si le fichier ou le répertoire demandé existe, et le réécrire s'il n'existe pas:

      RewriteCond% {request_filename}! -F
     RewriteCond% {request_filename}! -D
     REWRITREULE ^ (. *) $ Index.php? Q = 1 $ [l]

     Cela signifie que si le nom de fichier demandé n'est pas un vrai fichier (! -F) ou un vrai répertoire (! -D), la réécriture est effectuée.

3. Emplacement du fichier .htaccess : Le fichier .htaccess doit être placé dans le répertoire racine du site Web (ou dans le répertoire spécifique où vous souhaitez appliquer les règles de réécriture).
4. Configuration du serveur : assurez-vous que le module Mod_rewrite est activé par le serveur Apache, et dans la configuration de l'hôte httpd.conf ou virtuel, la directive AwardOverride pour le répertoire correspondant est définie sur tous ou FileInfo pour permettre les règles de réécriture dans le fichier .htAccess pour prendre effet.
5. Problèmes de mise en cache : lors du test des règles de réécriture de l'URL, le navigateur et le côté serveur (tels que PHP-FPM, OPCACHE) peuvent avoir des caches. Après avoir modifié .htaccess, il est recommandé d'effacer le cache du navigateur ou d'utiliser le mode sans trace pour tester, et de redémarrer le service Apache (si httpd.conf est modifié) pour s'assurer que les règles prennent effet.

Résumer

Grâce à une réécriture précise et à la compréhension des expressions régulières, nous pouvons utiliser efficacement .htaccess pour réaliser l'embellissement de l'URL et convertir les paramètres de requête dynamique en chemins concises et conviviaux. La clé consiste à sélectionner une expression régulière qui correspond avec précision sur le chemin cible et évite les conflits avec le fichier réel ou la demande de réécriture interne, et complété avec des drapeaux tels que [l] pour contrôler le processus de réécriture. La maîtrise de ces conseils aidera à créer des applications Web plus robustes et plus faciles à maintenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!