Aller au contenu principal

Portée d'une variable

Schéma

Notions théoriques​

En PHP, la portée d'une variable est le contexte dans lequel elle est définie et peut être utilisée. Il existe trois types de portées : globale, locale et statique.

  • Globale : Une variable définie en dehors d'une fonction a une portée globale. Elle ne peut pas être utilisée à l'intérieur d'une fonction à moins d'être explicitement déclarée comme globale dans cette fonction.

  • Locale : Une variable définie à l'intérieur d'une fonction a une portée locale. Elle ne peut être utilisée que dans cette fonction.

  • Statique : Une variable déclarée comme statique à l'intérieur d'une fonction conserve sa valeur entre les appels de fonction.

$x = 10; // Variable globale

function test() {
    $y = 20; // Variable locale
    global $x; // Utilisation de la variable globale $x
    static $z = 30; // Variable statique
}
Si une variable locale porte le même nom qu'une variable globale

Lorsqu'une fonction est exécutée, elle ne peut pas accéder aux variables globales à moins que celles-ci ne soient explicitement référencées en utilisant le mot-clé global (ou en utilisant l'array superglobal $GLOBALS).

Voici un exemple illustrant ce comportement :

$variable = "Je suis une variable globale";

function tester() {
    $variable = "Je suis une variable locale";
    echo $variable; // Cela affichera "Je suis une variable locale"
}

tester();

echo $variable; // Cela affichera "Je suis une variable globale"

Dans cet exemple, lorsqu'on appelle la fonction tester(), elle affiche la valeur de la variable locale $variable. En dehors de la fonction, l'écho affiche la valeur de la variable globale $variable.

Pour accéder à la variable globale à l'intérieur de la fonction, vous pouvez utiliser le mot-clé global :

$variable = "Je suis une variable globale";

function tester() {
    global $variable;
    echo $variable; // Cela affichera "Je suis une variable globale"
}

tester();

Ou vous pouvez utiliser l'array superglobal $GLOBALS qui est un tableau associatif contenant toutes les variables globales. L'index de ce tableau est le nom des variables :

$variable = "Je suis une variable globale";

function tester() {
    echo $GLOBALS['variable']; // Cela affichera "Je suis une variable globale"
}

tester();
attention

L'utilisation de variables globales peut rendre le code difficile à lire et à maintenir. Il est préférable de passer des variables aux fonctions en tant qu'arguments pour éviter d'avoir à dépendre de l'état global.

Astuce de pro : Implémenter des fonctions pures

Une fonction qui ne dépend que de ses paramètres et retourne un résultat est appelée fonction pure.

Une fonction pure est :

  • facile à utiliser,
  • facile à tester.

Exemple de fonction pure :

function additionner($a, $b) {
    return $a + $b; // fonction pure : pas de dépendance à des variables globales ou statiques
}

Exemple pratique​

  • Dans votre répertoire "Documents" créez le répertoire tp_portee_variable.
  • Dans ce répertoire créez le fichier main.php : 
    <?php
    // Portée d'une variable
    print("Démarrage de l'exemple \n\n");
  • Testez le fonctionnement de ce fichier : 
    php main.php

Voyons comment fonctionne la portée des variables en PHP avec un exemple.

$x = 10; // Variable globale

function test() {
    print("Appel de la fonction test \n\n");

    global $x; // Utilisation de la variable globale $x
    $y = 20; // Variable locale
    static $z = 30; // Variable statique

    print("x = $x  \n"); // Affiche 10
    print("y = $y  \n"); // Affiche 20
    print("z = $z  \n"); // Affiche 30

    print("Incremente la variable globale x \n");
    $x++; 

    print("Incremente la variable locale y \n");
    $y++; 

    print("Incremente la variable statique z \n\n");
    $z++; 
}

test(); // Affiche x=10, y=20, z=30
test(); // Affiche x=11, y=20, z=31

Dans cet exemple :

  • la variable globale $x est définie en dehors de la fonction test et peut être utilisée partout

    elle conserve donc sa valeur entre les appels de la fonction test

  • la variable locale $y est définie à l'intérieur de la fonction test et peut être utilisée seulement dans cette fonction

    elle réinitialise donc sa valeur à chaque appel de la fonction test

  • la variable statique $z est définie de façon statique à l'intérieur de la fonction test

    elle conserve sa valeur entre les appels de la fonction test

Risques des variables globales en PHP

L'utilisation excessive de variables globales en PHP peut présenter plusieurs risques et inconvénients.

Les variables globales sont accessibles de n'importe où dans le code, ce qui peut rendre le suivi des modifications et des erreurs difficile.

Voici quelques risques associés à une utilisation excessive de variables globales en PHP :

  1. Complexité et lisibilité du code : Trop de variables globales peuvent rendre le code confus, complexe et difficile à comprendre, ce qui peut entraîner des erreurs et des bugs.

  2. Dépendance accrue : L'utilisation excessive de variables globales crée une dépendance entre différentes parties du code, ce qui rend le code moins modulaire et plus difficile à maintenir.

  3. Conflits potentiels : Lorsque plusieurs parties du code modifient les mêmes variables globales, des conflits peuvent survenir, ce qui peut entraîner des résultats inattendus et des bogues difficiles à diagnostiquer.

  4. Sécurité : Les variables globales sont accessibles de partout, ce qui peut poser des problèmes de sécurité en exposant des données sensibles à des parties non autorisées du code.

  5. Testabilité : Les variables globales rendent le code plus difficile à tester, car elles introduisent des dépendances cachées qui peuvent rendre les tests unitaires plus complexes.

Pour éviter ces risques, il est recommandé de limiter l'utilisation des variables globales en PHP en les remplaçant par des méthodes plus sûres et plus structurées, telles que :

  • les paramètres de fonction,
  • les classes
  • et les espaces de noms.

Cela rendra le code plus modulaire, plus lisible, plus sûr et plus facile à maintenir.

Test de mémorisation/compréhension​


Qu'est-ce qu'une variable globale en PHP ?


Qu'est-ce qu'une variable locale en PHP ?


Qu'est-ce qu'une variable statique en PHP ?


Quel tableau superglobal PHP permet d'accéder à une variable globale sans utiliser le mot-clé `global` à l'intérieur d'une fonction ?


Quel est le risque d'utiliser une variable globale, puisqu'elle est accessible de n'importe où dans le code ?


Quelle méthode est préférable à l'utilisation de `global $x;` à l'intérieur d'une fonction ?


Quel mot-clé PHP permet de déclarer une variable qui, bien qu'elle soit à l'intérieur d'une fonction, conserve sa valeur entre les appels successifs ?


Quelle est la portée par défaut d'une variable déclarée à l'intérieur d'une fonction en PHP ?


Exercice pratique​

Dans cet exercice, nous allons explorer davantage la portée des variables en PHP. Vous allez travailler avec deux variables qui portent le même nom mais qui ont une portée différente. Le but est de comprendre comment la portée des variables peut affecter leur valeur et leur comportement.

  • Dans votre répertoire "Documents" créez le répertoire tp_changer_valeur.
  • Dans ce répertoire créez le fichier main.php : 
    <?php
    // Changer la valeur d'une variable
    print("Changer la valeur d'une variable \n\n");
  • Testez le fonctionnement de ce fichier : 
    php main.php


  1. Créez une variable $x à l'extérieur d'une fonction et attribuez-lui la valeur 10.

    $x = 10;

  2. Créez une fonction changerValeur qui déclare une variable $x avec la valeur 20.

    function changerValeur() {
        // Variable locale $x


    }

  3. À l'intérieur de la fonction changerValeur, affichez la valeur de $x.

    function changerValeur() {
        // Variable locale $x
        $x = 20;
        print(...); // Affiche 20


    }

  4. Après avoir appelé changerValeur, affichez la valeur de $x.

    $x = 10;

    function changerValeur() {
        $x = 20;
        print(...); // Affiche 20
    } 

    changerValeur();
    print(...); // Affiche 10

  5. À l'intérieur de changerValeur, essayez d'afficher la valeur de $x déclarée à l'extérieur de la fonction en utilisant le mot-clé global.

    $x = 10;

    function changerValeur() {
        $x = 20;
        print(...); // Affiche 20

        global $x;
        print(...); // Affiche 10
    }

    changerValeur();
    print(...); // Affiche 10
Une solution

TP pour réfléchir et résoudre des problèmes​

Créer une mini-calculatrice

Dans ce TP, vous allez créer une mini-calculatrice avec des fonctions : chaque fonction reçoit ses données via des paramètres et retourne un résultat via return. Aucun global, aucun static.

L'objectif : maîtriser la portée locale, la portée par défaut en PHP.

Bonne pratique : éviter les variables globales

Évitez d'utiliser des variables globales pour partager des données entre fonctions. Préférez les paramètres de fonction et les valeurs de retour pour une meilleure lisibilité, maintenabilité et testabilité du code.

  • Dans votre répertoire "Documents" créez le répertoire tp_calculatrice.
  • Dans ce répertoire créez le fichier main.php : 
    <?php
    print("=== Calculatrice ===\n\n");
  • Testez : 
    php main.php

Étape 1 — Fichier de base​

Étape 2 — Créer additionner($a, $b) avec variable locale​

Créez la fonction additionner($a, $b). Elle calcule la somme dans une variable locale $resultat et la retourne.

function additionner($a, $b) {
    $resultat = $a + $b;  // portée locale
    return $resultat;
}

Étape 3 — Créer multiplier($a, $b) — même nom, variable indépendante​

Créez multiplier($a, $b). Elle utilise aussi une variable locale $resultat — c'est un nom identique mais une variable totalement indépendante de celle dans additionner().


Indépendance des variables locales

Deux fonctions peuvent avoir des variables avec le même nom : elles sont complètement indépendantes. $resultat dans additionner() et $resultat dans multiplier() n'interfèrent jamais.

Étape 4 — Appeler les deux fonctions et observer​

Appelez additionner(5, 3) et multiplier(4, 6). Stockez les retours dans $somme et $produit.

$somme   = additionner(5, 3);   // $resultat local à additionner : vaut 8
$produit = multiplier(4, 6);    // $resultat local à multiplier  : vaut 24

Étape 5 — Créer formaterOperation(...) avec variable locale $texte​

Créez formaterOperation($symbole, $a, $b, $valeur) : elle construit une variable locale $texte et la retourne.

function formaterOperation($symbole, $a, $b, $valeur) {
    $texte = "$a $symbole $b = $valeur";  // portée locale
    return $texte;
}

Étape 6 — Afficher les résultats​

Passez $somme et $produit à formaterOperation() et affichez le résultat.

Résultat attendu :

5 + 3 = 8
4 * 6 = 24

Étape 7 — Observer la portée locale​

Les variables $resultat et $texte existent à l'intérieur des fonctions. En dehors, elles n'existent pas.

// $somme et $produit : accessibles (déclarées dans le script principal)
echo "Somme : $somme, Produit : $produit\n";

// $resultat et $texte : inaccessibles (locales aux fonctions)
// echo $resultat;  // ⚠️ Warning: Undefined variable
// echo $texte;     // ⚠️ Warning: Undefined variable

Bonne pratique — fonctions pures
  • Paramètre : faire entrer une donnée dans une fonction
  • return : faire sortir une donnée d'une fonction
  • Portée locale : les variables internes restent privées → pas d'effets de bord
  • Une fonction qui ne dépend que de ses paramètres et retourne un résultat est appelée fonction pure : facile à tester, facile à réutiliser

Une solution complète​

Une solution possible pour l'ensemble du TP