What References Do

There are three basic operations performed using references:
, ,
and . This section will give an introduction to these
operations, with links for further reading.

assigning by referencepassing by referencereturning by reference

Assign By Reference

 In the first of these, PHP references allow you to make two
 variables refer to the same content. Meaning, when you do:
 
 it means that  and 
 point to the same content.
 
```php


`$a``$b`> **Opmerking:** > and  are completely
>        equal here.  is not pointing to
>         or vice versa.
>         and  are pointing to the
>        same place.
>       `$a``$b``$a``$b``$a``$b`



> **Opmerking:** > If you assign, pass, or return an undefined variable by reference, 
>       it will get created.
>       
>      **Voorbeeld: Using references with undefined variables**
> 
> ```php
> <?php
> 
> function foo(&$var) {}
> 
> foo($a); // $a is "created" and assigned to 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)
> 
> ?>
> ```


     The same syntax can be used with functions that return
     references:
     
    ```php
<?php

$foo =& find_var($bar);

?>

 Using the same syntax with a function that does 
 return by reference will give an error, as will using it with the result
 of the  operator.
 Although objects are passed around as pointers, these are not the same as references,
 as explained under .
*not*newObjects and references

Waarschuwing: > If you assign a reference to a variable declared inside a function, the reference will be visible only inside the function. You can avoid this by using the array.

  Think about  as a shortcut to . Thus assigning another reference
  to  only changes the local variable's reference.
 `global``$GLOBALS`**Voorbeeld: Referencing global variables inside functions**

<?php

$var1 = "Example variable";
$var2 = "";

function global_references($use_globals)
{
    global $var1, $var2;

    if (!$use_globals) {
        $var2 =& $var1; // visible only inside the function
    } else {
        $GLOBALS["var2"] =& $var1; // visible also in global context
    }
}

global_references(false);
echo "var2 is set to '$var2'\n"; // var2 is set to ''

global_references(true);
echo "var2 is set to '$var2'\n"; // var2 is set to 'Example variable'

?>

global $var;``$var =& $GLOBALS['var'];``$var

Opmerking: > If you assign a value to a variable with references in a foreach statement, the references are modified too.
 **Voorbeeld: References and foreach statement**
<?php

$ref = 0;
$row =& $ref;

foreach (array(1, 2, 3) as $row) {
    // Do something
}

echo $ref; // 3 - last element of the iterated array

?>

 While not being strictly an assignment by reference, expressions created
 with the language construct
  can also
 behave as such by prefixing  to the array element
 to add. Example:
 
array()`&amp;````php





     Note, however, that references inside arrays are potentially dangerous.
     Doing a normal (not by reference) assignment with a reference on the
     right side does not turn the left side into a reference, but references
     inside arrays are preserved in these normal assignments. This also applies
     to function calls where the array is passed by value. Example:
     
     In other words, the reference behavior of arrays is defined in an
     element-by-element basis; the reference behavior of individual elements
     is dissociated from the reference status of the array container.
    ```php
<?php

/* Assignment of scalar variables */
$a = 1;
$b =& $a;
$c = $b;
$c = 7; // $c is not a reference; no change to $a or $b

/* Assignment of array variables */
$arr = array(1);
$a =& $arr[0]; // $a and $arr[0] are in the same reference set
$arr2 = $arr; // Not an assignment-by-reference!
$arr2[0]++;
/* $a == 2, $arr == array(2) */
/* The contents of $arr are changed even though it's not a reference! */

?>

Pass By Reference

 The second thing references do is to pass variables by
 reference. This is done by making a local variable in a function
 and a variable in the calling scope referencing the same
 content. Example:
 
 will make  to be 6. This happens because in
 the function  the variable
  refers to the same content as
 . For more information on this, read
 the  section.
```php


`$a``foo``$var``$a`passing by
       reference

### Return By Reference


     The third thing references can do is .
    return by reference

Vorige ← What References Are Volgende What References Are Not →

What References Do

What References Do

Assign By Reference

Pass By Reference

Documentatie