PHP: what's an alternative to empty(), where string "0" is not treated as empty?

In PHP, empty() is a great shortcut because it allows you to check whether a variable is defined AND not empty at the same time.

What would you use when you don't want "0" (as a string) to be considered empty, but you still want false, null, 0 and "" treated as empty?

That is, I'm just wondering if you have your own shortcut for this:

if (isset($myvariable) && $myvariable != "") ;// do something
if (isset($othervar  ) && $othervar   != "") ;// do something
if (isset($anothervar) && $anothervar != "") ;// do something
// and so on, and so on

I don't think I can define a helper function for this, since the variable could be undefined (and therefore couldn't be passed as parameter).

From stackoverflow

• if ((isset($var) && $var === "0") || !empty($var))
  {
  
  }
  

  This way you will enter the if-construct if the variable is set AND is "0", OR the variable is set AND not = null ("0",null,false)

  thomasrutter : This looks quite correct; it isn't really a shortcut for if (isset($myvariable) && $myvariable != "") though as it's longer. Thanks for the answer.

• This should do what you want:

  function notempty($var) {
      return ($var==="0"||$var);
  }
  

  Edit: I guess tables only work in the preview, not in actual answer submissions. So please refer to the PHP type comparison tables for more info.

  notempty("")       : false
  notempty(null)     : false
  notempty(undefined): false
  notempty(array())  : false
  notempty(false)    : false
  notempty(true)     : true
  notempty(1)        : true
  notempty(0)        : false
  notempty(-1)       : true
  notempty("1")      : true
  notempty("0")      : true
  notempty("php")    : true
  

  Basically, notempty() is the same as !empty() for all values except for "0", for which it returns true.

  ---

  Edit: If you are using error_reporting(E_ALL), you will not be able to pass an undefined variable to custom functions by value. And as mercator points out, you should always use E_ALL to conform to best practices. This link (comment #11) he provides discusses why you shouldn't use any form of error suppression for performance and maintainability/debugging reasons.

  See orlandu63's answer for how to have arguments passed to a custom function by reference.

  mercator : That will fail when the variable is undefined.

  Calvin : How do you mean? If passed an undefined variable, the function returns false--which is the opposite of what empty() returns: http://us2.php.net/manual/en/types.comparisons.php That is the desired behavior.

  Milan Babuškov : It does not fail, but produces a warning. So, although it does work, it is not The Right Way(tm). You should use isset() before checking the variable with ===

  Calvin : Strange, it doesn't produce any warnings when I have error reporting set to E_STRICT. If does however produce an error when I use E_ALL. But then using isset() inside of the function does not prevent the error either.

  Calvin : It seems that you can't pass an undefined variable to a custom function in E_ALL regardless of whether your use isset() or not. Gushiken's implementation without a custom function does work in all circumstances however.

  mercator : E_STRICT isn't a superset of E_ALL: http://www.php.net/manual/en/errorfunc.constants.php. You should use (E_ALL | E_STRICT). You *could* use the @ operator, but that adds overhead (see http://www.smashingmagazine.com/2009/03/24/10 "tip" #9 and comment #11) and isn't The Right Way™ either.

  thomasrutter : Unfortunately this will not work for me because it will fail (ie produce PHP notice) when the variable is undefined. I rely on PHP notices. I hadn't realised, I guess, that it's not possible to define a function that can accept an undefined variable; empty() and isset() are magical in that way.

• if(isset($var) && ($var === '0' || !empty($var)))
  {
  }
  

• function Void($var)
  {
      if (empty($var) === true)
      {
       if (($var === 0) || ($var === '0'))
       {
        return false;
       }
  
       return true;
      }
  
      return false;
  }
  

  thomasrutter : This has the problem that if $var is undefined, it fails as soon as it's passed as an argument (to a function other than isset or empty, such as your Void function). I think what I was wanting is actually impossible, sorry.

• function isempty(&$var) {
      return empty($var) || $var === '0';
  }
  

  The key is the & operator, which passes the variable by reference, creating it if it doesn't exist.

• The answer to this is that it isn't possible to shorten what I already have.

  Suppressing notices or warnings is not something I want to have to do, so I will always need to check if empty() or isset() before checking the value, and you can't check if something is empty() or isset() within a function.

• If ($var != null)