Fixing the PHP empty function

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.

"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).

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.

"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().

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.

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.

I use this to detect emptiness:

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

the function:

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

PHP’s empty() treats both 0 and "0" as empty, which can cause issues. Laravel’s blank() (Laravel docs, Github) offers a more precise alternative:

function blank($value)
    {
        if (is_null($value)) {
            return true;
        }

        if (is_string($value)) {
            return trim($value) === '';
        }

        if (is_numeric($value) || is_bool($value)) {
            return false;
        }

        if ($value instanceof Model) {
            return false;
        }

        if ($value instanceof Countable) {
            return count($value) === 0;
        }

        if ($value instanceof Stringable) {
            return trim((string) $value) === '';
        }

        return empty($value);
    }
}

Why use this?

• "0" and 0 are not considered blank.
• boolean values are not considered blank.
• Trims strings before checking.
• Handles arrays and Countable objects properly.
• Still treats null as blank.

Use blank() instead of empty() for safer checks where 0 should be valid.

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.

I created an IsEmpty() a terse quick function.

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

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

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;
}

If you want to check the "emptiness" of an scalar (string, bool, int, float), and you want 0 and "0" to be evaluated as non-empty, you can use the following function:

function my_empty(mixed $x): bool
{
    return $x === null || $x === ''  || $x === false;
}

It can evaluate expressions, not only variables (e.g. my_empty($m * $n)).