Comment utiliser la liaison statique tardive en PHP

Cet article vous présentera comment utiliser la liaison statique tardive en PHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Qu'est-ce que la liaison statique tardive ? D’ailleurs, nous en avons déjà parlé dans l’article précédent statique en PHP. Aujourd'hui, nous allons à nouveau comprendre ce concept en profondeur.

Tout d'abord, nous introduisons le concept de liaison statique tardive à travers un morceau de code :

class A
{
    public static function who()
    {
        echo __CLASS__, PHP_EOL;
    }
    public static function test()
    {
        self::who();
    }
}

class B extends A
{
    public static function who()
    {
        echo __CLASS__, PHP_EOL;
    }
}

B::test(); // A

Dans ce code, nous utilisons le mot-clé self, lors de l'utilisation de la classe B pour appeler test() Lors de l'utilisation une méthode statique, self pointe vers la méthode who() de la classe A, donc la sortie est A. Ne vous énervez pas, il s’agit d’une liaison statique ordinaire. Ce que le mot-clé self appelle dépend de la classe dans laquelle il est défini. En d’autres termes, peu importe la façon dont vous héritez ou quelle sous-classe est utilisée pour appeler la méthode test(), le mot-clé self appellera la méthode who() de la classe A.

Qu'en est-il de la liaison statique tardive ? En fait, c'est un peu comme un objet de classe instancié. Chaque objet instancié s'appelle lui-même, pas la méthode attributaire de la classe parent. Les appels statiques ordinaires ne sont pas comme ça, mais en réalité, nous avons un tel besoin d'appeler des méthodes de propriétés statiques de la même manière que les objets instanciés. À l'heure actuelle, nous pouvons utiliser le mot-clé static pour implémenter une liaison statique tardive.

class C
{
    public static function who()
    {
        echo __CLASS__, PHP_EOL;
    }
    public static function test()
    {
        static::who();
    }
}

class D extends C
{
    public static function who()
    {
        echo __CLASS__, PHP_EOL;
    }
}

D::test(); // D

Lorsque le mot-clé static est utilisé, le who() appelé à l'intérieur de la méthode test() appelée par la classe D est ici la classe D elle-même.

La définition dans la documentation officielle est la suivante :

Lors d'un appel de méthode statique, le nom de la classe est celui explicitement spécifié (généralement sur le côté gauche de l'opérateur ::) ; lors de la création d'un non- Lorsqu'une méthode statique est appelée, c'est la classe à laquelle appartient l'objet.

Cette fonctionnalité est appelée « liaison statique tardive » d'un point de vue interne au langage. « Liaison tardive » signifie que static :: n'est plus résolu en classe dans laquelle la méthode actuelle est définie, mais est calculé au moment de l'exécution réelle. Elle peut également être appelée « liaison statique » car elle peut être utilisée pour (mais sans s’y limiter) des appels à des méthodes statiques.

En plus des mots-clés self et static, nous avons également un mot-clé parent La signification de ce mot-clé est évidente, appelant le contenu statique de la classe parent. Nous utilisons trois mots-clés en même temps pour tester :

class E
{
    public static function who()
    {
        echo __CLASS__, PHP_EOL;
    }
    public static function test()
    {
        self::who();
        static::who();
    }
}

class F extends E
{
    public static function who()
    {
        echo __CLASS__, PHP_EOL;
    }
}

class G extends F
{
    public static function who()
    {
        parent::who();
        echo __CLASS__, PHP_EOL;
    }
}

G::test();

// E
// F
// G

Enfin, examinons deux méthodes PHP. L'une est la méthode get_call_class(), qui est utilisée pour obtenir quelle classe est actuellement appelée. Dans la méthode statique, vous pouvez déterminer sur quelle classe la classe actuelle est basée sur la méthode appelante pour effectuer d'autres opérations de logique métier. L'autre est la méthode forward_static_call(), qui est utilisée pour appeler des méthodes statiques.

class H
{
    public static function who()
    {
        echo __CLASS__ . ':' . join(',', func_get_args()), PHP_EOL;
    }
    public static function test()
    {
        echo get_called_class(), PHP_EOL;
        forward_static_call('who', 'a', 'b'); // xxx:a,b
        forward_static_call(['I', 'who'], 'c', 'd'); // I:c,d
        forward_static_call_array(['H', 'who'], ['e', 'f']); // H:e,f
    }
}

class I extends H
{
    public static function who()
    {
        echo __CLASS__ . ':' . join(',', func_get_args()), PHP_EOL;
    }
}

function who()
{
    echo 'xxx:' . join(',', func_get_args()), PHP_EOL;
}

H::test(); // H
// xxx:a,b
// I:c,d
// H:e,f
I::test(); // I
// xxx:a,b
// I:c,d
// H:e,f

Notez que si forward_static_call() ne spécifie pas de nom de classe, la méthode globale sera appelée. forward_static_call_array() transmet les paramètres à l'aide d'un tableau.

Code de test :

https://github.com/zhangyue0503/dev-blog/blob/master/php/202001/source/%E5%90%8E%E6%9C%9F%E9%9D%99%E6%80%81%E7%BB%91%E5%AE%9A%E5%9C%A8PHP%E4%B8%AD%E7%9A%84%E4%BD%BF%E7%94%A8.php

Apprentissage recommandé : Tutoriel vidéo php

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!