Question

I ask this question because i learned that in programming and designing, you must have a good reason for decisions. I am php learner and i am at a crossroad here, i am using simple incrementation to try to get what im asking across. I am certainly not here to start a debate about the pros/cons of referencing, but when it comes to php, which is the better programming practice:

function increment(&$param) {
      ++$param;
}

vs.

function increment($param){
 return ++$param;
}

$param = increment($param);

Answer 1

First, references are not pointers.

I tried the code given by @John in his answer, but I got strange results. It turns out microtime() returns a string. Arithmetic is unreliable and I even got negative results on some runs. One should use microtime(true) to get the value as a float.

I added another test of no function call, just incrementing the variable:

<?php

$param = 1;

$start = microtime(true);

for($i = 1; $i <= 1000000; $i++) {
    $param++;
}

$end = microtime(true);

echo "increment: " . ($end - $start) . "\n";

The results on my machine, Macbook 2.4GHz running PHP 5.3.2.

• function call with pass by reference: 2.14 sec.
• function call with pass by value: 2.26 sec.
• no function call, just bare increment: 0.42 sec.

So there seems to be a 5.3% performance advantage to passing by reference, but there is a 81% performance advantage to avoiding the function call completely.

I guess the example of incrementing an integer is arbitrary, and the OP is really asking about the general advantage of passing by reference. But I’m just offering this example to demonstrate that the function call alone incurs far more overhead than the method of passing parameters.

So if you’re trying to decide how to micro-optimize parameter passing, you’re being penny wise and pound foolish.

There are also other reasons why you should avoid references. Though they can simplify several algorithms, especially when you are manipulating two or more data structures that must have the same underlying data:

• They make functions have side-effects. You should, in general, avoid functions with side-effects, as they make the program more unpredictable (as in “OK, how this did this value get here? did any of the functions modify its parameters?”)
• They cause bugs. If you make a variable a reference, you must remember to unset it before assigning it a value, unless you want to change the underlying value of the reference set. This happens frequently after you run a foreach loop by reference and then re-use the loop variable.