La portée des variables en PHP

Dans cette nouvelle leçon, nous allons étudier un concept très important concernant les variables et leur utilisation qui est la notion de portée des variables en PHP.

 

Définition : la portée des variables en PHP

En PHP, nous pouvons déclarer des variables n’importe où dans notre script : au début du script, à l’intérieur de boucles, au sein de nos fonctions, etc.

L’idée principale à retenir ici est que l’endroit dans le script où on déclare une variable va déterminer l’endroit où la variable va être accessible c’est-à-dire utilisable. La « portée » d’une variable désigne justement la partie du script où la variable va être accessible.

Pour faire très simple, vous pouvez considérer que les variables peuvent avoir deux portées différentes : soit une portée globale, soit une portée locale.

Toute variable définie en dehors d’une fonction a une portée globale. Par définition, une variable qui a une portée globale est accessible « globalement », c’est-à-dire dans tout le script sauf dans les espaces locaux d’un script.

Au contraire, toute variable définie à l’intérieur d’une fonction va avoir une portée locale à la fonction. Cela signifie que la variable ne sera accessible qu’au sein de la fonction et notre variable sera par ailleurs par défaut détruite dès la fin de l’exécution de la fonction.

Regardez plutôt les exemples suivants pour bien comprendre la notion de portée des variables :

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php
            $x = 10;
            
            function portee1(){
                echo 'La valeur de $x globale est : ' .$x. '<br>';
            }
            function portee2(){
                $x = 5;
                echo 'La valeur de $x locale est : ' .$x. '<br>';
            }
            function portee3(){
                $y = 0;
                $y++;
                echo '$y contient la valeur : ' .$y. '<br>';
            }
            function portee4(){
                $z = 1;
            }
            portee1();
            portee2();
            portee3();
            portee3();
            portee4();
            echo 'La variable locale $z contient : ' .$z;
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

Exemple d'illustration de la notion de portée des variables en PHP ou scope

Ici, on commence par déclarer une variable $x en dehors de toute fonction. Notre variable possède donc une portée globale.

Dans notre première fonction portee1(), on tente d’afficher le contenu de notre variable $x déclarée globalement. Cela ne va pas fonctionner puisqu’une variable globale n’est par défaut pas accessible dans un espace local.

Notre deuxième fonction portee2() définit sa propre variable $x et a pour but d’afficher son contenu. Ici, vous devez bien comprendre que les deux variables $x globale et $x locale sont différentes pour le PHP. On le voit bien lorsqu’on affiche ensuite le contenu de notre variable $x globale qui n’a pas été modifié par son homologue locale.

Notre troisième fonction portee3() définit elle une variable $y = 0 et son but est d’incrémenter la valeur de notre variable puis de la renvoyer. Si on appelle plusieurs fois portee3(), on se rend compte que le résultat est toujours 1. Cela s’explique par le fait que la variable est détruite à la fin de l’exécution de chaque fonction et est donc réinitialisée sur sa valeur $y = 0 à chaque fois qu’on appelle la fonction.

Finalement, notre quatrième fonction portee4() définit une variable $z. Lorsqu’on essaie d’afficher le contenu de $z depuis l’espace global, aucune valeur n’est renvoyée puisqu’une variable définie localement n’est accessible que dans l’espace dans laquelle elle a été définie par défaut.

 

Accéder à une variable de portée globale depuis un espace local

Parfois, nous voudrons nous servir de variables possédant une portée globale (c’est-à-dire définies en dehors d’une fonction) à l’intérieur d’une fonction.

Pour cela, on va pouvoir utiliser le mot clef global avant la déclaration des variables qu’on souhaite utiliser dans notre fonction. Cela va nous permettre d’indiquer que les variables déclarées dans la fonction sont en fait nos variables globales. Pour être tout à fait précis, on dit que les variables globales sont importées dans le contexte local par référence.

On va ainsi pouvoir utiliser nos variables globales localement. Attention ici : si on modifie la valeur de ces variables dans notre fonction, la valeur des variables globales sera également modifiée puisque ce sont essentiellement les mêmes variables qu’on manipule à l’intérieur de notre fonction.

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php
            $x = 10;
            
            function portee(){
                global $x;
                echo 'La valeur de $x globale est : ' .$x. '<br>';
                $x = $x + 5; //On ajoute 5 à la valeur de $x
            }
            
            portee();
            echo '$x contient maintenant : ' .$x;
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

Exemple de variable à portée globale en PHP

On va également pouvoir utiliser la variable super globale $GLOBALS pour accéder localement à de variables de portée globale. Nous verrons comment faire cela lorsqu’on étudiera les variables super globales.

 

Accéder à une variable définie localement depuis l’espace global

Il n’y a aucun moyen d’accéder à une variable définie localement depuis l’espace global. Cependant, on va tout de même pouvoir récupérer la valeur finale d’une variable définie localement et la stocker dans une nouvelle variable globale en utilisant l’instruction return.

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php
            function portee(){
                $y = 5;
                echo 'Valeur de $y (depuis la fonction) :' .$y. '<br>';
            }
            
            function portee2(){
                $z = 5;
                return $z;
            }
            
            portee();
            echo 'Valeur de $y (depuis l\'espace global) : ' .$y. '<br>';
            
            $a = portee2(); //On stocke la valeur renvoyée par portee2() dans $a
            echo '$z contient la valeur : ' .$a;
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

Exemple de variable à portée locale en PHP

Notez cependant bien ici qu’une variable locale n’aura toujours qu’une portée locale et que sa portée ne pourra pas être étendue dans l’espace global.

 

Le mot clef static

Une variable définie localement va être supprimée ou détruite dès la fin de l’exécution de la fonction dans laquelle elle a été définie.

Parfois, nous voudrons pouvoir conserver la valeur finale d’une variable locale pour pouvoir s’en resservir lors d’un prochain appel à la fonction. Cela va notamment être le cas pour des fonctions dont le but va être de compter quelque chose.

Pour qu’une fonction de « souvienne » de la dernière valeur d’une variable définie dans la fonction, nous allons pouvoir utiliser le mot clef static devant la déclaration initiale de la variable.

La portée de la variable sera toujours statique, mais la variable ne sera pas détruite lors de la fin de l’exécution de la fonction mais plutôt conservée pour pouvoir être réutilisée lors d’une prochaine exécution.

Notez par ailleurs que lorsque nous initialisons une variable en utilisant static, la variable ne sera initialisée que lors du premier appel de la fonction (si ce n’était pas le cas, le mot clef static n’aurait pas grand intérêt).

<!DOCTYPE html>
<html>
    <head>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php
            function compteur(){
                static $x = 0;
                echo '$x contient la valeur : ' .$x. '<br>';
                $x++;
            }
            
            compteur();
            compteur();
            compteur();
            compteur();
            compteur();
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

Utilisation du mot clef static et portée des variables PHP

Ici, notre fonction commence par initialiser une variable $x, affiche sa valeur puis l’incrémente. Lors du premier appel, $x contient la valeur 0. Lors du deuxième appel, la fonction va réutiliser la dernière valeur de $x qui n’a pas été détruite grâce à l’utilisation du mot clef static et va à nouveau afficher la valeur contenue dans notre variable (1 donc) puis l’incrémenter à nouveau. Notez qu’ici la fonction ne réinitialise pas notre variable.

Sans le mot clef static, chaque nouvel appel de notre fonction renverrait la valeur 0 puisqu’à la fin de chaque exécution de la fonction les variables utilisées seraient détruites et seraient donc réinitialisées à chaque nouvel appel.

Laisser un commentaire