SiteCrafting, Inc.

Web apps become notoriously slow when running database queries. Often times we find ourselves writing a useful look up as a function, and then forget that it requires a query each time. This is where caching comes in. And PHP has a really clean way to do it.

The Problem

A common problem in web app development is the relative slowness of database queries. In an effort to make my code more efficient, I began searching for ways to cache the results so I wouldn't have so much latency. There are several places where this would be helpful. Take the example of looking up a user by ID. The function below is a dirt simple lookup. (Note: $id should be sanitized before use in a database query and is left out for simplification)

function getUser($id) {
    $sql = "SELECT * FROM users WHERE id = $id";
    $res = mysql_query($sql);
    return $res ? mysql_fetch_assoc($sql) : false;
}

This function is quite simple and works great for a one time lookup. But if you need to look up the user a second time, why waste time with a whole new query? We should create a caching method.

Global Variables

Originally, I used the $GLOBALS variable to store the results. I typically would use a string with a really long name to prevent functions from writing over each other. But $GLOBALS is slow and a memory hog, and there is the potential to be overwritten by other functions. This makes it very dangerous to use.

$GLOBALS['GET-USER-CACHE'] = array();
function getUser($id) {
    $user =& $GLOBALS['GET-USER-CACHE'][$id];
    if(!$user) {
        $sql = "SELECT * FROM users WHERE id = $id";
        $res = mysql_query($sql);
        $user = $res ? mysql_fetch_assoc($res) : false;
    }
    return $user;
}

You can see that there are many downfalls to this. First, you create a global variable, whether you use it or not. That will slow down all your code. Second, the long string must be the same or it will break your code (or cause two global variables, depending on your config). And third, if any other function uses that variable, it could ruin your code.

Static Keyword

Then I discovered the static keyword can be used from within a function. The effects of static variables within classes are well known, but what was unknown to me was how it would effect a function. After some time in my sandbox I discovered it could be used like this:

function getUser($id) {
    static $users = array();
    $user =& $users[$id];
    if(!$user) {
        $sql = "SELECT * FROM users WHERE id = $id";
        $res = mysql_query($sql);
        $user = $res ? mysql_fetch_assoc($res) : false;
    }
    return $user;
}

It turns out the variable $users is kept between calls of getUser(). The static nature of this variable means that it can be used to cache the results of the database query without any external access. It makes your close look cleaner. And another function can't come in and break it. No memory hog, no global variables, no problem.

Other Uses

Because static variables hold state we can use it for auto incrementing. In the example below, we are looking to alternate between even and odd. In the first example, you would have setup $i = 0, then call alternateRows($i++) each time. This means $i would be managed outside the function. In the second example, there is no need to know the internals of how it determines even or odd.

function alternateRows($i) {
    return $i%2 ? 'odd' : 'even';
}

V.S.

function alternateRows() {
    static $i = 0;
    return $i++%2 ? 'odd' : 'even';
}

Again, the function becomes protected from outside code. Since $i is commonly used in loops, a mistaken, duplicate variable name could break your code. But now the variable is hidden from view and the results become predictable.

Conclusion

Static is a keyword that can be applied to a variable (both in PHP 4 and 5) within a function to give in state between function calls. It has a great many uses, such as object caching or auto incrementing. This becomes particularly handy when writing libraries to hide the complexities of optimizations. What other uses can you think of for static variables in functions? Leave us a note in the comments.