So how do you know if there are PHP short tags being used some where in your code? I use grep to search for them: grep -rn "<?[^p]" *

Related posts:

1. PHP Helpers: html_print_r
2. Problems With libxml2 For WordPress XML-RPC Users
3. MakeItLink – Detecting URLs In Text And Making Them Links

From WordPress.TV.

I’ll never get used to watching myself on video.

Related posts:

1. WordCamp Utah 2010
2. WordCamp San Francisco – 2010
3. WordCamp Utah 2010 Update – Genius Bar

I added it to my slides page.

Related posts:

1. Slides
2. Utah PHP Users Group Presentation: Anatomy of a PHP Request
3. Presenting At Utah PHP Users (UPHPU) February Meeting

Ever wondered what really happens when your PHP script runs? I’ll cover the major milestones in the life and times of a PHP request (read, parse, compile, execute, output ) and where to look for road bumps along the way. There are lots of tools available to make your PHP purr like a kitten, so I’ll dive into op code caches (with APC), op code dumps (with VLD – Vulcan Logic Dumper), and profiling (with Xdebug and webgrind). It will be a great time digging a little deeper in to PHP!

The meeting is at:

April 15, 2010 @7pm

Bill Good Marketing
12393 Gateway Park Place
Suite 600
Draper, UT 84020

Google Map

Related posts:

1. Presenting At Utah PHP Users (UPHPU) February Meeting
2. Slides: Anatomy of a PHP Request
3. Firebug Feature Request

require dirname( __FILE__ ) . '/path/to/something.php';
require dirname( __FILE__ ) . '/path/to/another.php';
require dirname( __FILE__ ) . '/path/to/me-too.php';
require dirname( __FILE__ ) . '/path/to/sure-why-not.php';
require dirname( __FILE__ ) . '/path/to/kitchen-sink.php';

and what jumps out at me is the repeated use of dirname( __FILE__ ) for each require statement (for now we’ll avoid asking why anyone would need to include the kitchen-sink in their code base). My gut instinct is to call dirname( __FILE__ ) once, save that in a variable and then reference the variable to build the path. Not wanting to go on instinct alone I put together a small test to see if it really would make any difference.

The contrived test code will compare approach A:

$var = dirname( __FILE__ ) . '/path/to/something.php';
$var = dirname( __FILE__ ) . '/path/to/another.php';
$var = dirname( __FILE__ ) . '/path/to/me-too.php';
$var = dirname( __FILE__ ) . '/path/to/sure-why-not.php';
$var = dirname( __FILE__ ) . '/path/to/kitchen-sink.php';

with approach B:

$path = dirname( __FILE__ );

$var = $path . '/path/to/something.php';
$var = $path . '/path/to/another.php';
$var = $path . '/path/to/me-too.php';
$var = $path . '/path/to/sure-why-not.php';
$var = $path . '/path/to/kitchen-sink.php';

I’m not testing with require in an effort to focus just on the difference repeated dirname( __FILE__ ) calls make, not how fast the filesystem can slurp in PHP libraries.

VLD

My first test was to pass each approach through VLD to see how much “work” PHP was doing. For that I pulled out the number of operations needed for each approach:

approach A: 37 ops
approach B: 23 ops

Calling dirname( __FILE__ ) once required 37% fewer operations. This is a bit of blunt measurement since it doesn’t attempt to give individual weights to the different operations, but it gives a good general view. The rule of thumb is that fewer ops is better than more ops.

Time

I tried running each approach in a simple loop, but it always ran so quickly that I didn’t see any useful difference.

Memory

Next up was a look at memory_get_peak_usage. Turns out there was a small difference:

approach A: 57,312 bytes
approach B: 56,992 bytes

Sure 320 bytes isn’t a big deal in the world of servers with 16GB of memory, but it’s one more reason why approach B is just that tiny bit better.

Conclusion

If you see this pattern creeping into your code base and you can easily convert it then you’ll likely be better off for it. Remember that everything is a trade off though, if it takes you several hours to go through and make this kind of change it may not be worth it.

I’d certainly file this away for new projects though so that you can avoid repetitive dirname( __FILE__ ) calls from the start. For that matter, if you can get away with running on 5.3 or higher then you’d probably want to skip this entirely and look at using the new __DIR__ constant. I haven’t tested how it compares to the two approaches listed above, but I’d expect it to be at least as good as approach B, perhaps even better.

For reference I tested this using PHP 5.2.10-2ubuntu6.4 with Suhosin-Patch 0.9.7 (cli) (built: Jan 6 2010 22:41:56). Your specific version of PHP may behave differently.

Related posts:

1. PHP Count Performance
2. Database Powered CSS in WordPress Themes
3. MakeItLink

First a quick refresher course on isset() and empty(). The isset function only checks to see if a specific variable was been created and has a value other than NULL. Other than the NULL check isset doesn’t make any determinations on what value the variable holds. The empty function on the other hand looks at the value of a variable to see if it has been set to something that could be considered “empty”. The empty doc page mentions what PHP considers “empty”:

Returns FALSE if var has a non-empty and non-zero value.

The following things are considered to be empty:

“” (an empty string)
0 (0 as an integer)
“0″ (0 as a string)
NULL
FALSE
array() (an empty array)
var $var; (a variable declared, but without a value in a class)

So with all that in mind, what would you expect from the following code:

$test_me = ' ';

if ( empty( $test_me ) ) {
    echo "This is empty!\n";
} else {
    echo "NOT empty\n";
}

Where $test_me is set to a string that contains a single space character. If you said ‘NOT empty’ was the result, you are correct. If you said ‘This is empty!’, well, I can understand why you’d think that, but that turned out to be the wrong answer.

This is exactly what happened in the bug I saw. An empty check was being done inside a foreach() loop to see if any work on that item in the array really needed to be done. If empty returned TRUE then continue was called to skip work on that item and go on to the next. Unfortunately it didn’t expect the condition where the value might just be a string full of spaces. To people that looks empty, to PHP, not so much.

foreach ( $stuff as $a_thing ) {
    if ( empty( $a_thing ) ) {
        continue;
    }

    ...
}

A good approach, until $a_thing includes our friend the string of spaces.

So how do you deal with this? PHP provides an rtrim function to remove trailing spaces (and space line items) and you might be tempted to try this:

if ( empty( rtrim( $test_me ) ) ) {
    ...
}

But that won’t work. The empty function can only check variables, thankfully this is noted on the empty docs page:

Note: empty() only checks variables as anything else will result in a parse error. In other words, the following will not work: empty(trim($name)).

Not the end of the world, just means you have to write it like this:

$test_me = rtrim( $test_me );
if ( empty( $test_me ) ) {
    ...
}

That will remove any trailing spaces from $test_me before the empty check, so strings that consist of just spaces (or space like characters) will truly become empty in the PHP sense.

If you’ve been writing PHP long enough you’ve likely run into this problem, it’s an easy one to get tripped on. I’ve lost count the number of times I’ve been bitten by this over the years. Perhaps writing this will save me (and hopefully others) from this mistake in the future.

Related posts:

1. PHP Helpers: debug_log
2. PHP Helpers: esc_html
3. I Don’t Like PHP’s extract() Function

if ( !function_exists( 'curl_http_request' ) ) {
    function curl_http_request( $url, $req = 'GET', $arg = array( ) ) {
        $body       = '';
        $cookies    = array( );
        $err_no     = 0;
        $err_msg    = '';
        $headers    = array( );
        $info       = array( );

        $opt = array(
            'connect_timeout'   => 5,
            'cookies'           => array( ),
            'follow_location'   => TRUE,
            'http_headers'      => array( ),
            'max_redirects'     => 5,
            'timeout'           => 15,
            'password'          => '',
            'post_fields'       => array( ),
            'user_agent'        => 'PHP curl_http_get',
            'username'          => '',
            'verify_ssl'        => TRUE
        );
        foreach ( $opt as $k => $v ) {
            if ( isset( $arg[$k] ) ) {
                $opt[$k] = $arg[$k];
            }
        }

        $curl_opt = array(
            CURLOPT_AUTOREFERER     => TRUE,
            CURLOPT_CONNECTTIMEOUT  => $opt['connect_timeout'],
            CURLOPT_CUSTOMREQUEST   => $req,
            CURLOPT_ENCODING        => '',
            CURLOPT_FOLLOWLOCATION  => $opt['follow_location'],
            CURLOPT_HEADER          => TRUE,
            CURLOPT_MAXREDIRS       => $opt['max_redirects'],
            CURLOPT_RETURNTRANSFER  => TRUE,
            CURLOPT_TIMEOUT         => $opt['timeout'],
            CURLOPT_USERAGENT       => $opt['user_agent'],
        );

        if (
            is_array( $opt['cookies'] )
            && count( $opt['cookies'] ) > 0
        ) {
            $curl_opt[CURLOPT_COOKIE] = implode( ';', $opt['cookies'] );
        }

        if ( !empty( $opt['username'] ) ) {
            $curl_opt[CURLOPT_USERPWD] = $opt['username'] . ':' . $opt['password'];
        }

        if (
            is_array( $opt['post_fields'] )
            && count( $opt['post_fields'] ) > 0
        ) {
            $curl_opt[CURLOPT_POST] = TRUE;
            $curl_opt[CURLOPT_POSTFIELDS] = $opt['post_fields'];
        }

        if ( $req == 'HEAD' ) {
            $curl_opt[CURLOPT_NOBODY] = TRUE;
        }

        if (
            is_array( $opt['http_headers'] )
            && count( $opt['http_headers'] ) > 0
        ) {
            $curl_opt[CURLOPT_HTTPHEADER] = $opt['http_headers'];
        }

        if ( $opt['verify_ssl'] === FALSE ) {
            $curl_opt[CURLOPT_SSL_VERIFYPEER] = FALSE;
            $curl_opt[CURLOPT_SSL_VERIFYHOST] = 0;
        }

        $curl = curl_init( $url );
        curl_setopt_array( $curl, $curl_opt );

        $body       = curl_exec( $curl );
        $err_no     = curl_errno( $curl );
        $err_msg    = curl_error( $curl );
        $info       = curl_getinfo( $curl );
        curl_close( $curl );

        $header_string = trim( substr( $body, 0, $info['header_size'] ) );
        $body = substr( $body, $info['header_size'] );

        if ( strpos( $header_string, "\r\n\r\n" ) !== FALSE ) {
            $header_string = end( explode( "\r\n\r\n", $header_string ) );
            $header_string = str_replace( "\r\n", "\n", $header_string );
        }

        foreach ( explode( "\n", $header_string ) as $line ) {
            list( $k, $v ) = explode( ':', $line, 2 );
            if ( empty( $v ) ) {
                continue;
            }

            if ( strtolower( $k ) == 'set-cookie' ) {
                $cookies[] = trim( $v );
            } else {
                $headers[$k] = trim( $v );
            }
        }

        return array(
            'body'      => $body,
            'err_no'    => $err_no,
            'err_msg'   => $err_msg,
            'headers'   => $headers,
            'cookies'   => $cookies,
            'info'      => $info
        );
    } // function curl_http_request
}

It’s a bit longer that then other PHP Helper functions :-) .

Related posts:

1. PHP Helpers: debug_log
2. PHP Helpers: make_slug
3. PHP Helpers: redirect_url

Of course you’ll want to search all of that data. Perhaps you want to lookup all of the sub-domains for example.com. That query might look like

SELECT * FROM table_name WHERE domain LIKE '%.example.com'

Having a wildcard ( % ) at the front of a LIKE comparison generally results in poor performance. Depending on the database you may find that either it can’t make use of an index on that column, or it must do a full index scan in order to find the right entry. To make better use of an index the wildcard should be at the end of the string, which we could do if we reverse the domain name ordering:

SELECT * FROM table_name WHERE domain LIKE 'com.example.%'

So that’s what we do. This of course brings up the question of how to correctly reverse the domain name parts. In PHP this can be done with a combination of explode(), array_reverse(), and implode():

$domain = 'joseph.example.com';
$reverse_domain = implode( '.', array_reverse( explode( '.', $domain ) ) );

That turns joseph.example.com into com.example.joseph. The reversed domain name gets stored in the database and that allows us to use the more efficient database query.

Related posts:

1. PHP Helpers: debug_log
2. The Easy Way To Get Recent Comments In WordPress
3. WordPress Pretty Permalinks with Nginx

if ( !function_exists( 'make_slug' ) ) {
    function make_slug( $str ) {
        $url_str = strtolower( trim( $str ) );

        $url_str = preg_replace( '/[\s_]+/', '-', $url_str );
        $url_str = preg_replace( '/-{2,}/', '-', $url_str );
        $url_str = preg_replace( '/[^a-z0-9-]/', '', $url_str );

        return $url_str;
    }
}

This takes a string and returns a slug that is more URL friendly. For example “Do This_Today -- Please” would become “do-this-today-please“.

The approach is pretty simple:

• lower case everything (line 3)
• replace space and underscore with dash (line 5)
• replace two or more dashes with a single dash (line 6)
• remove any other characters that aren’t a-z, 0-9 or a dash (line 7)

Related posts:

1. PHP Helpers: redirect_url
2. PHP Helpers: debug_log
3. PHP Tip: Spaces Are Not empty()

if ( !function_exists( 'redirect_url' ) ) {
    function redirect_url( $url, $status = 302 ) {
        header( "Location: {$url}", TRUE, $status );
        exit;
    }
}

A special case wrapper around the header function to do URL redirection. I specifically added the exit call inside the function so that redirect happens immediately. That way I don’t have a chance to forget about it later on :-)

Related posts:

1. PHP Helpers: esc_html
2. PHP Helpers: debug_log
3. PHP Helpers: curl_http_request