Les références en PHP

Les références en PHP

En PHP, les références sont destinées à appeler le contenu d'une variable avec un autre nom.

Le nom de la variable et son contenu ont des noms différents, ce qui fait que l'on peut donner plusieurs noms au même contenu.

Pour bien comprendre ce concept on va faire une analogie avec les fichiers.

Quand vous créez un fichier avec un contenu, vous pouvez aussi créer un autre fichier avec un autre nom mais avec le même contenu, les deux fichier font référence au même contenu.

C’est ce que fait PHP avec les variables.

Que font les références ?

Il y a 3 utilisations principales des références:
assignation par référence,
passage par référence,
et retourner par référence.
Cette section introduit ces opérations.

Assignation par référence

Dans ce premier cas.

Les références vous permettent de faire pointer deux variables sur le même contenu. Par exemple, lorsque vous écrivez:

Exemple :      Copier le code

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

Veut dire que $a et $b pointent sur le même contenu.

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

NOTE :

Si un tableau par référence est copié, ses valeurs ne sont pas déréférencées. Cela est valide également pour les tableaux passés par valeur aux fonctions.

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

Les références et new()

Exemple :      Copier le code

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

Depuis PHP 5, new retourne une référence automatiquement, donc, l'utilisation de =& dans ce contexte est déprécié (n’est plus utilisé) et produit un message de degré E_STRICT.

Note :

A moins d'utiliser la syntaxe ci-dessus, le résultat de $bar = new fooclass() ne sera pas la même variable que $this dans le constructeur, ce qui signifie que si vous avez utilisé la référence $this dans le constructeur, vous devez assigner la référence, ou bien obtenir deux objets différents.

Même si vous pouvez utiliser l'opérateur @ pour supprimerles messages d'erreurs du constructeur avec la syntaxe @new , cela ne fonctionnera pas avec la syntaxe &new . C'est une limitation du moteur Zend, et cela conduit à une erreur d'analyse

Attention :

Si vous assignez une référence à une variable définie en tant que global dans une fonction, la référence sera visible uniquement à l'intérieure de la fonction. Vous pouvez éviter cela en utilisant le tableau $GLOBALS

Référencer une variable globale à l'intérieure d'une fonction

Exemple :      Copier le code

<?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 un 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 assignant d'autres références à $var changeant uniquement la référence local de la variable.

Note :

Si vous assignez des valeurs par références dans une structure foreach , les références seront également modifiées.

Références et structure foreach

Exemple :      Copier le code

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

Attention :

Les tableaux complexes sont parfois plutôt copiés que référencés. De ce fait, l'exemple suivant ne fonctionnera pas comme prévu :

Références avec un tableau complexe

Exemple :      Copier le code

<?php
$top = array(
	'A' => array(),
	'B' => array(
		'B_b' => array(),
	),
);
$top['A']['parent'] = &$top;
$top['B']['parent'] = &$top;
$top['B']['B_b']['data'] = 'test';
print_r($top['A']['parent']['B']['B_b']); // array()
?>

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 tel en préfixant par &l'élément du tableau.

Exemple:

Exemple :      Copier le code

  <?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'expression en référence, mais les références dans les tableaux sont préservées. Ceci s'applique aussi aux appels de fonctions avec un tableau passé par valeur.

Exemple:

Exemple :      Copier le code

  <?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! */
  ?>

Passage par référence

Le deuxième intérêt des références est de pouvoir passer des variables par référence. On réalise ceci en faisant pointer des variables locales vers le contenu des variables de fonction.

Exemple :

 Passage de paramètre par références

Exemple :      Copier le code

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

$a vaut 6. Cela provient du fait que dans la fonction foo , la variable $var pointe sur le même contenu que $a .

Retourner des références

Retourner des références est toujours utile lorsque vous voulez utiliser une fonction pour savoir à quoi est liée une variable. N'utilisez pas le retour par référence pour améliorer les performances, le moteur est suffisamment robuste pour optimiser cela en interne. Retournez uniquement des références lorsque vous avez techniquement une bonne raison de le faire ! Pour retourner des références, utilisez cette syntaxe :

Exemple :      Copier le code

  <?php
  class foo {
      public $value = 42;
  
      public function &getValue() {
          return $this->value;
      }
  }
  
  $obj = new foo;
  $myValue = &$obj->getValue();/* $myValue est une référence de $obj->value, qui vaut 42.*/

  $obj->value = 2;
  echo $myValue;                /* affiche la nouvelle valeur de $obj->value, i.e. 2.*/

  ?>

Dans cet exemple, on affecte une valeur à la propriété de l'objet retourné par la fonction getValue , et non à sa copie, comme ce serait le cas si on n'avait pas utilisé la syntaxe de référence.

Note:

 Contrairement au passage de paramètre, vous devez utiliser & aux deux endroits, à la fois pour indiquer que vous retournez par référence (pas une copie habituelle), et pour indiquer que vous assignez aussi par référence (pas la copie habituelle) pour la variable $myValue .

Note:

 Si vous tentez de retourner une référence depuis une fonction avec la syntaxe :return ($this->value);, cela ne fonctionnera pas comme vous l'attendez et retournera le résultat de l' expression , mais pas de la variable, par référence. Vous ne pouvez retourner des variables par référence que depuis une fonction - rien d'autre. Depuis PHP 4.4.0 et PHP 5.1.0, une alerte E_NOTICE est envoyée si le code tente de retourner une expression dynamique ou un résultat de l'opérateur new.

Détruire une référence

Lorsque vous détruisez une référence, vous ne faites que casser le lien entre le nom de la variable et son contenu. Cela ne signifie pas que le contenu est détruit.

Exemple :

Exemple :      Copier le code

  <?php
  $a = 1;
  $b =& $a;
  unset($a);
  ?>

Cet exemple ne détruira pas $b , mais juste $a .

Repérer une référence

De nombreuses syntaxes de PHP sont implémentées via le mécanisme de référence, et tout ce qui a été vu concernant les liaisons entre variables s'applique à ces syntaxes. Par exemple, le passage et le retour d'arguments par référence. Quelques autres exemples de syntaxes :

Références globales

Lorsque vous déclarez une variable global $var, vous créez en fait une référence sur une variable globale. Ce qui signifie que

Exemple :      Copier le code

  <?php
  $var =& $GLOBALS["var"];
  ?>

Et que, si vous détruisez la variable $var, la variable globale ne sera pas détruite.

Variable $this

Dans une méthode d'objet, $this il y a  toujours une référence sur l'objet courant.