PHP Optimizing a Very Long Switch Case Statement

Question

Please have a look to below code

function GetAreaName($AreaCode)
{
  switch ($AreaCode) 
  {
    case 201: return 'New Jersey';
    case 202: return 'Washington';
    // this goes on till
    case 999: return '';
  }
}

Let's say if the AreaCode is 998 then it would have to go through so many cases! How could we optimize this function? (No using databases.)

I'm thinking to build an array and do a binary search over it? But this means every time the function is called the array will be rebuild? How do we build the array once, cache it and re-use every time this function is called?

Answer 1

Why not just use a hash table?

class Area {

private $areaCodes = array(
            201 => 'New Jersey',
            202 => 'Washington',
            // this goes on till
            999 => '';
        );

    function getStateByAreaCode ($areaCode) {

        if (array_key_exists($areaCode, $this->areaCodes)) {
           return $this->areaCodes[$areaCode];
        } else {
           return false;
        }

    }
}

Call it like this:

$area = new Area();
$city = $area->getStateByAreaCode(303);

Just save your class in a file and include it when you need it.

You Asked How to Prevent the Array From Being Created Every Request: By putting this in a class you at least keep it clean. It technically still gets created each request, but unless your array is enormous (WAY bigger than the area codes in the U.S.) it shouldn't pose a performance issue. If you are worried about building the array every time you have a request, then take a look at a code optimizer like APC or the Zend Optimizer. This essentially takes the byte code that PHP generates at run time and caches it.

Answer 2

Sounds like you should just store it in your database.

But if you can't do that, either abstract it into a config file of some kind and store it in some kind of persisted object, or just use a static variable:

function foo($key) {
    static $cache = array(1 => 'abc', 2 => 'def', 3 => 'ghi');
    if (array_key_exists($key, $cache)) {
        return $cache[$key];
    } else {
        //Somehow signal an error (throw an exception, return boolean false, or something)
    }
}

In the above, $cache would only exist once. (If you knew that the values would never be null, you could use isset instead of array_key_exists.)

This isn't very flexible though since changing the data requires you to edit your code. You typically want your data and your code to be decoupled.

That could mean storing it in some kind of file (json, xml, php, whatever), and loading it into some kind of structure that you only create once. You would then pass that object or array around wherever it was needed. (Or, if you wanted to be hacky, you could use a static class. I suggest against this though.)