> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# PHP 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.
```php theme={"dark"}
$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`:
```php theme={"dark"}
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:
```php theme={"dark"}
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.
```php theme={"dark"}
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`.
```php theme={"dark"}
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 theme={"dark"}
// PHP 8.0+ Union Type
function findItem(): string|false {
return false;
}
// PHP 8.2+ Standalone Type
function alwaysFails(): false {
return false;
}
```
Tired of Poor PHP Skills? Fix That With Deep Grasping!
Learn More
