Why return new static? (PHP)

Question

Why some developers create one method that returns new static? What is the reason to have a method that returns new static? I am not asking what is the difference between static and self, or what static & self mean. For example, here is one simple class:

<?php

class Expression
{
    public static function make()
    {
        return new static;
    }


    public function find($value)
    {
        return '/' . $value .'/';
    }

    public function then($value)  
    {
        return $this->find($value);
    }

    public function hi($value)  
    {
        return "hi";
    }

}

As you can see, there is a static method make() which returns new static. Then, some developers call other methods like this:

$regex = Expression::make()->find('www');

What is the purpose of this? I see that here we don't use new Expression syntax, and if that's the point - then why not make all methods static? What is the difference, what is the reason to have that one method that returns new static (while other methods are not static)?

Michell

Possible duplicate of what means new static? – Ottar

The answer to New self vs. new static explains the difference clearly. – Littles

@Ankur Tiwari I am not asking what is the difference between static & self, or what static & self do. – Michell

@jeyoung My question is not about the difference between New self vs. new static... – Michell

@Michell It looked like you did not understand the purpose of new static(), but if you do... It's for re-use. You can define the static make method in a single base class and you will have the same functionality from derived classes. – Littles

@jeyoung deceze gave a nice explanation, it's basically an alternative constructor... Thanks – Michell

Answer 1

new static instantiates a new object from the current class, and works with late static bindings (instantiates the subclass if the class was subclassed, I expect you understand that).

Having a static method on a class which returns a new instance of same is an alternative constructor. Meaning, typically your constructor is public function __construct, and typically it requires a certain bunch of parameters:

class Foo {
    public function __construct(BarInterface $bar, array $baz = []) { ... }
}

Having an alternative constructor allows you to provide different defaults, or convenience shortcuts to instantiate this class without having to supply those specific arguments and/or for being able to provide different arguments which the alternative constructor will convert to the canonical ones:

class Foo {

    public function __construct(BarInterface $bar, array $baz = []) { ... }

    public static function fromBarString($bar) {
        return new static(new Bar($bar));
    }

    public static function getDefault() {
        return new static(new Bar('baz'), [42]);
    }

}

Now, even though your canonical constructor requires a bunch of complex arguments, you can create a default instance of your class, which will probably be fine for most uses, simply with Foo::getDefault().

The canonical example in PHP for this is DateTime and DateTime::createFromFormat.

In your concrete example the alternative constructor doesn't actually do anything, so it's rather superfluous, but I expect that's because it's an incomplete example. If there's indeed an alternative constructor which does nothing other than new static, it's probably just meant as convenience syntax over (new Foo)->, which I find questionable.

Bibliogony

Now I understand the purpose of it, thank you very much! – Michell

I guess that the constructor is really empty and this is made just for sugar. Probably that the developer prefer to call new object this way in order to concact them. So instead of write: $search = (new Expression)->find("wow");, he can just wrote $search = Expression::make()->find("wow"). Of course it's the same. – Foretaste

Answer 2

Complete answer here

TLDR
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(A::get_self()); // A
echo get_class(A::get_static()); // A
echo get_class(B::get_self());  // A
echo get_class(B::get_static()); // B

Campanulaceous

Not really an answer to the question, but still useful, clearly shows the difference between self and static. – Civilized

@sergeyshuchkin great Example... with little description more helpful it will be – Ardennes

It seems this answer was shamelessly copied without attribution and then incorrectly modified from this other more complete answer by @BoltClock https://mcmap.net/q/64326/-new-self-vs-new-static The answer was then edited for correctness - back to the original. I tried to edit in an attribution and the more complete explanation, but the edit queue is full. – Obligatory