web-dev-qa-db-fra.com

Pourquoi retourner une nouvelle statique? (PHP)

Pourquoi certaines personnes créent une méthode qui retourne de nouvelles statiques au lieu de rendre toutes les méthodes statiques? Quelle est la raison d'avoir cette méthode qui retourne une nouvelle statique? Je ne demande pas quelle est la différence entre statique et soi, ou ce que signifie statique et soi. Par exemple, voici une classe 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";
    }

}

Comme vous pouvez le voir, il existe une méthode statiquemake () qui renvoie nouvelle statique. Ensuite, certaines personnes appellent d'autres méthodes comme celle-ci:

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

Quel en est le but? Je vois qu'ici nous n'utilisons pas la nouvelle syntaxe Expression , et si c'est le point - alors pourquoi ils n'ont pas fait toutes les méthodes, par par exemple, statique? Quelle est la différence, quelle est la raison d'avoir cette méthode qui retourne une nouvelle statique ?

phpclassoopstaticlate-static-binding
27
PeraMika

new static Instancie un nouvel objet de la classe actuelle et fonctionne avec des liaisons statiques tardives (instancie la sous-classe si la classe a été sous-classée, je suppose que vous comprenez cela).

Avoir une méthode static sur une classe qui retourne une nouvelle instance de celle-ci est un constructeur alternatif . Autrement dit, votre constructeur est généralement public function __construct, Et il nécessite généralement un certain nombre de paramètres:

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

Avoir un constructeur alternatif vous permet de fournir différentes valeurs par défaut ou des raccourcis pratiques pour instancier cette classe sans avoir à fournir ces arguments spécifiques et/ou pour pouvoir fournir différents arguments que le constructeur alternatif convertira en arguments canoniques:

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

}

Maintenant, même si votre constructeur canonique nécessite un tas d'arguments complexes, vous pouvez créer une instance par défaut de votre classe, qui conviendra probablement à la plupart des utilisations, simplement avec Foo::getDefault().

L'exemple canonique dans PHP pour cela est DateTime et DateTime::createFromFormat .

Dans votre exemple concret, le constructeur alternatif ne fait rien, donc c'est plutôt superflu, mais je suppose que c'est parce que c'est un exemple incomplet. S'il y a bien un constructeur alternatif qui ne fait rien d'autre que new static, C'est probablement juste une syntaxe de commodité sur (new Foo)->, Ce que je trouve douteux.

32
deceze

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
8
Sergey Shuchkin