La portée d'une variable dépend du contexte
dans lequel la variable est définie. Pour la majorité des
variables, la portée concerne la totalité d'un script
PHP. Mais lorsque vous définissez une fonction, la
portée d'une variable définie dans cette fonction
est locale à la fonction. Par exemple :
Exemple 12-5. Les variables sont locales à la fonction
<?php
$a = 1;
include 'b.inc';
?>
|
|
Ici, la variable $a sera accessible dans le script inclus
b.inc. Cependant, dans les fonctions
définies par l'utilisateur, une nouvelle définition
de cette variable sera donnée, limitée à la
fonction. Toute variable utilisée dans une fonction est
par définition, locale. Par exemple :
Exemple 12-6. Les variables sont locales à la fonction (2)
<?php
$a = 1; /* portée globale */
function test() {
echo $a; /* portée locale */
}
test();
?>
|
|
Le script n'affichera rien à l'écran car
l'instruction echo() utilise la variable locale $a,
et celle-ci n'a pas été assignée
préalablement dans la fonction. Vous pouvez noter que
ce concept diffère un petit peu du langage C dans
lequel une variable globale est automatiquement accessible dans
les fonctions, Ã moins d'être redéfinie
localement dans la fonction. Cela peut poser des problèmes
si vous redéfinissez des variables globales localement.
En PHP, une variable globale doit être
déclarée à l'intérieur de chaque
fonction afin de pouvoir être utilisée dans cette
fonction.
Commençons par un exemple avec global :
Exemple 12-7. Exemple avec global
<?php
$a = 1;
$b = 2;
function somme() {
global $a, $b;
$b = $a + $b;
}
somme();
echo $b;
|
|
Le script ci-dessus va afficher la valeur 3.
En déclarant globales les variables $a et
$b locales
de la fonction somme(), toutes les références Ã
ces variables concerneront les variables globales. Il n'y a
aucune limite au nombre de variables globales qui peuvent
être manipulées par une fonction.
Une deuxième méthode pour accéder aux
variables globales est d'utiliser le tableau associatif
pré-défini $GLOBALS. Le précédent
exemple peut être réécrit de la
manière suivante :
Exemple 12-8. Les variables globales et $GLOBALS
<?php
$a = 1;
$b = 2;
function somme() {
$GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}
somme();
echo $b;
?>
|
|
Le tableau $GLOBALS est un tableau associatif avec le nom
des variables globales comme clé et les valeurs des éléments
du tableau comme valeur des variables. Notez que $GLOBALS
existe dans tous les contextes, car $GLOBALS est un
superglobal.
Voici un exemple des super globaux :
Exemple 12-9. Les variables super globales
<?php
function test_global() {
// La plupart des variables pré-définies ne sont pas des "superglobales" et
// requièrent le mot-clé 'global' pour être disponibles dans une fonction.
global $HTTP_POST_VARS;
echo $HTTP_POST_VARS['name'];
// Les superglobales sont accessibles dans tous les contextes
// et ne requièrent pas 'global'. Les superglobales sont disponibles
// depuis &php; 4.1.0 et HTTP_POST_VARS est de plus en plus
// déprécié.
echo $_POST['name'];
}
?>
|
|
Une autre caractéristique importante de la portée des variables est
la notion de variable static. Une variable statique a
une portée locale uniquement, mais elle ne perd pas sa valeur lorsque le
script appelle la fonction. Prenons l'exemple suivant :
Exemple 12-10. Les variables statiques
<?php
function Test()
{
$a = 0;
echo $a;
$a++;
}
?>
|
|
Cette fonction est un peu inutile car à chaque fois
qu'elle est appelée, elle initialise $a à 0 et
affiche "0". L'incrémentation de la variable ($a++)
ne sert pas à grand chose, car dès que la
fonction est terminée, la variable disparaît.
Pour faire une fonction de comptage utile, c'est-Ã -dire qui
ne perdra pas la trace du compteur, la variable $a est
déclarée comme une variable statique :
Exemple 12-11. Les variables statiques (2)
<?php
function Test() {
static $a = 0;
echo $a;
$a++;
}
?>
|
|
Maintenant, Ã chaque fois que la fonction Test() est
appelée, elle affichera une valeur de $a incrémentée
de 1.
Les variables statiques sont essentielles lorsque vous faites des
appels récursifs à une fonction. Une fonction
récursive est une fonction qui s'appelle elle-même.
Il faut faire attention lorsque vous écrivez une fonction
récursive car il est facile de faire une boucle infinie.
Vous devez vérifier que vous avez bien une condition qui
permet de terminer votre récursivité. La fonction
suivante compte récursivement jusqu'Ã 10 :
Exemple 12-12. Les variables statiques et la récursivité
<?php
function Test()
{
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
Test();
}
$count--;
}
?>
|
|
Note :
Les variables statiques doivent être déclarées comme dans l'exemple ci-dessus.
Tenter d'assigner des valeurs à ces variables qui sont le résultat d'expressions
causera une erreur d'analyse.
Exemple 12-13. Déclaration de variables statiques
<?php
function foo(){
static $int = 0; // correct
static $int = 1+2; // faux (car c'est une expression)
static $int = sqrt(121); // faux (car c'est aussi une expression)
$int++;
echo $int;
}
?>
|
|
Le Zend Engine 1, sur qui repose PHP 4, implémente les
options static
et global
pour les variables, en terme de références. Par exemple, une vraie
variable globale est importée dans un contexte de fonction avec
global.
Cette commande crée en fait une référence sur la variable globale. Cela
peut vous mener à des comportements inattendus, par exemple :
Exemple 12-14. Les variables statiques et les références
<?php
function test_global_ref() {
global $obj;
$obj = &new stdclass;
}
function test_global_noref() {
global $obj;
$obj = new stdclass;
}
test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>
|
|
L'exemple ci-dessus va afficher :
NULL
object(stdClass)(0) {
} |
Un comportement similaire s'applique à la commande static.
Les références ne sont pas stockées dynamiquement :
Exemple 12-15. Les variables statiques et les références (2)
<?php
function &get_instance_ref() {
static $obj;
echo 'Objet statique : ';
var_dump($obj);
if (!isset($obj)) {
// Assigne une référence à une variable statique
$obj = &new stdclass;
}
$obj->property++;
return $obj;
}
function &get_instance_noref() {
static $obj;
echo 'Objet statique : ';
var_dump($obj);
if (!isset($obj)) {
// Assigne une objet à une variable statique
$obj = new stdclass;
}
$obj->property++;
return $obj;
}
$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>
|
|
L'exemple ci-dessus va afficher :
Objet statique : NULL
Objet statique : NULL
Objet statique : NULL
Objet statique : object(stdClass)(1) {
["property"]=>
int(1)
} |
Ces exemples illustrent les problèmes rencontrés lors de l'assignation
de référence à des variables statiques, qui sont
oubliées lorsque vous appelez
&get_instance_ref() une seconde fois.
