Explanation of php quotes

What is a reference?

Reference in PHP means accessing the same variable content with different names. This is not like a C pointer; instead, the reference is a symbol table alias. Note that in PHP, variable names and variable contents are different, so the same content can have different names. The closest analogy is Unix's filenames and the files themselves - the variable names are the directory entries, and the variable contents are the files themselves. References can be thought of as hardlinks in Unix file systems.

What does a reference do

PHP’s reference allows two variables to point to the same content. Meaning, when doing this:

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

This means $a and $b point to the same variable.

Note:

$a and $b are exactly the same here. It’s not that $a points to $b or vice versa, but that $a and $b point to the same place.

Note:

If an array with a reference is copied, its value will not be dereferenced. The same is true for passing array values ​​to functions.

Note:

If an undefined variable is assigned by reference, passed by reference parameter, or returned by reference, the variable will be automatically created.

Example #1 Using a reference to an undefined variable

<?php
    function foo(&$var) { }
    foo($a); // $a is "created" and assigned to null
    $b = array();
    foo($b[&#39;b&#39;]);
    var_dump(array_key_exists(&#39;b&#39;, $b)); // bool(true)
    $c = new StdClass;
    foo($c->d);
    var_dump(property_exists($c, &#39;d&#39;)); // bool(true)
?>

The same syntax can be used in a function, which returns a reference, and in the new operator (PHP 4.0.4 and later):

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

Since PHP 5, new automatically returns a reference, so using =& here is obsolete and will generate an E_STRICT level message.

Note:

Not using the & operator causes a copy of the object to be generated. If you use $this in a class, it will apply to the current instance of the class. Assignment without & will copy the instance (e.g. object) and $this will act on the copy, which is not always the desired result. Due to performance and memory consumption issues, you usually only want to work on one instance.

Although it is possible to suppress any error messages in the constructor using the @ operator, such as @new, this has no effect when using the &new statement. This is a limitation of the Zend engine and will cause a parsing error.

Warning If a reference is assigned to a variable declared as global inside a function, the reference is only visible inside the function. This can be avoided by using the $GLOBALS array.

Example #2 Reference global variables within a function

<?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 &#39;$var2&#39;\n"; // var2 is set to &#39;&#39;
    global_references(true);
    echo "var2 is set to &#39;$var2&#39;\n"; // var2 is set to &#39;Example variable&#39;
?>

Treat global $var; as the abbreviation of $var =& $GLOBALS['var'];. Thus assigning other references to $var only changes the reference of the local variable.

Note:

If you assign a value to a variable with a reference in a foreach statement, the referenced object is also changed.

Example #3 References with the 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
?>

The second thing a reference does is pass a variable by reference. This is accomplished by creating a local variable within the function and that variable references the same content in the calling scope. For example:

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

will turn $a into 6. This is because the variable $var in the foo function points to the same content that $a points to.

The third thing that references do is reference returns.

What a reference is not

As mentioned before, a reference is not a pointer. This means that the following construct will not have the expected effect:

<?php
    function foo(&$var)
    {
        $var =& $GLOBALS["baz"];
    }
    foo($bar);
?>

This will cause the $var variable in the foo function to be bound to $bar when the function is called, but then re-bound to $GLOBALS[" baz"] above. It is not possible to bind $bar to another variable in the function call scope through the reference mechanism, because there is no variable $bar in function foo (it is represented as $var, but $var only has the variable content and no call symbol table name-to-value binding). You can use reference returns to reference variables selected by the function.