Variables PHP : déclaration, portée, global et static

Une variable PHP est un nom qui commence par $, et vous la créez en lui affectant une valeur : $name = "Ada";. Il n'y a ni mot-clé de déclaration ni type à préciser, car c'est la valeur qui décide du type. Vous pouvez plus tard lui affecter une valeur d'un autre type.

<?php
$name = "Ada";
$age = 36;
$height = 1.65;
$isAdmin = true;

echo "$name is $age years old\n";

$age = $age + 1;           // update the value
$age++;                    // add one more
echo "Two birthdays later: $age\n";

$age = "thirty-eight";     // the type can change too
echo "Now a string: $age\n";

Règles de nommage des variables

Un nom de variable commence par $, puis une lettre ou un tiret bas, puis des lettres, chiffres ou tirets bas. Les lettres non ASCII comptent comme des lettres, donc $名前 est valide, même si les noms ASCII sont la norme. Les noms sont sensibles à la casse.

$city, $City et $CITY sont donc trois variables différentes. Utilisez le snake_case ($first_name) ou le camelCase ($firstName), et tenez-vous à un seul style par projet. Les standards PSR laissent volontairement le nommage des variables libre ; le code Laravel et Symfony utilise surtout le camelCase.

Utiliser des variables dans des chaînes

Entre guillemets doubles, PHP remplace les variables par leur valeur ; entre guillemets simples, non. Entourez la variable d'accolades quand des lettres la suivent directement ou quand vous accédez à un élément de tableau par une clé de type chaîne :

<?php
$fruit = "apple";
$basket = ["count" => 4];

echo "I like $fruit pie\n";
echo 'I like $fruit pie' . "\n";              // single quotes: printed as written
echo "Two {$fruit}s please\n";                // braces separate the name
echo "There are {$basket['count']} left\n";   // array key inside a string
echo "Joined: " . $fruit . " and pear\n";     // concatenation with .

La page sur les chaînes détaille les guillemets, la concaténation et l'interpolation.

Variables non définies et valeurs par défaut

Lire une variable jamais affectée donne null, et votre PHP affiche un warning :

Warning: Undefined variable $discount in /home/index.php on line 3

Vérifiez d'abord avec isset, ou utilisez l'opérateur de fusion null ?? pour fournir une valeur par défaut. Les deux s'exécutent sans warning :

<?php
$price = 50;

$discount = $discount ?? 0;    // use 0 when $discount is not set
echo "Price: " . ($price - $discount) . "\n";

if (isset($coupon)) {
    echo "Coupon: $coupon\n";
} else {
    echo "No coupon given\n";
}

$coupon = null;
var_dump(isset($coupon));      // a variable holding null counts as not set

$x ??= 0; est la forme courte de $x = $x ?? 0;. Les valeurs de formulaire et d'URL sont le cas habituel : $page = $_GET['page'] ?? 1;.

La portée des variables dans les fonctions

Les variables définies hors d'une fonction ne sont pas visibles à l'intérieur, et les variables créées dans une fonction disparaissent quand elle se termine. C'est la surprise la plus fréquente pour qui vient de JavaScript :

<?php
$taxRate = 0.2;

function priceWithTax($price)
{
    // $taxRate does not exist here, so ?? falls back to 0
    return $price * (1 + ($taxRate ?? 0));
}

function priceWithTaxFixed($price, $rate)
{
    return $price * (1 + $rate);   // pass what the function needs
}

echo priceWithTax(100), "\n";
echo priceWithTaxFixed(100, $taxRate), "\n";

Sans le ?? 0, la première fonction afficherait un warning sur $taxRate non définie. Passer les valeurs en paramètres rend les fonctions prévisibles et faciles à tester, et c'est la première solution à envisager. La page sur les fonctions traite des paramètres et des valeurs de retour.

Le mot-clé global et $GLOBALS

Quand une fonction doit vraiment utiliser une variable globale, déclarez-la avec global, ou passez par le tableau $GLOBALS, qui contient toutes les variables globales par leur nom :

<?php
$visits = 0;
$siteName = "Bakery";

function countVisit()
{
    global $visits;      // now $visits refers to the global variable
    $visits++;
}

function title()
{
    return "Welcome to " . $GLOBALS['siteName'];
}

countVisit();
countVisit();
echo "Visits: $visits\n";
echo title(), "\n";

Les globales rendent le code plus difficile à suivre, car n'importe quelle fonction peut les modifier. On les trouve dans du code ancien et dans les plugins WordPress (global $wpdb;) ; dans du code neuf, passez les valeurs en paramètres ou utilisez une classe.

Les variables static gardent leur valeur

Une variable static dans une fonction est créée une seule fois et garde sa valeur entre les appels. Elle reste locale : le code hors de la fonction ne la voit pas.

<?php
function nextTicket(): int
{
    static $number = 100;   // runs only on the first call
    $number++;
    return $number;
}

echo nextTicket(), "\n";
echo nextTicket(), "\n";
echo nextTicket(), "\n";

function expensiveLookup(string $key): string
{
    static $cache = [];
    if (!isset($cache[$key])) {
        echo "(computing $key) ";
        $cache[$key] = strtoupper($key);
    }
    return $cache[$key];
}

echo expensiveLookup("php"), "\n";
echo expensiveLookup("php"), "\n";   // second call uses the cache

Les variables dynamiques ($$name)

$$name utilise la valeur de $name comme nom d'une autre variable. Cela fonctionne, mais un tableau fait presque toujours le même travail plus clairement :

<?php
$field = "color";
$$field = "blue";        // creates $color
echo $color, "\n";

// The clearer way to have names chosen at runtime:
$settings = [];
$settings[$field] = "blue";
echo $settings["color"], "\n";

Copie ou référence

Affecter une variable à une autre copie la valeur, tableaux compris. Ajoutez & devant pour que les deux noms désignent la même valeur :

<?php
$a = [1, 2, 3];
$b = $a;          // copy
$b[] = 4;
echo "a has " . count($a) . ", b has " . count($b) . "\n";

$c = &$a;         // reference: $c and $a are the same array
$c[] = 99;
echo "a has " . count($a) . " after changing c\n";

function addBonus(int &$points)
{
    $points += 10;
}
$score = 5;
addBonus($score);
echo "Score: $score\n";

unset($b);
var_dump(isset($b));

Les objets se comportent autrement : affecter un objet copie une poignée vers le même objet, donc une modification faite via l'une des variables est visible via l'autre. Utilisez clone pour une vraie copie.

Erreur fréquente : une variable définie dans un if ou une boucle

PHP n'a pas de portée de bloc, donc une variable créée dans un if, un for ou un foreach existe encore après. C'est pratique, mais cela cache un bug : quand le bloc ne s'exécute pas, la variable n'a jamais été créée.

<?php
$orders = [];   // try [120, 80] here

$message = "No orders yet";   // set a default before the loop
foreach ($orders as $amount) {
    $message = "Last order: $amount";
}
echo $message, "\n";

foreach ([1, 2, 3] as $n) {
    $last = $n;
}
echo "Still visible after the loop: $last\n";

Sans la ligne qui donne une valeur par défaut, un $orders vide laisserait $message non définie et afficherait un warning. Donnez une valeur à chaque variable avant le bloc qui pourrait la définir.