¿Por qué devolver nueva estática?(PHP)

class oop

Question

¿Por qué algunas personas crean un método que devuelve una nueva estática en lugar de hacer que todos los métodos sean estáticos? ¿Cuál es la razón para tener ese método que devuelve nueva estática ? No estoy preguntando cuál es la diferencia entre estática y yo, o qué significa estática y yo. Por ejemplo, aquí hay una clase simple:

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

}

Como puede ver, hay un método estático make () que devuelve una nueva estática . Entonces, algunas personas llaman a otros métodos como este:

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

¿Cuál es el propósito de esto? Veo que aquí no usamos la nueva sintaxis de Expression , y si ese es el punto, ¿por qué no hicieron que todos los métodos sean, por ejemplo, estáticos? ¿Cuál es la diferencia, cuál es la razón para tener ese método que devuelve una nueva estática ?

Answer 1

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

Answer 2

new static crea una instancia de un nuevo objeto de la clase actual, y funciona con enlaces estáticos tardíos (crea una instancia de la subclase si la clase fue subclase, espero que entienda eso).

Tener un método static en una clase que devuelve una nueva instancia del mismo es un constructor alternativo . Lo que significa que, normalmente, su constructor es public function __construct , y normalmente requiere un cierto conjunto de parámetros:

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

Tener un constructor alternativo le permite proporcionar diferentes valores predeterminados, o accesos directos de conveniencia para crear una instancia de esta clase sin tener que proporcionar esos argumentos específicos y / o para poder proporcionar diferentes argumentos que el constructor alternativo convertirá a los canónicos:

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

}

Ahora, aunque su constructor canónico requiere un montón de argumentos complejos, puede crear una instancia predeterminada de su clase, que probablemente esté bien para la mayoría de los usos, simplemente con Foo::getDefault() .

El ejemplo canónico en PHP para esto es DateTime y DateTime::createFromFormat .

En su ejemplo concreto, el constructor alternativo en realidad no hace nada, por lo que es bastante superfluo, pero espero que sea porque es un ejemplo incompleto. Si de hecho hay un constructor alternativo que no hace nada más que una new static , es probable que solo sea una sintaxis de conveniencia (new Foo)-> , lo cual me parece cuestionable.