When Should Variables Be Null, False, Undefined, or an Empty String in PHP?

Bad code level 1000+

You’ve probably been there. You’re reviewing a pull request or digging through some legacy code, and then you see it: if ($var == "not set"), or if ($data == "") where null or false should’ve been used. These kinds of mismatched variable states can quickly turn a clean codebase into a tangled mess of ambiguity and bugs.

I’ve run into these scenarios so many times that I felt the need to write this article as a guide for everyone who’s ever wondered, “What’s the difference between these values? And when should I use each?” Let’s break it all down so we can avoid these misuses and write cleaner, more consistent PHP code.

Understanding the Basics

Null

In PHP, null means the variable has no value—it’s empty, nada, zilch. It’s like saying, "I know this exists, but there’s nothing here".

$variable = null;

Use null when:

• You want to explicitly clear a variable.
• A value is not applicable but the variable needs to exist in the context of your program.

False

false is a boolean value that screams, "Nope! Not happening."

$isLoggedIn = false;

Use false when:

• A condition or state evaluates to a negative outcome.
• You need to represent failure in a boolean context (e.g., returning false from a function).

Undefined

In PHP, “undefined” isn’t exactly a thing like it is in JavaScript. Instead, accessing an undeclared variable triggers a notice. However, having a variable undefined can be okay in some scenarios — there’s no need to initialize variables just for the sake of it.

For example, consider this overly cautious initialization:

function processData() {
    $data = false; // WHY? This isn’t needed if it’s never used later
    if (someCondition()) {
        $data = fetchData();
    }
    // Process $data only if it’s set
}

Instead, use isset or check for existence when needed:

function processData() {
    if (someCondition()) {
        $data = fetchData();
    }

    if (isset($data)) {
        // Process $data only if it exists
    }
}

Legitimate scenarios for undefined variables include:

• When the variable’s existence depends on a condition.
• When initializing it would create unnecessary clutter or defaults.

Empty String

An empty string "" is a string with no characters—not null, not false, just... empty.

$username = "";

Use an empty string when:

• A variable must be a string but has no meaningful value yet.
• You’re resetting a string variable without changing its type.

Common Misuses and Their Consequences

Misusing null for false

$isAdmin = null; // WRONG
$isAdmin = false; // CORRECT

Why? null means no value, while false explicitly says, "This is not true."

Misusing Empty String for null

$description = ""; // WRONG if description is truly absent
$description = null; // CORRECT

Why? An empty string implies the description exists but is empty. Use null if the description doesn’t exist at all.

Checking for Empty String Instead of false

$hasAccess = ""; // WRONG
$hasAccess = false; // CORRECT

if ($hasAccess === "") {
    echo "No access."; // CONFUSING
}
if ($hasAccess === false) {
    echo "No access."; // CLEAR
}

Why? A boolean value communicates intent better in cases of access control or logical checks.

Using Non-Standard Strings for State

$status = "not set"; // WRONG
$status = null; // CORRECT

Why? Using arbitrary strings for state makes the code harder to read and prone to typos or mismatches.

Misusing false for Empty String

$username = false; // WRONG
$username = ""; // CORRECT

Why? A username should always be a string, even if it’s empty. Using false mixes data types unnecessarily.

Best Practices

1. Align Values With Intent

• Use null for absence, false for booleans, and empty strings for strings that have no characters.

$userEmail = null; // No email provided
$isVerified = false; // User is not verified
$comments = ""; // No comments provided yet

2. Default Values Always give variables default values that match the expected type.

$score = null; // Integer values may come later
$isAuthenticated = false; // Start with a boolean default
$name = ""; // Empty string as a default for text

3. Strict Comparisons Avoid weird coercions by using === and !==.

if ($variable === null) {
    echo "Variable is null";
}
if ($isLoggedIn === false) {
    echo "User is not logged in.";
}

4. Use Type Hints and Union Types PHP 8.0+ supports union types and nullable types. Use them to enforce the right values.

function setPrice(?float $price): void {
    if ($price === null) {
        echo "Price not available";
    } else {
        echo "Price: $price";
    }
}

Real-World Examples

Example 1: User Authentication

class User {

    private ?string $email = null; // Email may not always be set

    private bool $isVerified = false; // Default to not verified

    public function setEmail(?string $email): void {
        $this->email = $email;
    }

    public function verify(): void {
        $this->isVerified = true;
    }

    public function getEmail(): ?string {
        return $this->email; // always return value, not message in Model
    }

    public function isVerified(): bool {
        return $this->isVerified; // always return value, not message
    }
}

Example 2: Form Handling

$formData = [
    'username' => "",
    'password' => null,
    'remember_me' => false,
];

if ($formData['password'] === null) {
    echo "Password is required.";
}
if ($formData['username'] === "") {
    echo "Username cannot be empty.";
}
if ($formData['remember_me'] === false) {
    echo "User chose not to be remembered.";
}

Conclusion

Getting null, false, undefined, and empty strings right in PHP isn’t just about code working—it’s about code that makes sense. By matching values to their intent and avoiding unnecessary coercions, you’ll save yourself and your teammates a ton of headaches. Remember, clean and consistent code isn’t just good practice—it’s a sanity saver.