Implement URL rewriting using .htaccess: Remove query parameters and create beautiful URLs

This article discusses in depth how to use Apache's .htaccess file for URL rewriting to realize the conversion of URLs with query parameters (such as ?q=something) into simple and beautiful paths (such as /something). The article analyzes the common rewrite rule errors in detail and the reasons for internal rewrite loops, and provides the correct RewriteRule configuration to avoid matching internal files through precise regular expressions. At the same time, it demonstrates how to get parameters in conjunction with PHP code, aiming to help developers build a more friendly URL structure.

Understand URL beautification and rewriting requirements

In web development, in order to improve user experience and search engine optimization (SEO), we often need to convert dynamic URLs containing query strings (such as https://example.com/?q=something) into more readable and semantic static URL forms (such as https://example.com/something). This conversion is usually implemented through the server-side URL rewriting module. The most commonly used tool in the Apache server is the .htaccess file and the mod_rewrite module.

Analysis of common rewrite errors and causes

Many developers may encounter a common problem when trying to implement such URL rewrites: rewriting rules cause pages to display exceptions, such as always showing the content of index.php instead of the expected dynamic content. This is usually due to the over-the-top matching pattern of the rewrite rules, resulting in an internal rewrite loop.

An example of a common error rule is as follows:

 RewriteEngine On
RewriteRule ^(.*) index\.php?q=$1

The matching PHP code may be as follows:

 
  
    <meta charset="utf-8">
    <title>Document</title>
  
  
    <?php echo htmlspecialchars($_GET[&#39;q&#39;]); ?>
  

When accessing https://example.com/something using the above .htaccess rules, it is expected to be rewrite it to index.php?q=something. However, if you visit https://example.com/index.php, or during the second processing phase of the internal rewrite engine, the RewriteRule ^(.*) pattern will match index.php again after the request is rewritten to index.php. This causes an internal rewrite of index.php?q=index.php, thus making the value of $_GET['q'] become index.php, not something we expect. This phenomenon is particularly evident when used in .htaccess files (directory context), because Apache's rewrite engine may perform multiple rounds of processing requests for internal rewrites.

The correct solution

To avoid the above internal rewrite loop, we need a more precise regular expression that matches the "clean" URL path we expect while excluding the actual file name (especially index.php) and static resources with file extensions (e.g. .css, .js, .jpg, etc.).

An effective solution is to use the RewriteRule as follows:

 RewriteEngine On
RewriteRule ^([^.]*)$ index.php?q=$1 [L]

Detailed explanation of the rules

Let's parse the various parts of this rule in detail:

• RewriteEngine On: Enable Apache's rewrite engine.
• RewriteRule: Defines a rewrite rule.
  • ^([^.]*)$: This is the matching pattern (regular expression) for rewriting the rules.
    • ^: Match the beginning of the URL path.
    • ([^.]*): This is a capture group that matches zero or multiple times of any character except the dot (.).
      • [^.]: Match any character that is not a dot.
      • *: Match the previous character zero or multiple times.
    • $: Match the end of the URL path. This pattern ensures that only the full paths that do not contain dots (e.g. /something) will be matched, while file paths like index.php or style.css will not be matched, thus avoiding internal rewrite loops.
  • index.php?q=$1: This is the replacement string. When the matching pattern is successful, the original request will be rewritten to this internal path.
    • index.php?q=: This is the fixed target file and query parameter name.
    • $1: This is a backreference that references what is captured by the first capture group (i.e. ([^.]*)) in the matching pattern. For example, if the request is /something, the value of $1 is something. Note: In the replacement string, dot (.) does not require backslash escape because it is considered a normal character.
  • [L]: This is a flag that means "Last" (last rule). This means that if the current RewriteRule match successfully and the rewrite is performed, mod_rewrite will stop processing subsequent rewrite rules. This is crucial to prevent unnecessary rule handling and potential rewrite loops.

Supporting PHP code

In the index.php file, you can use $_GET['q'] to get the rewritten parameter value:

 <?php // index.php
$query_param = isset($_GET[&#39;q&#39;]) ? $_GET[&#39;q&#39;] : &#39;default_value&#39;;
?>


  
    <meta charset="utf-8">
    <title>URL rewrite example</title>
  
  
    <h1>The current requested parameters are: <?php echo htmlspecialchars($query_param); ?>
</h1>
    <p>Accessing/something will display "something"</p>
    <p>Accessing /another-page will display "another-page"</p>
  

When accessing https://example.com/something, index.php will receive $_GET['q'] as something.

Notes and best practices

1. The importance of [L] flag : Always consider using the [L] flag in RewriteRule, especially in the .htaccess environment, to ensure that the rewrite engine stops processing after the match is successful and avoids unexpected behavior.
2. The accuracy of regular expressions : ^([^.]*)$ This regular expression assumes that your beautiful URL path does not contain dot numbers. If your URL paths may contain dot numbers (e.g. /my.document), but you still want them to be overridden, then you need more complex regular expressions, or use conditions in RewriteCond to exclude files or directories that actually exist.
   • For example, you can use RewriteCond to check whether the requested file or directory exists, and rewrite it if it does not exist:

      RewriteCond %{REQUEST_FILENAME} !-f
     RewriteCond %{REQUEST_FILENAME} !-d
     RewriteRule ^(.*)$ index.php?q=$1 [L]

     This means that if the requested file name is not a real file (!-f) or a real directory (!-d), then rewrite is performed.

3. .htaccess file location : The .htaccess file should be placed in the root directory of the website (or in the specific directory where you want to apply the rewrite rules).
4. Server configuration : Make sure the mod_rewrite module is enabled by the Apache server, and in the httpd.conf or virtual host configuration, the AllowOverride directive for the corresponding directory is set to All or FileInfo to allow the rewrite rules in the .htaccess file to take effect.
5. Caching issues : When testing URL rewriting rules, the browser and server side (such as PHP-FPM, OpCache) may have caches. After modifying .htaccess, it is recommended to clear the browser cache or use traceless mode for testing, and restart the Apache service (if httpd.conf is modified) to ensure that the rules take effect.

Summarize

Through precise RewriteRule and understanding of regular expressions, we can effectively use .htaccess to achieve URL beautification and convert dynamic query parameters into concise and user-friendly paths. The key is to select a regular expression that accurately matches the target path and avoids conflicts with the actual file or internal rewrite request, and supplemented with flags such as [L] to control the rewrite process. Mastering these tips will help build more robust and easier to maintain web applications.

The above is the detailed content of Implement URL rewriting using .htaccess: Remove query parameters and create beautiful URLs. For more information, please follow other related articles on the PHP Chinese website!