Perché restituire una nuova statica? (PHP)

Question

Perché alcune persone creano un metodo che restituisce una nuova statica invece di rendere statici tutti i metodi? Qual è la ragione per avere quel metodo che restituisce statico nuovo? Non mi sto chiedendo quale sia la differenza tra statico e autonomo, o cosa sia il significato statico di &. Per esempio, qui è una semplice classe:

<?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"; 
    } 

} 

Come potete vedere, c'è un statica metodo make() che restituiscenuova statica. Quindi, alcune persone chiamano altri metodi come questo:

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

Qual è lo scopo? Vedo che non usiamo la nuova sintassi di Expressione, se questo è il punto, perché non hanno reso tutti i metodi, ad esempio, statici? Qual è la differenza, qual è la ragione per avere quel metodo che restituisce new static?

Answer 1

new static crea un'istanza di un nuovo oggetto dalla classe corrente e funziona con collegamenti statici ritardati (crea un'istanza della sottoclasse se la classe è stata sottoclasse, mi aspetto che tu lo capisca).

Avere un metodo static in una classe che restituisce una nuova istanza della stessa è un costruttore alternativo. Che significa, in genere il vostro costruttore è public function __construct, e in genere richiede un certo gruppo di parametri:

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

Avere un costruttore di un'alternativa permette di fornire diverse impostazioni predefinite, o scorciatoie convenienza di creare un'istanza di questa classe senza dover fornire quelle argomenti specifici e/o per essere in grado di fornire diversi argomenti che il costruttore alternativa verrà convertito a quelli canonici:

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]); 
    } 

} 

Ora, anche se il costruttore canonico richiede un mucchio di argomenti complessi, puoi creare un'istanza predefinita della tua classe, che probabilmente andrà bene per la maggior parte degli usi, semplicemente con Foo::getDefault().

L'esempio canonico in PHP per questo è DateTime e DateTime::createFromFormat.

Nel tuo esempio concreto, il costruttore alternativo non fa realmente nulla, quindi è piuttosto superfluo, ma mi aspetto che sia un esempio incompleto. Se esiste effettivamente un costruttore alternativo che non fa altro che new static, probabilmente è inteso semplicemente come sintassi di comodità su (new Foo)->, che trovo discutibile.

Answer 2

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