false

false is a built-in boolean literal in PHP representing the negative truth value. It is a scalar data type of bool utilized fundamentally in logical operations, state evaluation, and as a standard return value indicating the failure of an internal function.

Syntax and Case Sensitivity

The false keyword is case-insensitive. However, the PSR-12 coding standard mandates the use of lowercase for all PHP type keywords.

$val1 = false;
$val2 = FALSE; // Valid, but violates PSR-12
$val3 = FaLsE; // Valid, but highly discouraged

var_dump($val1 === $val2); // bool(true)

Type Coercion and “Falsy” Values

Due to PHP’s dynamic typing system, various values of different data types are implicitly coerced to false when evaluated in a boolean context (such as a conditional expression or when explicitly cast using (bool)). These are technically referred to as “falsy” values.

The following values strictly evaluate to false:

var_dump((bool) 0);           // Integer zero
var_dump((bool) 0.0);         // Float zero (and -0.0)
var_dump((bool) "");          // Empty string
var_dump((bool) "0");         // String containing exactly "0"
var_dump((bool) []);          // Empty array
var_dump((bool) null);        // Uninitialized or null variables

Note: Unlike some other languages, an empty object (new stdClass()) evaluates to true in PHP.

Casting false to Other Types

When false is explicitly or implicitly cast to other scalar or compound types, PHP applies specific conversion rules:

var_dump((string) false); // string(0) "" (Evaluates to an empty string, not "0" or "false")
var_dump((int) false);    // int(0)
var_dump((float) false);  // float(0)
var_dump((array) false);  // array(1) { [0]=> bool(false) }

Comparison Mechanics

PHP provides two comparison operators that handle false differently based on type juggling rules.

Loose Comparison (==) Loose comparison applies type coercion before comparing values. false will loosely match any “falsy” value.

var_dump(false == 0);    // bool(true)
var_dump(false == "");   // bool(true)
var_dump(false == "0");  // bool(true)
var_dump(false == []);   // bool(true)
var_dump(false == null); // bool(true)

Strict Comparison (===) Strict comparison evaluates both the value and the data type. It will not perform type coercion. false will only strictly match another boolean false.

var_dump(false === 0);    // bool(false)
var_dump(false === "");   // bool(false)
var_dump(false === null); // bool(false)

false as a Type Hint (PHP 8.0+)

Historically, false was only a value, not a valid type declaration.

• PHP 8.0 introduced false as a valid literal type exclusively within Union Types (e.g., string|false), reflecting the legacy behavior of internal PHP functions that return a specific type on success and false on failure.
• PHP 8.2 elevated false to a standalone type, allowing it to be used as a return type, parameter type, or property type declaration on its own.

// PHP 8.0+ Union Type
function findItem(): string|false {
    return false;
}

// PHP 8.2+ Standalone Type
function alwaysFails(): false {
    return false;
}

Master PHP with Deep Grasping Methodology!

Learn More