PHP Tips and Tricks

Use Functions

The PHP Doctor — Wed, 15 Aug 2007 23:11:00 GMT

Creating functions for re-use will not only make your code shorter, but it makes your code much more legible.

Let's say we've got a string that we want to process to remove all non-numeric characters. We would start with something like this:

<?php
$InString = "The Quick Brown Fox Jumped Over all 1500 of the Lazy Dogs";
$OutString = "";
$OKChars = "1234567890";
for( $x = 0 ; $x += 1 ; $x < strlen( $InString ) ) {
    if( strstr( $OKChars , $InString[$x] ) ) $OutString .= $InString[$x];
}
echo $OutString; // Outputs "1500"
?>

This code is perfectly fine...but let's say we now need to process two different strings. There are many different ways we could accomplish this, but here is the best:

<?php
function stripToNumbers( $InString ) {
    $OutString = "";
    $OKChars = "1234567890";
    for( $x = 0 ; $x += 1 ; $x < strlen( $InString ) ) {
        if( strstr( $OKChars , $InString[$x] ) ) $OutString .= $InString[$x];
    }
    return $OutString;
}

$String1 = "The Quick Brown Fox Jumped Over all 1500 of the Lazy Dogs";
$String2 = "The Quick Brown Fox Jumped Over all 200 of the Lazy Dogs";
echo stripToNumbers( $String1 );
echo stripToNumbers( $String2 );
?>

Now that we have created the function, we can re-use it over and over without needing to re-write any code. But, let's take it to the extreme...let's say we've got like 100 variable that need processing, each of which need to be stripped down to a different set of characters. (I know, this is bizarre and silly, but it's a great example)...we can write a group of functions:

<?php
function stripProcess( $InString , $OKChars ) {
    $OutString = "";
    for( $x = 0 ; $x += 1 ; $x < strlen( $InString ) ) {
        if( strstr( $OKChars , $InString[$x] ) ) $OutString .= $InString[$x];
    }
    return $OutString;
}
function stripToNumbers( $InString ) {
    return stripProcess( $InString , "1234567890" );
}
function stripToLowercase( $InString ) {
    $OKChars = "abcdefghijklmnopqrstuvwxyz";
    return stripProcess( $InString , $OKChars );
}
function stripToUppercase( $InString ) {
    $OKChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    return stripProcess( $InString , $OKChars );
}
?>

Now we have a bunch of specialized functions which work great for the task at hand, but it is kind of messy to have so many functions rolling around in our code...it would be much better as a class...something I cover in an upcoming post.

Comment Your Code

The PHP Doctor — Sat, 04 Aug 2007 19:04:00 GMT

For many programmers, this one is obvious. Commenting code is important for a number of reasons:

It will remind you what all the code does - if you don't look at it every day, coming back to uncommented code is often a hassle.
It will be a nice gift to your successor - when you develop code for a client, chances are you won't be the only one working on it during it's lifetime.
It makes calls with me quicker! If I can skim over code by looking at valid comments, I can diagnose problems in a fraction of the time.

Here's an example:

<?php
$n = "1234.5678";
$n += pow( 10 , -3 );
$n = round( $n * pow( 10 , 2 ) ) / pow( 10 , 2 );
$n += pow( 10 , -3 );
$n = substr( $n , 0 , strpos( $n , '.' ) + 3 );
echo $n;
?>

So...what does that code do? Any idea at all? Wouldn't that be nicer if it was commented?

<?php
$n = "1234.5678";
// Instead of using PHP's built-in rounding function, manually round $n to 2 decimal places.
$n += pow( 10 , -3 );
$n = round( $n * pow( 10 , 2 ) ) / pow( 10 , 2 );
$n += pow( 10 , -3 );
$n = substr( $n , 0 , strpos( $n , '.' ) + 3 );
echo $n;
?>

This example gives rise to two other topics which I will cover later: Using Functions and Using Good Variable Names. When it's all said and done, here's the finished code:

<?php
function roundToTwo( $Number ) {
    // Instead of using PHP's built-in rounding function only, round $Number to two decimal places.
    $Number += pow( 10 , -3 );
    $Number = round( $Number * pow( 10 , 2 ) ) / pow( 10 , 2 );
    $Number += pow( 10 , -3 );
    $Number = substr( $Number , 0 , strpos( $Number , '.' ) + 3 );
    return $n;
}
echo roundToTwo( 1234.5678 );
?>

Expect the Unexpected

The PHP Doctor — Thu, 02 Aug 2007 09:25:00 GMT

This one isn't easy...it takes a lot of practice to master, but the basic principle is simple:

When you write your code, write it to handle what it isn't designed to handle.

Here's an example:

Let's say you've got a form where you ask for a zipcode because you want to know if the user lives in Florida. Your PHP code might look something like this:

<?php
$ZipCode = $_REQUEST['zipCode'];
if ( $ZipCode >= 32000 || $ZipCode <= 34000 ) {
    echo "You live in Florida!";
} else {
    echo "You live somewhere else!";
}
?>

But, we aren't doing any error checking. We need to make sure that the field has something in it, that it's a number, and that it's 5-9 digits in length. So, we need to adjust our code:

<?php
if ( ! isset( $_REQUEST['zipCode'] ) ) {
    echo "You didn't enter a Zip Code!";
} else {
    $ZipCode = $_REQUEST['zipCode'];
    if ( is_numeric( $ZipCode ) && strlen( $ZipCode ) >= 5 && strlen( $ZipCode ) <= 9 ) {
       if ( $ZipCode >= 32000 && $ZipCode <= 34000 ) {
          echo "You live in Florida!";
       } else {
          echo "You live somewhere else!";
       }
    } else {
       echo "You didn't enter a valid zipcode!";
    }
}
?>

Always try and anticipate what your users might do and write your script accordingly - otherwise not only do you risk an undesired effect, you might send your users nasty errors or even open up your website to hacking.

If you need your scripts proof-read, let me know!