PHP链接方法和CLONE

Question

I am curious about something.

A respected developer suggested using "return clone $this" instead of simply using "return $this" and he ended up leaving the open source project for a while and never answered my "why?" question so I am curious if there is ANY benefit to it.

So as an example in a normal chainable method we might have something like this:

function setProperty($arg) {
    this->property = $arg;
    return $this;
 }

His example was more like this:

function setProperty($arg) {
     this->property = $arg;
     return clone $this;
}

My impression was that he was wrong for this because all it would do is make a copy of the object at each step that would be inaccessible.

So if we used his method and say had something like this...

class foo {
     public $value;
     function setA($arg) {
        $this->value = $arg;
        return clone $this;
     }

     function setB($arg) {
         $this->value = $arg;
         return clone $this;
     }

     function setB($arg) {
         $this->value = $arg;
         return clone $this;
     }

     function print() {
         print $this->value;
     }
}

And we had a line like this($obj is an instance of class foo):

$obj->setA('a')->setB('b')->setC('c')->print();

This should end up printing c regardless if done with the clone $this or just plain $this.

However...

$obj->setA('a')->setB('b')->setC('c');
$obj->print();

should print a since only the first step would change the original object. The second step would change a cloned object from the first step and the third step would be changing the object passed to it from the second step.

but then again if you went with:

$obj = $obj->setA('a')->setB('b')->setC('c');
$obj->print();

I would believe this would print c in either method as well.

If we had declared $value as static originally then all of these different variations should print a c.

If I understand how this stuff all works I believe I am correct and see absolutely no benefit in using "return clone $this" as opposed to "return $this". Or am I missing something or am I totally wrong in my above assumptions?

Thanks!

Rodney

Answer 1

I don't think you'd ever want to modify the state of the current object and then return a clone. Instead, you'd clone then modify. Example,

class Foo {
     private $value;

     function setValue($arg) {
        $clone = clone $this;
        $clone->value = $arg;
        return $clone;
     }

     function printValue() {
         echo $this->value.PHP_EOL;
     }
}

In this way your object becomes immutable.

Example usage:

$a = (new Foo)->setValue('a');
$b = $a->setValue('b');

$a->printValue();
$b->printValue();

This will print

a
b

This way $a isn't messed with when you "modify" $b .