PHP
Les références

Syntaxe

• $foo = 1; $bar = &$foo; // both $foo and $bar point to the same value: 1
• $var = 1; function calc(&$var) { $var *= 15; } calc($var); echo $var;

Remarques

$foo = 1;
$bar = &$foo;

$baz = &$bar;
unset($bar);
$baz++;

Attribuer par référence

C'est la première phase du référencement. Essentiellement, lorsque vous attribuez par référence , vous permettez à deux variables de partager la même valeur.

$foo = &$bar;

$foo et $bar sont égaux ici. Ils ne se pointent pas les uns les autres. Ils indiquent le même endroit ( la "valeur" ).

Vous pouvez également affecter par référence dans la construction de langage array() . Bien que n'étant pas strictement une cession par référence.

$foo = 'hi';
$bar = array(1, 2);
$array = array(&$foo, &$bar[0]);

Notez cependant que les références dans les tableaux sont potentiellement dangereuses. Faire une affectation normale (pas par référence) avec une référence sur le côté droit ne transforme pas le côté gauche en référence, mais les références dans les tableaux sont conservées dans ces affectations normales. Cela s'applique également aux appels de fonction où le tableau est transmis par valeur.

L'affectation par référence n'est pas seulement limitée aux variables et aux tableaux, elle est également présente pour les fonctions et toutes les associations "pass-by-reference".

function incrementArray(&$arr) {
    foreach ($arr as &$val) {
        $val++;
    }
}

function &getArray() {
    static $arr = [1, 2, 3];
    return $arr;
}

incrementArray(getArray());
var_dump(getArray()); // prints an array [2, 3, 4]

L'affectation est la clé dans la définition de la fonction comme ci-dessus. Vous ne pouvez pas transmettre une expression par référence, uniquement une valeur / variable. D'où l'instanciation de $a in bar() .

Retour par référence

Il arrive parfois que vous ayez le temps de retourner implicitement par référence.

Le renvoi par référence est utile lorsque vous souhaitez utiliser une fonction pour trouver à quelle variable une référence doit être liée. N'utilisez pas le renvoi par référence pour améliorer les performances. Le moteur optimisera automatiquement cela seul. Ne renvoyez les références que lorsque vous avez une raison technique valable de le faire.

^{Tiré de la documentation PHP pour le renvoi par référence .}

De nombreux formulaires peuvent être retournés par référence, dont l'exemple suivant:

function parent(&$var) {
    echo $var;
    $var = "updated";
}

function &child() {
    static $a = "test";
    return $a;
}

parent(child()); // returns "test"
parent(child()); // returns "updated"

Le renvoi par référence ne se limite pas aux références de fonction. Vous avez également la possibilité d'appeler implicitement la fonction:

function &myFunction() {
    static $a = 'foo';
    return $a;
}

$bar = &myFunction();
$bar = "updated"
echo myFunction();

Vous ne pouvez pas référencer directement un appel de fonction, il doit être assigné à une variable avant de l'exploiter. Pour voir comment cela fonctionne, essayez simplement echo &myFunction(); .

Remarques

• Vous devez indiquer une référence ( & ) aux deux endroits que vous souhaitez utiliser. Cela signifie que pour votre définition de fonction ( function &myFunction() {... ) et dans la référence d'appel ( function callFunction(&$variable) {... ou &myFunction(); ).
• Vous ne pouvez renvoyer une variable que par référence. D'où l'instanciation de $a dans l'exemple ci-dessus. Cela signifie que vous ne pouvez pas retourner une expression, sinon une erreur PHP E_NOTICE sera générée ( Notice: Only variable references should be returned by reference in ...... ).
• Le retour par référence a des cas d'utilisation légitimes, mais je devrais avertir qu'ils devraient être utilisés avec parcimonie, seulement après avoir exploré toutes les autres options possibles pour atteindre le même objectif.

Passer par référence

Cela vous permet de passer une variable par référence à une fonction ou à un élément qui vous permet de modifier la variable d'origine.

Le passage par référence n'est pas limité aux variables uniquement, les éléments suivants peuvent également être transmis par référence:

• Nouvelles instructions, par exemple foo(new SomeClass)
• Références renvoyées par les fonctions

Tableaux

Une utilisation courante de "passer par référence" consiste à modifier les valeurs initiales dans un tableau sans aller jusqu'à créer de nouveaux tableaux ou à jeter des déchets dans votre espace de noms. Passer par référence est aussi simple que précéder / préfixer la variable avec un & => &$myElement .

Vous trouverez ci-dessous un exemple d’exploitation d’un élément d’un tableau et d’ajout de 1 à sa valeur initiale.

$arr = array(1, 2, 3, 4, 5);

foreach($arr as &$num) {
    $num++;
}

Maintenant, lorsque vous utilisez un élément dans $arr , l'élément d'origine sera mis à jour à mesure que la référence augmentera. Vous pouvez le vérifier en:

print_r($arr);

Remarque

Vous devriez prendre note lorsque vous utilisez le renvoi par référence dans les boucles. À la fin de la boucle ci-dessus, $num contient toujours une référence au dernier élément du tableau. L'attribuer post-boucle finira par manipuler le dernier élément du tableau! Vous pouvez vous assurer que cela ne se produit pas en le unset() en post-boucle:

$myArray = array(1, 2, 3, 4, 5);

foreach($myArray as &$num) {
   $num++;
}
unset($num);

Ce qui précède garantira que vous ne rencontrez aucun problème. Un exemple de problèmes pouvant en découler est présent dans cette question sur StackOverflow .

Les fonctions

Un autre usage courant du passage par référence se trouve dans les fonctions. La modification de la variable d'origine est aussi simple que:

$var = 5;
// define
function add(&$var) {
    $var++;
}
// call
add($var);

Ce qui peut être vérifié en faisant echo la variable d'origine.

echo $var;

Il existe diverses restrictions concernant les fonctions, comme indiqué ci-dessous dans les documents PHP:

Remarque: il n'y a pas de signe de référence sur un appel de fonction - uniquement sur les définitions de fonction. Les définitions de fonctions seules suffisent pour transmettre correctement l'argument par référence. À partir de PHP 5.3.0, vous recevrez un avertissement indiquant que "call-time pass-by-reference" est obsolète lorsque vous utilisez & in foo (& $ a) ;. Et à partir de PHP 5.4.0, le temps de référence référence à l’heure d’appel a été supprimé, ce qui entraîne une erreur fatale.