STATIQUE vs soi: démêler les liaisons statiques tardives en php

Lorsqu'une méthode statique est appelée l'utilisation de soi dans l'héritage, il pointe toujours la classe qui définit la méthode, plutôt que la classe réellement appelée, ce qui entraîne l'incapacité d'appeler la méthode remplacée sous-classe comme prévu; Alors que Static utilise la liaison statique tardive, ce qui peut analyser correctement la classe réellement appelée lors de l'exécution. 1. Self est une liaison précoce, pointant vers la classe où se trouve le code; 2. Static est une liaison tardive, pointant vers la classe d'appel d'exécution; 3. Utilisez statique pour implémenter des méthodes d'usine statiques et renvoyer automatiquement les instances de sous-classe; 4. Statique prend en charge l'analyse correcte des attributs héréditaires dans la chaîne de méthodes; 5. LSB ne convient qu'aux méthodes et attributs statiques, pas pour les constantes; 6. La statique doit être utilisée en premier dans les classes héréditaires pour améliorer la flexibilité et l'évolutivité, qui est largement recommandée dans le PHP moderne.

Lorsque vous travaillez avec l'héritage dans PHP, vous avez probablement rencontré self et vous vous êtes demandé pourquoi parfois cela ne se comporte pas comme vous vous attendez - en particulier lorsque vous appelez des méthodes statiques des classes enfants. C'est là que les liaisons statiques tardives (LSB) entrent en jeu, et la différence entre self et static devient cruelle.

Le problème de self

self en PHP fait référence à la classe où la méthode est définie , pas nécessairement celle qui l'appelle. Cela signifie qu'il est lié tôt - résolu à l'heure de compilation, pas à l'exécution.

Considérez cet exemple:

 classe parentClass {
    fonction statique publique qui () {
        echo "parentClass \ n";
    }

    Fonction statique publique callwho () {
        self :: who ();
    }
}

Classe La classe d'enfants étend ParentClass {
    fonction statique publique qui () {
        Echo "Classe de sauvetage \ n";
    }
}

Certes d'enfants :: callwho (); // sorties: "parentClass"

Même si nous appelons callWho() sur ChildClass , il publie ParentClass . Pourquoi? Parce que self::who() Inside ParentClass se réfèrent toujours à ParentClass::who() , quel que soit le contexte d'appel.

Ce comportement n'est souvent pas ce que vous voulez lors de la conception de hiérarchies de classe excessives.

Entrez static : liaisons statiques tardives

PHP 5.3 a introduit les liaisons statiques tardives , permettant à static de se référer à la classe qui a été appelée au moment de l'exécution - pas où la méthode est définie.

Ajusterons l'exemple en utilisant static au lieu de self :

 classe parentClass {
    fonction statique publique qui () {
        echo "parentClass \ n";
    }

    Fonction statique publique callwho () {
        statique :: qui (); // Remarque: statique au lieu de soi
    }
}

Classe La classe d'enfants étend ParentClass {
    fonction statique publique qui () {
        Echo "Classe de sauvetage \ n";
    }
}

Certes d'enfants :: callwho (); // Sorties: "Certes enfants"

Maintenant, il imprime ChildClass . En effet, static::who() est résolu à l'exécution en fonction de la classe réelle utilisée dans l'appel - c'est une liaison tardive .

✅ Règle de base:

• self → fait référence à la classe actuelle (où le code est écrit)
• static → fait référence à la classe appelée (qui peut être un enfant)

Cas d'utilisation pratiques pour static

1. Méthodes d'usine statiques

Vous pouvez créer une méthode d'usine de base qui renvoie les instances de la bonne classe enfant:

 Modèle de classe {
    fonction statique publique create () {
        retourner new static (); // renvoie l'instance de la classe appelée
    }
}

Classe L'utilisateur étend le modèle {
    // hérite de création (), mais renvoie l'instance utilisateur
}

$ user = user :: create (); // en fait un objet utilisateur
var_dump ($ d'instance utilisateur de l'utilisateur); // vrai

Sans static , vous devrez remplacer create() dans chaque classe d'enfants.

2. Méthode chaînage d'héritage

 classe queryBuilder {
    Table $ statique protégé;

    fonction statique publique tous () {
        ECHO "Sélectionner parmi". Table statique :: $. "\ n";
    }
}

Classe L'utilisateur étend QueryBuilder {
    protégé Static $ table = 'utilisateurs';
}

User :: all (); // Sorties: "Sélection parmi les utilisateurs"

Encore une fois, static::$table résout à User::$table , pas QueryBuilder::$table .

Mises en garde et limitations

• LSB fonctionne uniquement avec la méthode statique et les appels de propriété.
• Il ne s'applique pas aux constantes ( self::CONST vs static::CONST toujours à la classe où il est défini).
• Soyez prudent lorsque vous utilisez static dans les classes finales - pas d'héritage, donc self et static se comportent de la même manière.
• La différence de performance est négligeable; prioriser la clarté et le comportement correct.

Résumé

Utilisez static lorsque vous souhaitez des méthodes héréditaires pour respecter l'implémentation de la classe d'appel - en particulier dans les bases abstraites, les usines ou les interfaces courantes.

En PHP moderne, favorisez static par rapport à self lorsque vous travaillez avec des méthodes statiques dans des classes héritables. Cela rend votre code plus flexible et intuitif.

Fondamentalement: si vous construisez quelque chose signifie être étendu, static est probablement le bon choix.

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!