New self vs. new static
I am converting a PHP 5.3 library to work on PHP 5.2. The main thing standing in my way is the use of late static binding like return new static($options); , if I convert this to return new self($options) will I get the same results?
What is the difference between new self and new static?
will I get the same results?
Not really. I don't know of a workaround for PHP 5.2, though.
What is the difference between new self and new static?
self refers to the same class in which the new keyword is actually written.
static, in PHP 5.3's late static bindings, refers to whatever class in the hierarchy you called the method on.
In the following example, B inherits both methods from A. The self invocation is bound to A because it's defined in A's implementation of the first method, whereas static is bound to the called class (also see get_called_class()).
class A {
public static function get_self() {
return new self();
}
public static function get_static() {
return new static();
}
}
class B extends A {}
echo get_class(B::get_self()); // A
echo get_class(B::get_static()); // B
echo get_class(A::get_self()); // A
echo get_class(A::get_static()); // A
If the method of this code is not static, you can get a work-around in 5.2 by using get_class($this).
class A {
public function create1() {
$class = get_class($this);
return new $class();
}
public function create2() {
return new static();
}
}
class B extends A {
}
$b = new B();
var_dump(get_class($b->create1()), get_class($b->create2()));
The results:
string(1) "B"
string(1) "B"
clone, but just by re-creating and setting the properties. $copy = new static(); $copy->set($this->get()); return $copy;
self:: or static:: is going to affect whether the base class's or subclass's version of that static method is used. In the absence of some reason to think that such a situation occurring inherently indicates bad practice (and I don't see any reason why this should be so), the choice between self:: and static:: is just as relevant within non-static methods as it is in static methods. Have I misunderstood your comment, or is one us simply wrong?
In addition to others' answers :
static:: will be computed using runtime information.
That means you can't use static:: in a class property because properties values :
Must be able to be evaluated at compile time and must not depend on run-time information.
class Foo {
public $name = static::class;
}
$Foo = new Foo;
echo $Foo->name; // Fatal error
Using self::
class Foo {
public $name = self::class;
}
$Foo = new Foo;
echo $Foo->name; // Foo
Please note that the Fatal error comment in the code i made doesn't indicate where the error happened, the error happened earlier before the object was instantiated as @Grapestain mentioned in the comments
public $name = static::class;, not on line 7, as suggested by the example. The error says: "static::class cannot be used for compile-time class name resolution" which indicates the problem is not where you try to access the $name field, but far before, at the compilation of the PHP class. Line 7 (or 6) will not be reached in the first example.
Follow WeChat
Success story sharing
Want to stay one step ahead of the latest teleworks?
Subscribe Now
HuntsBot,a one-stop outsourcing task, remote job, product ideas sharing and subscription platform, which supports DingTalk, Lark, WeCom, Email and Telegram robot subscription. The platform will push outsourcing task requirements, remote work opportunities, product ideas to every subscribed user with timely, stable and reliable.
get_called_class(), which is effectively the same as__CLASS__, but LSB compatible.selfwould return itself, andstaticwould return something that cannot be overridden... But lo and behold it's the opposite. I never cease to be impressed by PHP's naming, conventions, and overall style. -_-