web-dev-qa-db-fra.com

PHP Variables statiques

$count = 5;
function get_count()
{
    static $count = 0;
    return $count++;
}
echo $count;
++$count;
echo get_count();
echo get_count();

J'ai deviné que les sorties 5 0 1 et c'est vrai, mais j'ai besoin d'une meilleure explication?

phpstatic
40
omg

La variable $count dans la fonction n'est liée d'aucune sorte à la variable globale $count. Le mot clé static est le même qu'en C ou en Java, cela signifie: N'initialisez cette variable qu'une seule fois et conserve son état lorsque la fonction se termine. Cela signifie que, lorsque l'exécution entre à nouveau dans la fonction, elle constate que le nombre de dollars interne a déjà été initialisé et stocké la dernière fois sous la forme 1 et utilise cette valeur.

70
soulmerge
$count = 5; // "outer" count = 5

function get_count()
{
    static $count = 0; // "inner" count = 0 only the first run
    return $count++; // "inner" count + 1
}

echo $count; // "outer" count is still 5 
++$count; // "outer" count is now 6 (but you never echoed it)

echo get_count(); // "inner" count is now + 1 = 1 (0 before the echo)
echo get_count(); // "inner" count is now + 1 = 2 (1 before the echo)
echo get_count(); // "inner" count is now + 1 = 3 (2 before the echo)

J'espère que cela efface votre esprit.

41
Alix Axel

Vous avez deux variables distinctes appelées $ count, mais elles ont un étendue ..__ différent. La première variable n'est pas explicitement déclarée, mais elle existe dès que vous l'avez affectée pour la première fois.

La deuxième variable (à l'intérieur de la méthode) n'est visible que par cette méthode. Comme il s'agit de statique , sa valeur est conservée entre plusieurs exécutions de la même méthode. L'affectation $count = 0; n'est exécutée que lors de la première exécution de la méthode.

En ce qui concerne l'opérateur d'incrémentation (++), le résultat de l'évaluation correspond à la valeur avant l'incrémentation de, car l'opérateur ( unary ) vient après le nom de la variable. Donc, oui, la sortie serait 5, 0, 1.
Si vous aviez écrit return ++$count;, le résultat aurait été 5, 1, 2.

Remarque: le ++$count que vous avez dans votre code existant est effectivement équivalent à $count++, car le résultat de l'évaluation est ignoré. L'effet sur la variable $count est le même: il est incrémenté de 1.

13
Thorarin

Premier écho: vous donne la variable $ count que vous déclarez dans votre première ligne.

Deuxième echo: calles get_count qui crée la variable statique $ count (donc dans le contexte de cette fonction) et lorsque vous instanciez la variable statique, vous la définissez à zéro. return $ count ++ est l'une de ces lignes que nous évitons habituellement dans le code - mais essentiellement, elle est incrémentée APRÈS le retour de la valeur.

Troisième écho: De même, 0 a été incrémenté à 1 après l'appel précédent à get_count, la même chose se produit ici: il renvoie 1 et incrémente la valeur à 2.

Est-ce que cela aide ou est-ce réellement plus déroutant?

5
Fenton

Tout d’abord, $ count à l’intérieur de la fonction et $ count à l’extérieur de la fonction sont deux variables différentes. Cela explique pourquoi la première sortie imprime 5.

Passons maintenant à static: Static signifie que votre variable locale n’est créée qu’une fois, lorsque la fonction s’exécute pour la première fois. Chaque exécution de fonction utilise ensuite la même variable, de sorte que les dernières valeurs de la variable dans la dernière exécution de la fonction sont toujours présentes.

Ainsi, lorsque vous appelez get_count () pour la première fois, la variable est définie sur 0, puis renvoyée. Après le retour, la variable est incrémentée.

Lorsque vous appelez la fonction pour la deuxième fois, la variable est toujours 1. Cette valeur est renvoyée puis incrémentée à 2.

0
Maximilian Mayerl

PHP a un mot clé bien connu static qui est largement utilisé dans PHP orienté objet pour définir des méthodes et des propriétés statiques, mais gardez à l'esprit que static peut également être utilisé dans des fonctions pour définir des variables statiques.

Qu'est-ce que c'est 'variable statique'?

La variable statique diffère de la variable ordinaire définie dans l'étendue de la fonction dans le cas où elle ne perd pas de valeur lorsque l'exécution du programme quitte cette étendue. Prenons l'exemple suivant d'utilisation de variables statiques:

function countSheep($num) {
 static $counter = 0;
 $counter += $num;
 echo "$counter sheep jumped over fence";
}

countSheep(1);
countSheep(2);
countSheep(3);

Résultat:

1 sheep jumped over fence
3 sheep jumped over fence
6 sheep jumped over fence

Si nous avions défini $counter sans static, chaque valeur renvoyée en écho serait identique au paramètre $num transmis à la fonction. Utiliser static permet de construire ce compteur simple sans solution de contournement supplémentaire.

Cas d'utilisation de variables statiques

  1. Pour stocker des valeurs entre les appels consécutifs à la fonction.
  2. Pour stocker des valeurs entre des appels récursifs lorsqu'il n'y a aucun moyen (ou aucun but.) De les transmettre en tant que paramètres.
  3. Pour mettre en cache une valeur qu'il est normalement préférable de récupérer une fois. Par exemple, résultat de la lecture d'un fichier immuable sur le serveur.

Des trucs

La variable statique n'existe que dans une étendue de fonction locale. Ça ne peut pas être accessible en dehors de la fonction dans laquelle il a été défini. Vous pouvez donc assurez-vous qu'il conservera sa valeur inchangée jusqu'au prochain appel à cette fonction.

La variable statique ne peut être définie qu'en tant que scalaire ou scalaire expression (depuis PHP 5.6). Lui attribuant d’autres valeurs inévitablement conduit à un échec au moins au moment où cet article a été écrit . Néanmoins, vous ne pouvez le faire que sur la ligne suivante de votre code:

function countSheep($num) {
  static $counter = 0;
  $counter += sqrt($num);//imagine we need to take root of our sheep each time
  echo "$counter sheep jumped over fence";
}

Résultat:

2 sheep jumped over fence
5 sheep jumped over fence
9 sheep jumped over fence

La fonction statique est un peu 'partagée' entre les méthodes d'objets de la même classe. Il est facile à comprendre en consultant l'exemple suivant:

class SomeClass {
  public function foo() {
    static $x = 0;
    echo ++$x;
  }
}

$object1 = new SomeClass;
$object2 = new SomeClass;

$object1->foo(); // 1
$object2->foo(); // 2 oops, $object2 uses the same static $x as $object1
$object1->foo(); // 3 now $object1 increments $x
$object2->foo(); // 4 and now his twin brother

Cela ne fonctionne qu'avec des objets de la même classe. Si les objets appartiennent à différentes classes (même s’étendant les unes sur les autres), le comportement des vars statiques sera comme prévu.

La variable statique est-elle le seul moyen de conserver les valeurs entre les appels d'une fonction?

Une autre façon de conserver les valeurs entre les appels de fonction consiste à utiliser des fermetures. Les fermetures ont été introduites dans PHP 5.3. En deux mots, ils vous permettent de limiter l’accès à un ensemble de variables d’une portée de fonction à une autre fonction anonyme qui sera le seul moyen d’y accéder. Les variables de fermeture peuvent imiter (avec plus ou moins de succès) OOP des concepts tels que 'constantes de classe' (si elles sont passées dans fermeture par valeur) ou 'propriétés privées' (si passées par référence) dans la programmation structurée.

Ce dernier permet en réalité d’utiliser des fermetures au lieu de variables statiques. Ce qu’il faut utiliser revient toujours au développeur qui décide, mais il convient de mentionner que les variables statiques sont certainement utiles lorsqu’on travaille avec des récurrences et méritent d’être remarquées par les développeurs.

0
alex_edev