Unsetting a variable vs setting to ''

Is it better form to do one of the following? If not, is one of them faster than the other?

unset($variable);

or to do

$variable = '';

From stackoverflow waiwai933

• they will do slightly different things:

  • unset will remove the variable from the symbol table and will decrement the reference count on the contents by 1. references to the variable after that will trigger a notice ("undefined variable"). (note, an object can override the default unset behavior on its properties by implementing __unset()).

  • setting to an empty string will decrement the reference count on the contents by 1, set the contents to a 0-length string, but the symbol will still remain in the symbol table, and you can still reference the variable. (note, an object can override the default assignment behavior on its properties by implementing __set()).

  in older php's, when the ref count falls to 0, the destructor is called and the memory is freed immediately. in newer versions (>= 5.3), php uses a buffered scheme that has better handling for cyclical references (http://www.php.net/manual/en/features.gc.collecting-cycles.php), so the memory could possibly be freed later, tho it might not be delayed at all... in any case, that doesn't really cause any issues and the new algorithm prevents certain memory leaks.

  if the variable name won't be used again, unset should be a few cpu cycles faster (since new contents don't need to be created). but if the variable name is re-used, php would have to create a new variable and symbol table entry, so it could be slower! the diff would be a negligible difference in most situations.

  if you want to mark the variable as invalid for later checking, you could set it to false or null. that would be better than testing with isset() because a typo in the variable name would return false without any error... you can also pass false and null values to another function and retain the sentinel value, which can't be done with an unset var...

  so i would say:

  $var = false; ...
  if ($var !== false) ...
  

  or

  $var = null; ...
  if (!is_null($var)) ...
  

  would be better for checking sentinel values than

  unset($var); ...
  if (isset($var)) ...
  

  From jspcal

• Technically $test = '' will return true to

  if(isset($test))
  

  Because it is still 'set', it is just set to en empty value.

  It will however return true to

  if(empty($test))
  

  as it is an empty variable. It just depends on what you are checking for. Generally people tend to check if a variable isset, rather than if it is empty though.

  So it is better to just unset it completely.

  Also, this is easier to understand

  unset($test);
  

  than this

  $test = '';
  

  the first immediately tells you that the variable is NO LONGER SET. Where as the latter simply tells you it is set to a blank space. This is commonly used when you are going to add stuff to a variable and don't want PHP erroring on you.

  From Chacha102

• You are doing different things, the purpose of unset is to destroys the specified variable in the context of where you make it, your second example simply sets the variable to an empty string.

  Unsetting a variable doesn't force immediate memory freeing, if you are concerned about performance, setting the variable to NULL may be a better option, but really, the difference will be not noticeable...

  Discussed in the docs:

  unset() does just what it's 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.

  If you are doing $whatever = null; then you are rewriting variable's data. You might get memory freed / shrunk faster, but it may steal CPU cycles from the code that truly needs them sooner, resulting in a longer overall execution time.

  From CMS

• They have totally different meanings. The former makes a variable non-existant. The latter just sets its value to the empty string. It doesn't matter which one is "better" so to speak, because they are for totally different things.

  Are you trying to clean up memory or something? If so, don't; PHP manages memory for you, so you can leave it laying around and it'll get cleaned up automatically.

  If you're not trying to clean up memory, then you need to figure out why you want to unset a variable or set it to empty, and choose the appropriate one. One good sanity check for this: let's say someone inserted the following line of code somewhere after your unset/empty:

  if(strcmp($variable, '') == 0) { do_something(); }
  

  And then, later:

  if(!isset($variable)) { do_something_else(); }
  

  The first will run do_something() if you set the variable to the empty string. The second will run do_something_else() if you unset the variable. Which of these do you expect to run if your script is behaving properly?

  From jboxer

• I think the most relevant difference is that unsetting a variable communicates that the variable will not be used by subsequent code (it also "enforces" this by reporting an E_NOTICE if you try to use it, as jspcal said that's because it's not in the symbol table anymore).

  Therefore, if the empty string is a legal (or sentinel) value for whatever you are doing with your variable, go ahead and set it to ''. Otherwise, if the variable is no longer useful, unsetting it makes for clearer code intent.

  Tom : I can't believe nobody else mentioned `E_NOTICE`... my god, anyone who still ignores that needs to be smacked over the head with a _proper_ compiler!
  From Jon

• There is one other 'gotcha' to consider here, the reference.

  if you had:

  $a = 'foobar';
  $variable =& $a;
  

  then to do either of your two alternatives is quite different.

  $variable = '';
  

  sets both $variable and $a to the empty string, where as

  unset($variable);
  

  removes the reference link between $a and $variable while removing $variable from the symbol table. This is indeed the only way to unlink $a and $variable without setting $variable to reference something else. Note, e.g., $variable = null; won't do it.

  From Don