Month: February 2010

While you can always use .htaccess and the mod_rewrite module to map SEO friendly URLs to actual PHP parameterized URLs with question marks and ampersands, you can simply put these lines in .htaccess and then rely on PHP entirely to recognize and handle all incoming URL requests of any kind / form:

<IfModule mod_rewrite.c>

RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]

</IfModule>

The index.php file in the document root of your domain is now effectively in charge of all incoming URL requests. You can recognize / distinguish the requests and perform accordingly in your PHP script, the key is the PHP environmental variable $_SERVER["REQUEST_URI"] which contains the complete URL request string. Consider a index.php like this:

<?php // index.php

$req = explode('/', $_SERVER['REQUEST_URI']);
print_r($req);

?>

Type in your browser address bar:

http://www.example.com/user/110/edit

And the site will render the output page like this:

Array
(
    [0] =>
    [1] => user
    [2] => 110
    [3] => edit
)

So you can process the request according to the array. It probably means opening the editor page to edit the user whose ID is 110. Just sub-include the responsible PHP script to get the job done from index.php. To parse more complicated request URLs, e.g. with question marks and parameters, you may want to use the parse_url() or preg_split().

PHP file upload max size is determined by 3 configuration values in php.ini, namely upload_max_filesize, post_max_size and memory_limit. You can get the maximum file size allowed in uploading by this snippet:

$max_upload = (int)(ini_get('upload_max_filesize'));
$max_post = (int)(ini_get('post_max_size'));
$memory_limit = (int)(ini_get('memory_limit'));
$upload_mb = min($max_upload, $max_post, $memory_limit);

Wherein $upload_mb is the maximum file size allowed for upload in MB. It’s the smallest of the 3 values. Just display this value beside the file upload control so the user knows the limit before choosing the file.

I guess most of the websites out there are using plain strings for the years of footer copyright because many of them are still showing 2009 right now. If you have quite a few websites as I do, it’d be kind of intimidating to manually update the copyright years for all of them. So why not use PHP to output the current year automatically? The code is dead simple:

&copy; Copyright 2006 - <?php echo date('Y'); ?>

The PHP date() function does the job, the format string ‘Y’ tells it to return the current year in 4 digits. Now your website would automatically update the copyright footer year to 2006 – 2011 when comes next year.

While it may seem a good idea without tradeoffs, when you think about it, it does consume a little bit more computing resources to process the pages because it’s a function rather than a plain text string. Without a content cache, the date() function would use up extra 0.000045 seconds upon every page view (tested on my personal computer with WAMP installed on Windows XP SP2, could be larger on virtual host where computing power is restrained). With a site receiving 100,000 page views per month, the users would lost a total of 54 seconds across the year. There are also server computing resources that could otherwise be saved, thus electricity, and thus your website’s carbon footprint.

Up to you, though, especially if your time is valuable enough.

When you need to include or require a php file that is in the same directory as the currently running one, most people come up with this simple line in the current script:

include('include.php');

While this approach doesn’t present obvious breaches, it is slightly inefficient than the following way:

include(dirname(__FILE__).'/include.php');

You will type a little more but the extra code frees PHP from iterating through the include_path in the attempt to locate ‘include.php’ because dirname(__FILE__) has explicitly returned the absolute path to the file. The constant __FILE__ in PHP always returns the absolute path to the script file that’s currently active – the PHP file in which the code line is being run right now. Function dirname() returns the directory part of the given path.

A better approach would be:

include('./include.php');

Which explicitly commands PHP to look for the file ‘include.php’ in the current directory, yet comes without the overhead of the function dirname(). With large applications, you would prefer storing the path of the primary working directory of the application in some centralized configuration files:

define('APP_DIR', '/home/appuser/appdomain.com/app');

And when you need to include a file in the sub directory ‘class’:

include(APP_DIR.'/class/tobeincluded.php');

Thanks to Gumbo, alexef and Justin at Stack Overflow.