I just read about unset variable through php manual.
The php manual says "unset() destroys the specified variables"
This def seems perfect until I came across static variable... "If a static variable is unset() inside of a function, unset() destroys the variable only in the context of the rest of a function. Following calls will restore the previous value of a variable. "
This definition doesn't seems a good one for me, at least, since "destroy the variable" implies that the variable is no longer associated with that memory location.
Does anyone else think a better definition would be "unset() makes the variable out of current scope"? I mean, rather than pointing towards lifetime, it's better to use word scope here?
The unset() function unsets a variable.
The unlink() function is used when you want to delete the files completely. The unset() Function is used when you want to make that file empty.
The unset function is used to destroy any other variable and same way use to delete any element of an array. This unset command takes the array key as input and removed that element from the array. After removal the associated key and value does not change.
unset() does just what its name says - unset a variable. It does not force immediate memory freeing. PHP's garbage collector will do it when it see fits - by intention as soon, as those CPU cycles aren't needed anyway, or as late as before the script would run out of memory, whatever occurs first.
Let's consider the function:
function foo() {
static $bar;
$bar++;
unset($bar);
}
foo(); //static $bar is 1
foo(); //static $bar is 2
The function compiles to:
function name: foo number of ops: 11 compiled vars: !0 = $bar line # * op fetch ext return operands --------------------------------------------------------------------------------- 2 0 > EXT_NOP 4 1 EXT_STMT 2 FETCH_W static $0 'bar' 3 ASSIGN_REF !0, $0 5 4 EXT_STMT 5 POST_INC ~1 !0 6 FREE ~1 6 7 EXT_STMT 8 UNSET_VAR !0 7 9 EXT_STMT 10 > RETURN null
A variable actually exists outside each function call to foo()
and, on each call, it's fetched and a reference to it is assigned to $bar
. In fact, it's very similar to this:
function foo() {
global $bar;
$bar++;
unset($bar);
}
When you call unset()
, you're only destroying the reference you created, not the underlying value.
I didn't confirm, but what I'd guess that happens is this:
foo()
is called, the symbol $bar
is associated with this zval, its reference count is increased to 2 and the reference flag is set.unset
is called, the zval has its reference count decreased to 1, the reference flag is probably cleared and the symbol $bar
is removed.See reference count basics.
Inside a function, variable names referencing static variables are just that.. references. In effect, unset destroys the reference.
unset(self::$somethingstatic); will raise an Fatal error, because the variable is static (always there, can't be unset).
the documentation refers specifically to static variables defined inside a function, consider:
function t($stage)
{
static $shell = 23;
switch($stage) {
case 1:
$shell++;
break;
case 2:
unset($shell);
break;
case 3:
$shell--;
break;
}
echo $shell;
}
because $shell is a static variable, it's always there (static) so any other time you mention $shell that is simply a reference - when you unset it, you are unsetting the reference (think unlink'ing a symlink) - the static variable is however still there (that's what static means).
thus if you call the above function t(1) will echo 24, t(2) will echo nothing, and t(3) will (rightly) echo 23 :)
help any?
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With