Optimize file include inside functions in PHP

You could use a static variable in the function to hold your values:

function getString($arrayName, $strValue){
static $string_arrays = array();
if (empty($string_arrays)) {
    include('stringArrays.php');
    $string_arrays = array_diff_key(get_defined_vars(), array(
        'string_arrays' => true,
        'arrayName' => true,
        'strValue' => true,
    ));
}
return $string_arrays[$arrayName][$strValue];

}

Should only include the file once.

You could always add another parameter, perhaps a boolean, to tell the function whether or not to include it.

function getString(arrayName, strValue, includeFile)
{ 
    if (includeFile)
    {
        inclue('stringArrays.php');
    }

    return $$arrayName[strValue]; 
}

You can try globalizing what's in stringArrays.php so you can check to see if that global variable is already set before including the file. Hard to tell without seeing what structure is in stringArrays.php.

If your function does nothing more than include a file you should be first evaluating whether that function should be called in the first place or make the function determine if an include is required. Basically don't blindly include a file if you truly don't need it included. include_once will incur a performance hit.

Install APC, eAccelerator, XCache or any other code accelerator so PHP doesn't need to retrieve the include file from disk every time it's called. Code accelerators save the file in shared memory. That will improve performance significantly.

Is there anything preventing you from wrapping your current "bunch" of arrays in an array, then passing that wrapper array into the function by reference? You can then do a single require/include outside of the function. Alternatively, you can wrap both the set of arrays and the function inside an object, again bringing you down to a single require/include.

If stringArrays.php is simply a collection of arrays, what about creating a stringHandler singleton that includes stringArrays.php within the constructor and maps the each array to a class property, then a simple method to get whichever you want from that class. Then your getString() function simply references a getter method in the stringHandler.

stringArrays.php

<?php

$abc = array('def' => 'Hello',
             'ghi' => ' '
            );

$jkl = array('mno' => 'World',
             'pqr' => '.'
            );

?>

stringHandler.php

<?php

class stringHandler
{
    private static $instance;

    private function __construct()
    {
        include('stringArrays.php');
        foreach(get_defined_vars() as $key => $val) {
            $this->{$key} = $val;
        }
    }

    public static function singleton()
    {
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        }

        return self::$instance;
    }

    public function getStringFromArray($arrayName, $strValue)
    {
        return $this->{$arrayName}[$strValue];
    }

}

function getString($arrayName, $strValue){
    return stringHandler::singleton()->getStringFromArray($arrayName, $strValue);
}


echo getString('abc','def');
echo getString('abc','ghi');
echo getString('jkl','mno');

?>

Kludgy, but shouldn't be a big performance overhead.