passing by reference

lajkonik86

when should you pass a variable by reference and what is the performance loss of not doing so?

thanks

halojoy

Yes, I like to know this myself.

I cant remember one time I needed to pass by reference in my scripts.
And I have been writing php code for 4-5 years.
What am I missing?

😉

mpb001

Passing simple types by reference can lead to confusion if the code being called is not in direct line of sight.

eg.

function test( &$a , &$b , $c )
{
   $a = $a*c;
   $b = $b*c;
}

$d = 1;
$e = 2;
$f = 3;
test( $d , $e , $f );

Unless you call the doc comment up when calling there is now way of knowing what is being affected. Could be any combination of $d, $e, $f. This confusion can lead to errors. If you are doing a referential change on simple types then make it clear in the function/method name.

eg.

function RefRecalculateXY( &$x , &$y , $c )
{
   $x = $x*c;
   $y = $y*c;
}

$width = 1;
$height = 2;
$multiplier = 3;
RefRecalculateXY( $width , $height , $multiplier );

So it is clear when looking at the code that you are breaking out of the norm and doing something different. Referencial recalculation is useful when dealing with large pieces of data to conserve memory.

Objects should be passed by reference manually in php4 so migration to 5 will ensure behavioural consistentancy.

"When should references be used?
When you're passing on large text, array or object structures to functions or passing data trough nested function calls. You should also perform benchmarking of your PHP code to find out places that need references, often using references will reduce execution time significantly.

When should references not be used?
When creating functions which usually is fed with constants values. PHP cannot create references to unassigned data, except for new object instances. For instance consider this example"

http://zez.org/article/articleprint/77/

mpb001

I also couldn't find anything about whether php passes by shallow copy. If it does then a refence to the memory location is used until the values changes, then a deep copy is made.

laserlight

when should you pass a variable by reference and what is the performance loss of not doing so?

Use pass by reference when you want a function to operate on its arguments such that the changes are visible to the caller. For example, a swap function would take its arguments by reference since the caller wants the arguments to be swapped. Merely swapping them internally would not be useful. Another example is when you want to return two values, typically of different types. Instead of using an array, you might require the caller to pass an argument by reference, and then assign one of the return values to that reference.

I think that there is negligible difference between passing variables of primitive types by value versus by reference. In PHP5, objects are passed as references, so you do not need to use pass by reference for performance reasons. You still have to use pass by reference if you want the objects themselves to be modified with respect to the caller, otherwise you will only be able to change the state of the object (if the object provides an interface with mutators), not the object itself.

Unless you call the doc comment up when calling there is now way of knowing what is being affected. Could be any combination of $d, $e, $f.

Not quite. The user of the function has no way of knowing what will be modified merely by looking at the function signature, but can tell what may be modified just by looking at the function signature. Effectively, the pass by reference mechanism is a contract that states that the argument passed may be modified with changes visible to the caller. In your example, only $d and $e are expected to be modifiable with respect to the caller, since only the parameters $a and $b use pass by reference.

This confusion can lead to errors. If you are doing a referential change on simple types then make it clear in the function/method name.

I think that one should always use a descriptive function name, but having the "Ref" prefix is unnecessary. The user can tell just by looking at the parameter list that the function may modify its arguments such that the changes are visible to the caller. Your example is something of a straw man since "test" is totally undescriptive, whereas "RecalculateXY" might be sufficient, especially since "recalculate" is a good hint.

NogDog

My general rule of thumb in order to keep my code as easily maintainable and reusable as possible is: "Don't use global variables within a function when you can use function parameters that are passed by reference instead, and don't use function parameters that are passed by reference when you can return a result instead." Therefore, I basically never use the global variables within a function, and almost never use passed by reference parameters.

mpb001

"Not quite. The user of the function has no way of knowing what will be modified merely by looking at the function signature, but can tell what may be modified just by looking at the function signature. Effectively, the pass by reference mechanism is a contract that states that the argument passed may be modified with changes visible to the caller. In your example, only $d and $e are expected to be modifiable with respect to the caller, since only the parameters $a and $b use pass by reference.
"

Your swap function argument is a better use/naming hint than my one. My Ref one was I couldn't think of one better at the time as I never do pass by reference on simple types. Unless you have the code in front of you or you use intellisense to bring the function params up how do you know only $d and $s are modifiable?

if I see an obtuse function call that doesn't set a value to a variable I assume it is junk that needs to be cleaned. I then stop whatever I am doing and check, thus breaking my flow needlessly. Swap is a simple thing but I quite happily assume someone somewhere is making every value pass by reference due to some crazy optimization scheme 🙂

If something is passed by reference even if the value is the same at the finish it should be assumed that the original value has been changed to the correct one in the current code line.

ie
$i = 1;
settype( $i , "integer" );

It is what is expected when you see something is pass by reference. Or you could write a comment like

"value $d goes fubar on wednesday at 3 pm if user is in Sweden and it is raining. In this case you cannot trust the new set value and have to do somethign else with it"

laserlight

Unless you have the code in front of you or you use intellisense to bring the function params up how do you know only $d and $s are modifiable?

You dont, unless you already know the function signature from memory (or have the documentation at hand, but that is the same as using intellisense). On the other hand, if you are new to using the function (or have forgotten its signature), then you have to look it up anyway.

mpb001

It is not about using it, but coming across it later and having to second guess it is the damage as it's a minor goose chase. Might not seem like much but it's one more thing on the big pile of other things that can be avoided. Save enough of these little warts and things become a lot cleaner.

I am just using a method I did do once that wasn't clear and made me second guess when I was viewing the source later. As it made me second guess while I was scanning with the scroll wheel I rewrote it as it wasn't self documenting and didn't follow the path of expectance.

Swap is self documenting but there are so few cases when it is a benefit I always assume simple types are pass by value. I remember the php native ones but never write my own.

jazz_snob

My general take is don't pass by reference. However, w/ objects I do pass by reference. How do I decide? I write tests. If I have to pass by reference to make the test pass, then that is what I'll do (eg: an object that is a database connection, or a Registry class, which I despise but have to use occasionally).
http://phpfunk.com/software/Registry.phps

Of course you can go straight to the source: http://www.php.net/manual/en/language.references.php