Changement dans la gestion des références
Présentation
Du point de vue du programmeur, le changement qui aura le plus d'impact sur le code déjà écrit est la manière avec laquelle les références sont gérées dans les versions PHP 4.4.0 et plus récentes.
Jusqu'à la version PHP 4.3 incluse, il était possible d'envoyer, assigner ou retourner des variables par références, alors qu'elles auraient dues être retournées par valeur, comme des constantes, des valeurs temporaires (comme le résultat d'une expression), ou le résultat d'une fonction qui elle-même, retourne une valeur.
<?php
$foo = "123";
function return_value() {
global $foo;
return $foo;
}
$bar = &return_value();
?>
Même si ce code fonctionne tel qu'attendu en PHP 4.3, en général il conduit à une situation indéfinie. Le moteur Zend ne peut pas fonctionner correctement avec des valeurs passées par références. Ce bogue peut et a conduit à des corruptions de mémoire difficiles à reproduire, notamment lorsque le code de l'application est compliqué.
En PHP 4.4.0, PHP 5.0.4 et toutes les versions plus récentes, le moteur
Zend a été modifié pour reconnaître les cas où une valeur ne doit pas
être utilisée par référence. La valeur réelle est maintenant utilisée
dans ces cas, et une alerte est émise. Cette alerte prend la forme d'un
message E_NOTICE en PHP 4.4.0 et plus récent, et
E_STRICT en PHP 5.0.4 et plus récent.
Du code qui pouvait produire des corruptions de mémoire ne peut plus le faire. Cependant, certains codes anciens peuvent fonctionner de manière différente.
Code qui fonctionnait en 4.3.x, mais qui échoue maintenant
<?php
function func(&$arraykey) {
return $arraykey; // la fonction retourne par valeur!
}
$array = array('a', 'b', 'c');
foreach (array_keys($array) as $key) {
$y = &func($array[$key]);
$z[] =& $y;
}
var_dump($z);
?>
<
L'exécution du script ci-dessus dans une version de PHP antérieure à la correction du bogue produit ce résultat :
array(3) {
[0]=>
&string(1) "a"
[1]=>
&string(1) "b"
[2]=>
&string(1) "c"
}
Après la correction du bogue, cela donne :
array(3) {
[0]=>
&string(1) "c"
[1]=>
&string(1) "c"
[2]=>
&string(1) "c"
}
Ceci est dû au fait que func() effectue une assignation
par valeur. La valeur de $y est réassignée, et que la
liaison par référence avec $z est préservée. Avant la
correction du bogue, la valeur était assignée par référence, faisant que
la variable $y était réassignée à chaque assignement.
La tentative de liaison avec une valeur temporaire est la cause
de la corruption de la mémoire.
Ce code peut être réparé pour fonctionner à l'identique avec des versions
pré et post-correction. La signature de func() peut être
modifiée pour retourner les valeurs par référence, ou bien l'affectation
par référence peut être supprimée du résultat de func().
<?php
function func() {
return 'function return';
}
$x = 'original value';
$y =& $x;
$y = &func();
echo $x;
?>
En PHP 4.3, $x vaudrait 'original value', alors qu'après le changement, il
vaudrait 'function return' : n'oubliez pas que la fonction ne retourne plus
par référence, et que la référence est convertie en affectation par valeur.
Encore une fois, cela peut être corrigé en forçant func() à retourner par
référence, ou bien en éliminant l'affectation par référence.
Code qui fonctionnait en PHP 4.3.x, mais qui émet maintenant une erreur
<?php
class Foo {
function getThis() {
return $this;
}
function destroyThis() {
$baz =& $this->getThis();
}
}
$bar = new Foo();
$bar->destroyThis();
var_dump($bar);
?>
En PHP 5.0.3, $bar vaut NULL au
lieu de l'objet attendu. Cela arrive car getThis()
retourne une valeur, mais que la valeur est assignée par référence.
Même si cela fonctionne désormais comme attendu, ce code est en
fait invalide, et émettra une alerte E_NOTICE sous
PHP 4.4 ou E_STRICT en PHP 5.0.4 et plus récent.
Code qui échouaient en PHP 4.3.x, mais qui fonctionne maintenant
<?php
function &f() {
$x = "foo";
var_dump($x);
print "$x\n";
return($a);
}
for ($i = 0; $i < 3; $i++) {
$h = &f();
}
?>
En PHP 4.3, le troisième appel à var_dump() produit
NULL, à cause d'une correction de la mémoire, causée
par le retour d'une valeur non initialisée par référence. C'est du code
valide en PHP 5.0.4 et plus récent, mais il produit une erreur dans les
versions plus anciennes.
<?php
$arr = array('a1' => array('alfa' => 'ok'));
$arr =& $arr['a1'];
echo '-'.$arr['alfa']."-\n";
?>
Jusqu'en PHP 5.0.5, il n'était pas possible d'assigner un élément de tableau par référence de cette manière. C'est corrigé maintenant.
Code qui aurait du fonctionner en PHP 5.0.x
Il y a quelques cas de bogues rapportés en PHP PHP 5.0 avant la correction
de ce bogue qui 'refonctionnent'. Cependant, dans tous les cas, des erreurs
sont émises en PHP 5.1.x, car le code est invalide. Retourner des références
avec self:: fonctionne maintenant, mais émet une alerte
E_STRICT, et même si votre expérience est différente
lors de l'assignation d'un objet par référence, vous verrez toujours une
erreur E_ERROR lorsque vous tentez cela même si
l'assignation semble fonctionner.
Alertes qui vont et viennent
Des appels imbriqués à des fonctions retournant des valeurs par référence
sont valides en PHP 4.3.x et PHP 5.1.x, mais ils émettent des erreurs
E_NOTICE et E_STRICT dans les
nouvelles versions de PHP.
<?php
function & foo() {
$var = 'ok';
return $var;
}
function & bar() {
return foo();
}
$a =& bar();
echo "$a\n";
?>
add a note
