Que font les références ?

Il existe trois principales utilisations des références : l'assignation par référence, le passage par référence, et le retour par référence. Cette section va introduire ces opérations, avec des liens vers plus de précisions.

Assignation par référence

Dans ce premier cas, les références PHP permettent de faire en sorte que deux variables référencent le même contenu. Par exemple :


<?php
$a =& $b;
?>

Cette écriture indique que $a et $b pointent sur le même contenu.

Note:
$a et $b sont complètement égales ici : ce n'est pas $a qui pointe sur $b, ou vice-versa. Ce sont bien $a et $b qui pointent sur le même contenu.

Note:
Si vous assignez, passez, ou retournez, une variable indéfinie par référence, elle sera créée automatiquement.

Exemple #1 Utilisation des références avec des variables indéfinies

<?php function foo(&$var) { } foo($a); // $a est "créée" et assignée à NULL $b = array(); foo($b['b']); var_dump(array_key_exists('b', $b)); // bool(true) $c = new StdClass; foo($c->d); var_dump(property_exists($c, 'd')); // bool(true) ?>

La même syntaxe peut être utilisée avec les fonctions qui retournent des références, et avec l'opérateur new (depuis PHP 4.0.4 et avant PHP 5.0.0) :


<?php
$foo =& find_var($bar);
?>

Depuis PHP 5, new retourne automatiquement une référence, donc l'utilisation de =& dans ce contexte est obsolète, et produit un message de niveau E_DEPRECATED à partir de PHP 5.3, et un message E_STRICT avec les versions antérieures. (Techniquement, la difference est qu'en PHP 5, les objets, comme les ressources en fait, sont des pointeurs vers la donnée réelle. La notion de "référence" ici est donc un peu différente de celle utilisée précédemment (alias). Pour plus d'informations, voyez Les objects et les références.)

Avertissement

Si vous assignez une référence à une variable déclarée comme global dans une fonction, la référence ne sera visible qu'au sein de la fonction. Vous pouvez éviter cela en utilisant le tableau $GLOBALS.

Exemple #2 Référencer des variables globales depuis des fonctions


<?php
$var1 = "Variable Exemple";
$var2 = "";

function global_references($use_globals)
{
    global $var1, $var2;
    if (!$use_globals) {
        $var2 =& $var1; // visible uniquement dans la fonction
    } else {
        $GLOBALS["var2"] =& $var1; // visible également dans le contexte global
    }
}

global_references(false);
echo "var2 est défini à '$var2'\n"; // var2 est défini à ''
global_references(true);
echo "var2 est défini à '$var2'\n"; // var2 est défini à 'Variable Exemple'
?>

Voyez global $var; comme un raccourci pour $var =& $GLOBALS['var'];. De ce fait, assigner une autre référence à $var modifie uniquement la référence locale de la variable.

Note:
Si vous assignez une valeur à une variable qui a des références dans une structure foreach, les références seront également modifiées.

Exemple #3 Références et structure foreach

<?php $ref = 0; $row =& $ref; foreach (array(1, 2, 3) as $row) { // faites quelque chose } echo $ref; // 3 - le dernier élément du tableau itéré ?>

Même si ce n'est pas strictement une assignation par référence, les expressions créees avec la structure de langage array() peuvent aussi se comporter comme telles, en préfixant par & l'élément du tableau. Voici un exemple :


<?php
$a = 1;
$b = array(2, 3);
$arr = array(&$a, &$b[0], &$b[1]);
$arr[0]++; $arr[1]++; $arr[2]++;
/* $a == 2, $b == array(3, 4); */
?>

Notez par contre que les références à l'intérieur des tableaux peuvent s'avérer dangereuses. Utiliser une assignation normale (pas par référence) avec une référence à droite de l'opérateur ne transforme pas la partie gauche de l'assignation en référence, mais les références à l'intérieur des tableaux sont préservées. Ceci s'applique également aux appels de fonctions avec un tableau passé par valeur. Exemple :


<?php
/* Assignation de variables scalaires */
$a = 1;
$b =& $a;
$c = $b;
$c = 7; // $c n'est pas une référence ; pas de changement à $a ou $b

/* Assignation de variables de type tableau */
$arr = array(1);
$a =& $arr[0]; // $a et $arr[0] sont des références vers la même valeur
$arr2 = $arr; // PAS une assignation par référence!
$arr2[0]++;
/* $a == 2, $arr == array(2) */
/* Les contenus de $arr sont changés même si ce n'était pas une référence ! */
?>

Autrement dit, d'un point de vue des références, le comportement des tableaux est défini élément par élément ; le comportement de chaque élément est indépendant du statut de référence du tableau qui les contient.

Passage par référence

Le deuxième intérêt des références est de permettre de passer des variables par référence. On réalise ceci en faisant référencer le même contenu par une variable locale à un fonction et par une variable du contexte appelant. Par exemple :


<?php
function foo(&$var) {
  $var++;
}
$a=5;
foo($a);
?>

Après l'exécution de cette portion de code, $a vaut 6. Cela provient du fait que, dans la fonction foo, la variable $var pointe sur le même contenu que $a. Pour plus d'informations à ce sujet, vous pouvez consulter la section passage par référence.

Retour par référence

Le troisième intérêt des références est de permettre le retour de valeurs par référence.