Pros and cons of assigning new variables vs. re-using exisiting ones

Question

First, I apologize if this just a coding style issue. I'm wondering about the pros and cons of assign a new variable for each property or function to just to re-assign an existing variable. This is assuming you don't need access to the variable beyond the scope.

Here's what I mean (noting that the names $var0,... are just for simplicity), Option#1:

$var0= array('hello', 'world');
$var1="hello world";
$var2=//some crazy large database query result
$var3=//some complicated function()

vs. Option#2:

$var0= array('hello', 'world');
$var0="hello world";
$var0=//some crazy large database query result
$var0=//some complicated function()

1. Does it depend on the memory size of the existing variable? I.e., is re-assigning memory more computationally expensive that assigning a new variable?
2. Is this always a scope issue, meaning you should use Option#2 only if you don't need each of the variable values outside the scope shown here?
3. Does it depend on what each variable value is? Does re-assigning to different data types have different costs associated with it?

Answer 1

Technically speaking, reusing variables would be (insignificantly) faster. It will make zero difference in measurable performance though.

While hardware gets cheaper and hours get more expensive, you should rather look to have maintainable code. This will save yourself headaches and your company hard dollars in the long run.

Only optimize where enough performance gain can be made to offset the amount of work (money) you are putting into it.

Nowadays of clouds and server clusters, a-bit-less-optimized code will most likely not make for a slower project in the end. It is more probable that your project will run just as fast, but will take a few more cpu cycles, and therefore cost you a little bit more money to your hosting provider. This minor added cost though, will most likely not weigh up to hours of optimizing for performance gain. Unless, ofcourse, you're asking this because you're developing for Amazon. (and even at places like Amazon, with millions and millions of hits per day, reusing variables will not result any noticable performance gain)

To get back to your question; I believe you should only reuse a variable when it will hold updated content of the original state. But in general, that doesn't happen too much.

I think in the following situation, reusing the $content var is the logical choice to make

function getContent()
{
    $cacheId = 'someUniqueCacheIdSoItDoesNotTriggerANotice';
    $content = someCacheLoadingCall( $cacheId );

    if (null === $content) {
        $content = someContentGeneratingFunction();

        someCacheSavingCall( $cacheId, $content);
    }

    return $content;
}

Descriptive code

Also, please be kind to your future self to always use descriptive names for your variables. You will thank yourself for it. When you then make the pact with yourself to never reuse variables unless it logically makes sense, you've made another step towards maintainable code.

Imagine, that in 6 months from now, after you've done another big project - or a more small projects - you get a call from an important client that there is a bug in the old project. Holy !@#! Gotta fix that right now! You open up and see functions like this everywhere;

function gC()
{
    $cI = 'someUniqueCacheIdSoItDoesNotTriggerANotice';
    $c  = sclc( $cI );

    if (null === $c) {
        $c = scg_f();
        scsc( $cI, $c);
    }

    return $c;
}

Much better to use descriptive variable and function names and to get a code editor with good code completion so you're still coding as fast as you want. Right now, I would recommend Aptana Studio or Zend Studio, Zend has a little bit better code completion, but Aptana has proven to be more stable.

PS. I don't know your level of programming, sorry if I babbled on too far. If not relevant for you, I hope to have helped someone else who might read this :)

Answer 2

Personally I would say you should never ever reassign a variable to contain different stuff. This makes it really hard to debug. If you are worried about memory consumption you can always unset() variables.

Also note that you should never ever have variables names $var#. Your variablenames should describe what it holds.

In the end of the day it's all about minimizing the number of WTFs inyour code. And option two is one big WTF.

Does it depend on the memory size of the existing variable? I.e., is re-assigning memory more computationally expensive that assigning a new variable?

It's about limiting the number of WTFs for both you and other people (re)viewing your code.

Is this always a scope issue, meaning you should use Option#2 only if you don't need each of the variable values outside the scope shown here?

Well if it is in a totally other scope it is fine if you use the same name multiple names. As long as it is clear what the variabel contains, e.g.:

// perfectly fine to use the same name again. I would go as far as to say this is prefered.
function doSomethingWithText($articleText)
{
    // do something
}

$articleText = 'Some text of some article';
doSomethingWithText($articleText);

Does it depend on what each variable value is? Does re-assigning to different data types have different costs associated with it?

Not a matter of cost, but a matter of maintainability. Which is often way more important.