PHP 7.0.6 Released

    Unsetting References

    When you unset the reference, you just break the binding between variable name and variable content. This does not mean that variable content will be destroyed. For example:

    <?php
    $a     = 1;
    $b =& $a;
    unset(    $a); 
    ?>
    won't unset $b, just $a.

    Again, it might be useful to think about this as analogous to the Unix unlink call.

    User Contributed Notes

    ojars26 at NOSPAM dot inbox dot lv
    7 years ago
    Simple look how PHP Reference works
    <?php
    /* Imagine this is memory map
    ______________________________
    |pointer | value | variable              |
    -----------------------------------
    |   1     |  NULL  |         ---           |
    |   2     |  NULL  |         ---           |
    |   3     |  NULL  |         ---           |
    |   4     |  NULL  |         ---           |
    |   5     |  NULL  |         ---           |
    ------------------------------------
    Create some variables   */
    $a=10;
    $b=20;
    $c=array ('one'=>array (1, 2, 3));
    /* Look at memory
    _______________________________
    |pointer | value |       variable's       |
    -----------------------------------
    |   1     |  10     |       $a               |
    |   2     |  20     |       $b               |
    |   3     |  1       |      $c['one'][0]   |
    |   4     |  2       |      $c['one'][1]   |
    |   5     |  3       |      $c['one'][2]   |
    ------------------------------------
    do  */
    $a=&$c['one'][2];
    /* Look at memory
    _______________________________
    |pointer | value |       variable's       |
    -----------------------------------
    |   1     |  NULL  |       ---              |  //value of  $a is destroyed and pointer is free
    |   2     |  20     |       $b               |
    |   3     |  1       |      $c['one'][0]   |
    |   4     |  2       |      $c['one'][1]   |
    |   5     |  3       |  $c['one'][2]  ,$a | // $a is now here
    ------------------------------------
    do  */
    $b=&$a;  // or  $b=&$c['one'][2]; result is same as both "$c['one'][2]" and "$a" is at same pointer.
    /* Look at memory
    _________________________________
    |pointer | value |       variable's           |
    --------------------------------------
    |   1     |  NULL  |       ---                  | 
    |   2     |  NULL  |       ---                  |  //value of  $b is destroyed and pointer is free
    |   3     |  1       |      $c['one'][0]       |
    |   4     |  2       |      $c['one'][1]       |
    |   5     |  3       |$c['one'][2]  ,$a , $b |  // $b is now here
    ---------------------------------------
    next do */
    unset($c['one'][2]);
    /* Look at memory
    _________________________________
    |pointer | value |       variable's           |
    --------------------------------------
    |   1     |  NULL  |       ---                  | 
    |   2     |  NULL  |       ---                  | 
    |   3     |  1       |      $c['one'][0]       |
    |   4     |  2       |      $c['one'][1]       |
    |   5     |  3       |      $a , $b              | // $c['one'][2]  is  destroyed not in memory, not in array
    ---------------------------------------
    next do   */
    $c['one'][2]=500;    //now it is in array
    /* Look at memory
    _________________________________
    |pointer | value |       variable's           |
    --------------------------------------
    |   1     |  500    |      $c['one'][2]       |  //created it lands on any(next) free pointer in memory
    |   2     |  NULL  |       ---                  | 
    |   3     |  1       |      $c['one'][0]       |
    |   4     |  2       |      $c['one'][1]       |
    |   5     |  3       |      $a , $b              | //this pointer is in use
    ---------------------------------------
    lets tray to return $c['one'][2] at old pointer an remove reference $a,$b.  */
    $c['one'][2]=&$a;
    unset(    $a);
    unset(    $b);  
    /* look at memory
    _________________________________
    |pointer | value |       variable's           |
    --------------------------------------
    |   1     |  NULL  |       ---                  | 
    |   2     |  NULL  |       ---                  | 
    |   3     |  1       |      $c['one'][0]       |
    |   4     |  2       |      $c['one'][1]       |
    |   5     |  3       |      $c['one'][2]       | //$c['one'][2] is returned, $a,$b is destroyed
    --------------------------------------- ?>
    I hope this helps.
    sony-santos at bol dot com dot br
    9 years ago
    <?php
    //if you do:

    $a = "hihaha";
    $b = &$a;
    $c = "eita";
    $b = $c;
    echo     $a; // shows "eita"

    $a = "hihaha";
    $b = &$a;
    $c = "eita";
    $b = &$c;
    echo     $a; // shows "hihaha"

    $a = "hihaha";
    $b = &$a;
    $b = null;
    echo     $a; // shows nothing (both are set to null)

    $a = "hihaha";
    $b = &$a;
    unset(    $b);
    echo     $a; // shows "hihaha"

    $a = "hihaha";
    $b = &$a;
    $c = "eita";
    $a = $c;
    echo     $b; // shows "eita"

    $a = "hihaha";
    $b = &$a;
    $c = "eita";
    $a = &$c;
    echo     $b; // shows "hihaha"

    $a = "hihaha";
    $b = &$a;
    $a = null;
    echo     $b; // shows nothing (both are set to null)

    $a = "hihaha";
    $b = &$a;
    unset(    $a);
    echo     $b; // shows "hihaha"
    ?>

    I tested each case individually on PHP 4.3.10.
    lazer_erazer
    9 years ago
    Your idea about unsetting all referenced variables at once is right,
    just a tiny note that you changed NULL with unset()...
    again, unset affects only one name and NULL affects the data,
    which is kept by all the three names...

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

    This does also work!

    <?php
    $a     = 1;
    $b =& $a;
    $c =& $b;
    $b = NULL;
    ?>
    donny at semeleer dot nl
    9 years ago
    Here's an example of unsetting a reference without losing an ealier set reference

    <?php
    $foo     = 'Bob';              // Assign the value 'Bob' to $foo
    $bar = &$foo;              // Reference $foo via $bar.
    $bar = "My name is $bar";  // Alter $bar...
    echo $bar;
    echo     $foo;                 // $foo is altered too.
    $foo = "I am Frank";       // Alter $foo and $bar because of the reference
    echo $bar;                 // output: I am Frank
    echo $foo;                 // output: I am Frank

    $foobar = &$bar;           // create a new reference between $foobar and $bar
    $foobar = "hello $foobar"; // alter $foobar and with that $bar and $foo
    echo $foobar;              //output : hello I am Frank
    unset($bar);               // unset $bar and destroy the reference
    $bar = "dude!";            // assign $bar
    /* even though the reference between $bar and $foo is destroyed, and also the
    reference between $bar and $foobar is destroyed, there is still a reference
    between $foo and $foobar. */
    echo $foo;                 // output : hello I am Frank
    echo $bar;                 // output : due!
    ?>
    libi
    10 years ago
    clerca at inp-net dot eu dot org
    "
    If you have a lot of references linked to the same contents, maybe it could be useful to do this :
    <?php
    $a     = 1;
    $b = & $a;
    $c = & $b; // $a, $b, $c reference the same content '1'

    $b = NULL; // All variables $a, $b or $c are unset
    ?>

    "

    ------------------------

    NULL will not result in unseting the variables.
    Its only change the value to "null" for all the variables.
    becouse they all points to the same "part" in the memory.
    To Top