PHP 5.6.0beta1 released

Retourner des références

Retourner des références est utile lorsque vous voulez utiliser une fonction pour déterminer à quelle variable une référence devrait être liée. 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 des références uniquement lorsque vous avez de bonnes raisons techniques de le faire ! Pour retourner des références, utilisez cette syntaxe :

<?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 nous n'avions pas utilisé la syntaxe de référence.

Note: Contrairement au passage de paramètre, ici, vous devez utiliser & aux deux endroits, à la fois pour indiquer que vous retournez par référence (pas par copie), et pour indiquer que vous assignez aussi par référence (pas par copie non plus) 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, et pas de la variable, par référence. Vous ne pouvez retourner que des variables par référence depuis une fonction - et rien d'autre. Depuis PHP 4.4.0 dans la branche PHP 4, et PHP 5.1.0 dans la branche PHP 5, 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.

Pour utiliser la référence retournée, vous devez utiliser l'assignement par référence :

<?php
function &collector() {
  static 
$collection = array();
  return 
$collection;
}
$collection = &collector();
$collection[] = 'foo';
?>
Pour passer la référence retournée à une autre fonction attendant une référence, vous pouvez utiliser la syntaxe suivante :
<?php
function &collector() {
  static 
$collection = array();
  return 
$collection;
}
array_push(collector(), 'foo');
?>

Note: Notez que array_push(&collector(), 'foo'); ne fonctionnera pas, et résultera en une erreur fatale.

add a note add a note

User Contributed Notes 15 notes

up
12
Spad-XIII
6 years ago
a little addition to the example of pixel at minikomp dot com here below
<?php

   
function &func(){
        static
$static = 0;
       
$static++;
        return
$static;
    }

   
$var1 =& func();
    echo
"var1:", $var1; // 1
   
func();
   
func();
    echo
"var1:", $var1; // 3
   
$var2 = func(); // assignment without the &
   
echo "var2:", $var2; // 4
   
func();
   
func();
    echo
"var1:", $var1; // 6
   
echo "var2:", $var2; // still 4

?>
up
6
obscvresovl at NOSPAM dot hotmail dot com
9 years ago
An example of returning references:

<?

$var
= 1;
$num = NULL;

function &
blah()
{
   
$var =& $GLOBALS["var"]; # the same as global $var;
   
$var++;
    return
$var;
}

$num = &blah();

echo
$num; # 2

blah();

echo
$num; # 3

?>

Note: if you take the & off from the function, the second echo will be 2, because without & the var $num contains its returning value and not its returning reference.
up
7
stanlemon at mac dot com
6 years ago
I haven't seen anyone note method chaining in PHP5.  When an object is returned by a method in PHP5 it is returned by default as a reference, and the new Zend Engine 2 allows you to chain method calls from those returned objects.  For example consider this code:

<?php

class Foo {

    protected
$bar;

    public function
__construct() {
       
$this->bar = new Bar();

        print
"Foo\n";
    }   
   
    public function
getBar() {
        return
$this->bar;
    }
}

class
Bar {

    public function
__construct() {
        print
"Bar\n";
    }
   
    public function
helloWorld() {
        print
"Hello World\n";
    }
}

function
test() {
    return new
Foo();
}

test()->getBar()->helloWorld();

?>

Notice how we called test() which was not on an object, but returned an instance of Foo, followed by a method on Foo, getBar() which returned an instance of Bar and finally called one of its methods helloWorld().  Those familiar with other interpretive languages (Java to name one) will recognize this functionality.  For whatever reason this change doesn't seem to be documented very well, so hopefully someone will find this helpful.
up
2
sandaimespaceman at gmail dot com
5 years ago
The &b() function returns a reference of $a in the global scope.

<?php
$a
= 0;
function &
b()
{
    global
$a;
    return
$a;
}
$c = &b();
$c++;
echo
"
\$a:
$a
\$b:
$c
"
?>

It outputs:

$a: 1 $b: 1
up
2
zayfod at yahoo dot com
10 years ago
There is a small exception to the note on this page of the documentation. You do not have to use & to indicate that reference binding should be done when you assign to a value passed by reference the result of a function which returns by reference.

Consider the following two exaples:

<?php

function    & func_b ()
{
   
$some_var = 2;
    return
$some_var;
}

function   
func_a (& $param)
{
   
# $param is 1 here
   
$param = & func_b();
   
# $param is 2 here
}

$var = 1;
func_a($var);
# $var is still 1 here!!!

?>

The second example works as intended:

<?php

function    & func_b ()
{
   
$some_var = 2;
    return
$some_var;
}

function   
func_a (& $param)
{
   
# $param is 1 here
   
$param = func_b();
   
# $param is 2 here
}

$var = 1;
func_a($var);
# $var is 2 here as intended

?>

(Experienced with PHP 4.3.0)
up
1
rwruck
8 years ago
The note about using parentheses when returning references is only true if the variable you try to return does not already contain a reference.

<?php
// Will return a reference
function& getref1()
  {
 
$ref =& $GLOBALS['somevar'];
  return (
$ref);
  }

// Will return a value (and emit a notice)
function& getref2()
  {
 
$ref = 42;
  return (
$ref);
  }

// Will return a reference
function& getref3()
  {
  static
$ref = 42;
  return (
$ref);
  }
?>
up
1
willem at designhulp dot nl
8 years ago
There is an important difference between php5 and php4 with references.

Lets say you have a class with a method called 'get_instance' to get a reference to an exsisting class and it's properties.

<?php
class mysql {
    function
get_instance(){
       
// check if object exsists
       
if(empty($_ENV['instances']['mysql'])){
           
// no object yet, create an object
           
$_ENV['instances']['mysql'] = new mysql;
        }
       
// return reference to object
       
$ref = &$_ENV['instances']['mysql'];
        return
$ref;
    }
}
?>

Now to get the exsisting object you can use
mysql::get_instance();

Though this works in php4 and in php5, but in php4 all data will be lost as if it is a new object while in php5 all properties in the object remain.
up
0
Anonymous
1 month ago
I learned a painful lesson working with a class method that would pass by reference.  

In short, if you have a method in a class that is initialed with ampersand during declaration, do not use another ampersand when using the method as in &$this->method();

For example
<?php
class A {
    public function &
hello(){
        static
$a='';
        return
$a;
    }
    public function
bello(){
       
$b=&$this->hello();  // incorrect. Do not use ampersand.
       
$b=$this->hello();  // $b is a reference  to the static variable.
}
?>
up
0
benjamin dot delespierre at gmail dot com
3 years ago
Keep in mind that returning by reference doesn't work with __callStatic:

<?php
class Test {
  private static
$_inst;
  public static function &
__callStatic ($name, $args) {
    if (!isset(static::
$_inst)){
      echo
"create";
      static::
$_inst = (object)"test";
   }
   return static::
$_inst;
}

var_dump($a = &Test::abc()); // prints 'create'
$a = null;
var_dump(Test::abc()); // doesn't prints and the instance still exists in Test::$_inst
?>
up
0
szymoncofalik at gmail dot com
3 years ago
Sometimes, you would like to return NULL with a function returning reference, to indicate the end of chain of elements. However this generates E_NOTICE. Here is little tip, how to prevent that:

<?php
class Foo {
   const
$nullGuard = NULL;
  
// ... some declarations and definitions
  
public function &next() {
     
// ...
     
if (!$end) return $bar;
      else return
$this->nullGuard;
   }
}
?>

by doing this you can do smth like this without notices:

<?php
$f
= new Foo();
// ...
while (($item = $f->next()) != NULL) {
// ...
}
?>

you may also use global variable:
global $nullGuard;
return $nullGuard;
up
0
spidgorny at gmail dot com
4 years ago
When returning reference to the object member which is instantiated inside the function, the object is destructed upon returning (which is a problem). It's easier to see the code:

<?php

class MemcacheArray {
    public
$data;

    ...

   
/**
     * Super-clever one line cache reading AND WRITING!
     * Usage $data = &MemcacheArray::getData(__METHOD__);
     * Hopefully PHP will know that $this->data is still used
     * and will call destructor after data changes.
     * Ooops, it's not the case.   
     *
     * @return unknown
     */
   
function &getData($file, $expire = 3600) {
       
$o = new MemcacheArray($file, $expire);
        return
$o->data;
    }
?>

Here, destructor is called upon return() and the reference becomes a normal variable.

My solution is to store objects in a pool until the final exit(), but I don't like it. Any other ideas?

<?php
   
protected static $instances = array();

    function &
getData($file, $expire = 3600) {
       
$o = new MemcacheArray($file, $expire);
       
self::$instances[$file] = $o; // keep object from destructing too early
       
return $o->data;
    }
?>
up
0
php at thunder-2000 dot com
7 years ago
If you want to get a part of an array to manipulate, you can use this function

function &getArrayField(&$array,$path) {
  if (!empty($path)) {
    if (empty($array[$path[0]])) return NULL;
    else return getArrayField($array[$path[0]], array_slice($path, 1));
  } else {
    return $array;
  }
}

Use it like this:

$partArray =& getArrayField($GLOBALS,array("config","modul1"));

You can manipulate $partArray and the changes are also made with $GLOBALS.
up
0
contact at infopol dot fr
10 years ago
A note about returning references embedded in non-reference arrays :

<?
$foo
;

function
bar () {
    global
$foo;
   
$return = array();
   
$return[] =& $foo;
    return
$return;
}

$foo = 1;
$foobar = bar();
$foobar[0] = 2;
echo
$foo;
?>

results in "2" because the reference is copied (pretty neat).
up
-1
pixel at minikomp dot com
6 years ago
<?php

   
function &func(){
        static
$static = 0;
       
$static++;
        return
$static;
    }

   
$var =& func();
    echo
$var; // 1
   
func();
   
func();
   
func();
   
func();
    echo
$var; // 5

?>
up
-1
hawcue at yahoo dot com
10 years ago
Be careful when using tinary operation condition?value1:value2

See the following code:

$a=1;
function &foo()
{
  global $a;
  return isset($a)?$a:null;
}
$b=&foo();
echo $b;   // shows 1
$b=2;
echo $a;   // shows 1 (not 2! because $b got a copy of $a)

To let $b be a reference to $a, use "if..then.." in the function.
To Top