Fixing the PHP empty function

Question

PHP has the habit of evaluating (int)0 and (string)"0" as empty when using the empty() function. This can have unintended results if you expect numerical or string values of 0. How can I "fix" it to only return true to empty objects, arrays, strings, etc?

Answer 1

If you want an equivalent to empty($var) which returns false when var is the string "0", you can use:

if (($var ?? 0) != '')

The reason this works is:

• $var ?? 0 is a shortcut for the ternery isset($var) ? $var : 0. That is, if the variable on the left doesn't exist it takes the value on the right, without issuing a warning or notice, as with isset() or empty().

• <value> != '' does an implicit cast of the empty string when the left value isn't a string. This returns false for any false-like value of <value> such as null, false or (numeric) 0. However, for the string "0", this will return true, since no cast will be performed and "0" != "" is true.

Answer 2

I used ord function to check either the value passed was empty or not.

/*
* SPACE is not empty - Please do trim before using this function for your own purpose
*  var_dump(is_having_value(0));        // true
   var_dump(is_having_value(0000));     // true
   var_dump(is_having_value("    0"));  // true
   var_dump(is_having_value(""));       // false
   var_dump(is_having_value("  "));     // true
   var_dump(is_having_value('\t'));     // true
   var_dump(is_having_value(''));       // false
   var_dump(is_having_value('o'));      // true
   var_dump(is_having_value('O'));      // true
   var_dump(is_having_value('0'));      //true
   var_dump(is_having_value(null));     //false
   var_dump(is_having_value());         //false
*/
function is_having_value($val = null) {
    if (is_array($val) || is_object($val)):
        $logic_empty = empty($val);
        return !$logic_empty;
    else:
        $ascii = ord($val);
        if ($ascii == 48 || $ascii = 0 || $ascii == 32):
            return true;
        else:
            $logic_empty = empty($val);
            return !$logic_empty;
        endif;
    endif;
}

Answer 3

I use this to detect emptiness:

''  --> true
'0' --> false
0   --> false

the function:

function is_empty_or_zero($str) {
 return (is_null($str) || ($str === ''));
}

Answer 4

This didn't work for me.

if (empty($variable) && '0' != $variable) {
  // Do something
}

I used instead:

if (empty($variable) && strlen($variable) == 0) {
  // Do something
}

Answer 5

if ( is_int($val) || !empty($val) ) {;}

Answer 6

I always add to my codebase

function is_blank($value) {
    return empty($value) && !is_numeric($value);
}

and use it instead of empty(). It solves the issue of keeping zeros (int, float or string) as non-empty.

See http://www.php.net/manual/en/function.empty.php#103756 which was added May 2011.

Answer 7

You're trying to use empty() for something it's not intended for. Personally, I think it's behaviour comes from an older programming paradigm in PHP and it could probably be retired.

Instead, make your checks more explicit. Rather than checking if the value is not useful, check that it is. For example, if you want an array, check it's an array (is_array()) rather than checking whether it's a string.

Also, you can rely on the fact that all $_POST and $_GET variables are strings, so you can make comparisons to "", or check that strlen() == 0.

Answer 8

The most effective solution for this problem is to test if the variable is false e.g.

if (!$variable_name) {echo $variable_name;}

It doesn't matter if the variable is empty or null, it all equals to false when put in a if conditional.

Answer 9

"0" is always considered false (or empty) in PHP, and it does make alot of sense (not that I'll argue that here). If you want to have zero evaluate to true as well, use strlen($value).

Answer 10

Generally speaking you want to use the triple equals operator to determine when a value truly is null or false. This is more specific and the results ALWAYS return exactly as expected.

Creating a separate function to do something that you can do in a single line of code but using a different operator seems to be overly complicated and adds additional obfuscation.

Additionally, many programmers tend to use 0 or an empty string to denote a non-existent value but it is more correct (and I feel a better practice) to use a null value to denote any value (regardless of type) that is truly non-existent.

Answer 11

I seldom use empty() for the reason you describe. It confuses legitimate values with emptiness. Maybe it's because I do a lot of work in SQL, but I prefer to use NULL to denote the absence of a value.

PHP has a function is_null() which tests for a variable or expression being NULL.

$foo = 0;
if (is_null($foo)) print "integer 0 is null!\n"; 
else print "integer 0 foo is not null!\n";

$foo = "0";
if (is_null($foo)) print "string '0' is null!\n"; 
else print "string '0' is not null!\n";

$foo = "";
if (is_null($foo)) print "string '' is null!\n"; 
else print "string '' is not null!\n";

$foo = false;
if (is_null($foo)) print "boolean false is null!\n"; 
else print "boolean false is not null!\n";

You can also use the exactly equals operator === to do a similar test:

if ($foo === null) print "foo is null!\n";

This is true if $foo is NULL, but not if it's false, zero, "", etc.

Answer 12

"Fixing" is one point of view. Another would be to assume it's not "broken", and learn to work with it the way it was intentionally designed.

Given the problem as you describe it, the best thing would be to tighten up your code so the variable can't be put into an indeterminate type state. Otherwise, you'll want to test for datatype using gettype().

Answer 13

I created an IsEmpty() a terse quick function.

function IsEmpty($mData) {
    return is_int($mData) ? false : 
        is_string($mData) ? $mData=="" : 
        empty($mData);
}