## 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 l'on assigne, passe, ou retourne, 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 :

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

Utiliser la même syntaxe avec une fonction qui ne retourne pas par référence génèrera une erreur, comme l'utiliser avec le résultat de l'opérateur new. Bien que les objets soient passés comme des pointeurs, ceci n'est pas identique aux références comme expliqué dans la section les Objets et références.

Avertissement

Si une référence est assignée à une variable déclarée comme `global` dans une fonction, la référence ne sera visible qu'au sein de la fonction. Il est possible d'é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'

Considérer `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 une valeur est assignée à 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éées 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); */
    var_dump($a);
    var_dump($b);

Il est à noter 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
    print "a = {$a}; b = {$b}; c = {$c}\n\n";

    /* 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 ! */
    print "a = {$a}\n";
    var_dump($arr);
    var_dump($arr2);

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 à une fonction et par une variable du contexte appelant. Par exemple :

    <?php
    function foo(&$var)
    {
        $var++;
    }

    $a = 5;
    foo($a);
    print $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, 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.

`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open