OOP, static variables in methods.

[bokehman]

<?php

class myClass
{
    function myMethod($in = null)
    {
        static $i = 0;
        !$in or $i++;
        echo $i;
    }
}

$class = new myClass();
$class->myMethod();
$class->myMethod(1);

$class2 = new myClass();
$class2->myMethod();
$class2->myMethod(1);

$class3 = new myClass();
$class3->myMethod();
$class3->myMethod(1);

?>

That prints:

011223

Is that the expected bahaviour or a bug? I thought each new object was unique and nothing going on in another object should affect it but this shows that is not the case.

Any thoughts on this?

[stadskle]

This is expected behaviour.

Static variable is tied to the class not the object. You do not get a new instance of the static variable when creating a new object, you are still changing the same value.

[stereofrog]

A method belongs to a class, i.e. all instances of the class share the same "instance" of the method. Since static variables are part of the method, they are also shared between all instances.

[kyberfabrikken]

This does what you expect:

<?php

class myClass
{
    var $i = 0;
    function myMethod($in = null)
    {
        !$in or $this->i++;
        echo $this->i;
    }
}

$object = new myClass();
$object->myMethod();
$object->myMethod(1);

$object2 = new myClass();
$object2->myMethod();
$object2->myMethod(1);

$object3 = new myClass();
$object3->myMethod();
$object3->myMethod(1);
?>

[bokehman]

This does what you expect:

Well that's what I had originally but I want to switch due to the big speed advantage of the static variable.

[kyberfabrikken]

Well that's what I had originally but I want to switch due to the big speed advantage of the static variable.

Who told you that non-sense?

[bokehman]

Who told you that non-sense?

Just for you, here is some scientific proof: http://bokehman.com/StaticDynamicTest/

[dreamscape]

Just for you, here is some scientific proof: http://bokehman.com/StaticDynamicTest/

The biggest thing you are testing in that test is actually memory usage.

Here is a far more sensible test for what you're trying to test:

<?php

class Tester {

    public $var = 0;

    public function staticMethod() {
        static $var = 0;
        return ++$var;
    }

    public function dynamicMethod() {
        return ++$this->var;
    }

}


$n = 100;

$tester = new Tester();

$time = microtime(true);
for ($x=0; $x<$n; $x++) {
    $tester->dynamicMethod();
}
echo "DYNAMIC: " . number_format($dynamic = (microtime(true) - $time), 5) . "\n";


$time = microtime(true);
for ($x=0; $x<$n; $x++) {
    $tester->staticMethod();
}
echo "STATIC:  " . number_format($static = (microtime(true) - $time), 5) . "\n";


echo 'RATIO:   ' . number_format($dynamic / $static, 5) . "\n\n";

When $n = 100:

$ php ./test-static.php
DYNAMIC: 0.00152
STATIC:  0.00139
RATIO:   1.08740

When $n = 1000:

$ php ./test-static.php
DYNAMIC: 0.01447
STATIC:  0.01882
RATIO:   0.76904

When $n = 5000:

$ php ./test-static.php
DYNAMIC: 0.07730
STATIC:  0.12661
RATIO:   0.61050

[kyberfabrikken]

Just for you, here is some scientific proof: http://bokehman.com/StaticDynamicTest/

A static variable is basically a variant of a global variable. This code:

function foo() {
    static $foo = 42;
    echo $foo;
} 

Is another way of expressing this:

$foo = 42;
function foo() {
    global $foo;
    echo $foo;
} 

The only difference being that $foo is only accessible from within the function foo() in the first case, while in the second case, $foo can be accessed from anywhere.

The reason for the difference in your example between StaticFunction and DynamicFunction is that in the first case, you're only creating one variable, while in the second example, you're creating 100 variables.
The first case is going to be significantly faster than the second, but that's because they are doing two different things. You can't compare them to each other.

[bokehman]

Here is a far more sensible test for what you're trying to test

You are moving the goal posts. I am using the variable as a reference while you are writing to it. Also my variable is a real variable and as my code demonstrates having it static is definitely the way to go otherwise every time I use the function the variable needs to be loaded and unloaded from the RAM.

[bokehman]

You can't compare them to each other.

The mechanism is not relevant to me only the outcome. What is fact is adding the word "static" to my function speeds it up 2000 times.

[kyberfabrikken]

I thought each new object was unique and nothing going on in another object should affect it (...)

If you declare a variable static, then there is only one variable for the entire program. If you use a member variable ($this->foo), you get one variable per object.

The mechanism is not relevant to me only the outcome.

Then why did you ask?

[bokehman]

Then why did you ask?

I didn't ask about the mechanism, I asked if it was a bug. You then went on to (wrongly) tell me I was talking nonsense when I pointed out there was a speed advantage to using a static variable in read context.