Question

I was wondering when does PHP free the memory which is used for a variables

for example

function foo(){
  $foo = 'data';
  return $foo;  // <- is the memory space for `$foo` emptied at this point?
}

is it slower than:

function foo(){
  return 'data'; 
}

?

Answer 1

Well, let’s find out!

<?php
$checkpoints = array( 'start' => memory_get_usage() );

$checkpoints['before defining demo1'] = memory_get_usage();
function demo1() { $foo = 'data'; return $foo; }
$checkpoints['after defining demo1'] = memory_get_usage();

$checkpoints['before defining demo2'] = memory_get_usage();
function demo2() { return 'data'; }
$checkpoints['after defining demo2'] = memory_get_usage();


$checkpoints['before calling demo1'] = memory_get_usage();
demo1();
$checkpoints['after calling demo1'] = memory_get_usage();

$checkpoints['before calling demo2'] = memory_get_usage();
demo2();
$checkpoints['after calling demo2'] = memory_get_usage();

$checkpoints['before calling demo1 with storage'] = memory_get_usage();
$storage1 = demo1();
$checkpoints['after calling demo1 with storage'] = memory_get_usage();

$checkpoints['before calling demo2 with storage'] = memory_get_usage();
$storage2 = demo2();
$checkpoints['after calling demo2 with storage'] = memory_get_usage();

echo '<pre>';
print_r($checkpoints);

$last_key = 'start';
foreach($checkpoints as $key => $value) {
    echo "{$key} - {$last_key} = ", ($value - $checkpoints[$last_key]), "\n";
    $last_key = $key;
}

Under PHP 5.3.6, my output is:

Array
(
    [start] => 321920
    [before defining demo1] => 322188
    [after defining demo1] => 322788
    [before defining demo2] => 322880
    [after defining demo2] => 323188
    [before calling demo1] => 323280
    [after calling demo1] => 323368
    [before calling demo2] => 323464
    [after calling demo2] => 323552
    [before calling demo1 with storage] => 323692
    [after calling demo1 with storage] => 323896
    [before calling demo2 with storage] => 324000
    [after calling demo2 with storage] => 324204
)

and then

start - start = 0
before defining demo1 - start = 268
after defining demo1 - before defining demo1 = 600
before defining demo2 - after defining demo1 = 92
after defining demo2 - before defining demo2 = 308
before calling demo1 - after defining demo2 = 92
after calling demo1 - before calling demo1 = 88
before calling demo2 - after calling demo1 = 96
after calling demo2 - before calling demo2 = 88
before calling demo1 with storage - after calling demo2 = 140
after calling demo1 with storage - before calling demo1 with storage = 204
before calling demo2 with storage - after calling demo1 with storage = 104
after calling demo2 with storage - before calling demo2 with storage = 204

It’s very likely that the memory increase during the initial calls to demo1 and demo2 that discard the output is due to the creation of variables to store memory use.

However, the bottom line here is the two storage examples, where both returning data directly and assigning it to a variable before returning it resulted in the same exact memory use for the given data.

Conclusion: PHP seems smart enough in this simple test to not needlessly copy string variables — though do keep an eye on the memory use difference between the two functions. Just declaring the demo1 function took more memory that declaring demo2. A few hundred bytes, really.