Quand est-ce que j'utilise des variables/fonctions statiques dans php?
Je me rafraîchit sur OOP avec PHP et j'ai vu un exemple de paramétrage de fonctions et/ou de variables statiques. Quand et pourquoi devrais-je définir une variable/fonction sur static? J'ai utilisé d'autres langages et je ne me rappelle pas vraiment avoir utilisé statique, je n'ai jamais trouvé de véritable objectif. Je sais ce que ça fait mais pourquoi ne pas simplement utiliser une variable?
Vous utilisez static lorsque vous souhaitez utiliser une méthode/variable qui n'est pas liée à une instance. Cela peut arriver quand:
Il n'y a pas de relation avec votre objectif et une instance (utile pour les boîtes à outils dans des langages qui ne permettent rien d'autre que OOP comme Java, mais qui ne soit pas utile en PHP).
Vous voulez contrôler l'accès à l'instance. Le plus souvent, l'instance que vous souhaitez traiter n'est pas définie lorsque vous écrivez le code, mais le sera à l'exécution. Le modèle Singleton est le meilleur exemple. Vous pouvez utiliser des méthodes statiques comme fabriques pour créer un objet en fonction du contexte ou pour partager des ressources avec d'autres instances. E.G: un membre statique peut donner accès à une couche de base de données. Ainsi, une partie de l'application accède au même élément de n'importe où et est ouverte/fermée sans conflit.
Les performances sont importantes et la méthode sera exécutée souvent. Dans ce cas, vous économiserez du temps CPU, empêchant ainsi l'interprète de rechercher le membre sur une instance à chaque appel. Néanmoins, si perfs devient un problème de ce type et que vous en venez à cette solution, il serait peut-être temps de reconsidérer votre architecture ou d'utiliser une liaison à un langage plus rapide pour les parties critiques du code.
Vous avez une méthode qui est liée à un type mais qui sera appliquée à un autre. Il peut être judicieux d’écrire la méthode dans la déclaration du premier type, mais de la définir comme statique car elle attend une instance de l’autre.
L'exemple parfait est un analyseur de chaînes:
class MyObject
{
static function parse($str)
{
$obj = new MyObject();
// some parsing/setting happens here
return $obj;
}
}
// you create an object "MyObject" from a string, so it's more obvious
// to read it this way :
$new_obj = MyObject::parse("This a description of a super cool object");
Les fonctions statiques et les variables sont utilisées pour accéder aux variables/fonctions dans une étendue globale, comme ceci:
echo myClass::myVariable;
echo myClass::myFunction();
Lorsque quelque chose est statique, il est possible d'y accéder n'importe où et ressemble beaucoup à une fonction de type procédural, à la différence près qu'elle peut utiliser self et est contenue dans la portée des classes.
class myClass{
static $myVariable = "myVar";
static function myFunction()
{
return "myFunc";
}
}
Une des façons de l'utiliser consiste à ne conserver qu'une instance d'une classe, ou une méthode Singleton.
class myClass
{
static $class = false;
static function get_connection()
{
if(self::$class == false)
{
self::$class = new myClass;
}
else
{
return self::$class;
}
}
private function __construct()
{
// my constructor
}
// Then create regular class functions.
}
Comme il a un constructeur privé, il ne peut pas être instancié avec l'opérateur new. Vous devez donc appeler myClass::get_connection() pour obtenir une classe. Cette fonction peut créer la nouvelle classe (car c'est un membre de la classe). Ensuite, il stocke la classe dans une variable statique et si vous appelez à nouveau la fonction, il retournera simplement la classe créée.
En fin de compte, le mot-clé static est utilisé pour conserver les éléments statiques en référence à scope. Cela signifie que vous ne voulez rien qui «change» à cause de la portée actuelle. Bien que la méthode Singleton étire un peu cela, elle garde la même idée que vous avez toujours la «même» classe, quelle que soit la portée dans laquelle vous vous trouvez.
Documentation PHP
Mot clé statique
Opérateur Résolution Scope
Connaissances StackOverflow
Comment éviter d'utiliser PHP Objets globaux
Partager des variables entre des fonctions dans PHP sans utiliser de globes
Rendre une variable globale accessible pour chaque fonction de la classe
Global ou Singleton pour la connexion à la base de données
PHP Classes: quand utiliser :: vs. ->?
En outre, il est très utile pour la mise en cache si une méthode est appelée très souvent et fait exactement la même chose, par exemple:
/**
* Returns true if the user is logged in through shibboleth
*
* @return boolean true on success, else false
*/
protected function is_logged_in() {
//Check shibboleth headers
if (!empty($_SERVER['HTTP_SHIB_IDENTITY_PROVIDER']) || !empty($_SERVER['Shib-Identity-Provider'])) {
if (!empty($_SERVER[$this->core->dbconfig("shib_auth", self::SHIB_AUTH_CONFIG_UID)])) {
return true;
}
}
return false;
}
Cette méthode sera appelée très souvent dans mon framework et fera à chaque appel une recherche dans la base de données pour la clé de configuration $ _SERVER.
Donc, pendant que la page est traitée, j'appelle peut-être 10 fois en une page, elle aura 10 appels de base de données, mais je l'ai changée en:
/**
* Returns true if the user is logged in through shibboleth
*
* @return boolean true on success, else false
*/
protected function is_logged_in() {
static $logged_in = null;
if($logged_in != null) {
return $logged_in;
}
//Check shibboleth headers
if (!empty($_SERVER['HTTP_SHIB_IDENTITY_PROVIDER']) || !empty($_SERVER['Shib-Identity-Provider'])) {
if (!empty($_SERVER[$this->core->dbconfig("shib_auth", self::SHIB_AUTH_CONFIG_UID)])) {
$logged_in = true;
return true;
}
}
$logged_in = false;
return false;
}
Donc, il suffit de vérifier pour chaque chargement de page une fois le comportement normal si je me connectais et mettre en cache le résultat. la prochaine fois, elle renverra simplement la valeur en cache ..__ Cette fonctionnalité que j'utilise très souvent pour améliorer les performances.
J'espère que cela t'aides.
Voici un hasard, bien que assez bonne description des différences entre les méthodes statiques et d'instance .
De la poste:
Les méthodes d'instance sont des méthodes d'instance car elles reposent sur l'état de l'instance d'objet spécifique. Les méthodes d'instance sont liées à un exemple particulier parce que le comportement que la méthode appelle repose sur l'état de ce cas particulier.
Lorsque vous déclarez une méthode comme statique, vous définissez cette méthode comme étant un méthode de classe. Une méthode de classe s'applique à la classe par opposition à tout exemple particulier. Le comportement provoqué par une méthode de classe fait ne pas compter sur l'état d'une instance particulière. En fait, un statique method ne peut pas compter sur l'état d'une instance car les méthodes statiques manquent accès à cette référence. Au lieu de cela, le comportement d'une méthode de classe soit dépend d’un état que tous les objets partagent au niveau de la classe, ou est indépendant de tout état du tout.
Si une méthode repose sur l'état d'une instance d'objet, il doit s'agir d'un méthodes d'instance. Si une méthode est générale pour toutes ou aucune instance de classe, et ne repose pas sur l'état de l'objet, il devrait être une statique méthode. Les méthodes d'instance sont les plus couramment utilisées. Cependant statique les méthodes sont très utiles pour les classes d’utilitaires et d’usines et beaucoup autres utilisations.
En général, en utilisant la fonction statique, vous pouvez optimiser la vitesse ainsi que la mémoire. La portée de la méthode ne doit pas être modifiée, elle doit être de nature statique et vous pouvez accéder aux propriétés statiques des objets, méthodes sans les initier.
Les éléments statiques ont un certain nombre de caractéristiques qui peuvent être utiles.
Premièrement, ils sont disponibles à partir de n’importe où dans votre script (en supposant que vous ayez accès au cours). Cela signifie que vous pouvez accéder aux fonctionnalités sans avoir à passer d'une instance de la classe d'un objet à l'autre ni, pire, à stocker une instance dans une variable globale.
Deuxièmement, une propriété statique est disponible pour chaque instance d'une classe. Vous pouvez donc définir les valeurs que vous souhaitez voir disponibles pour tous les membres d'un type.
Enfin, le fait de ne pas avoir besoin d’une instance pour accéder à une propriété ou à une méthode statique peut vous éviter d’instancier un objet uniquement pour obtenir une fonction simple.
Si vous souhaitez partager des données avec toutes les instances, comme un compteur pour le nombre d'instances créées lors de l'exécution en cours.
Visitez: http://verraes.net/2014/06/when-to- use-static-methods-in-php/
Les méthodes statiques ne sont rien de plus que des fonctions globales namespaced. Je pense que nous pouvons tous être d’accord sur l’espacement des noms. En ce qui concerne les fonctions globales: nous les utilisons tout le temps. Les fonctions natives dans PHP constituent nos blocs de construction de base.