Convert String to Boolean in PHP Safely

You will learn the difference between converting a value and receiving a function's success result in PHP. You will also learn PHP's string-to-Boolean casting rules and how to reliably parse text values such as 'true' and 'false'.

settype() changes the type of the variable passed to it by reference. Its return value does not contain the converted variable. Instead, it returns true when the conversion operation succeeds.

$string = 'false';
$result = settype($string, 'boolean');

var_dump($result); // bool(true): settype succeeded
var_dump($string); // bool(true): converted value

There is a second important detail: PHP's normal Boolean conversion does not interpret the word 'false' as false. When converting a string to bool, PHP considers only these values false:

• the empty string: ''
• the string '0'

Every other non-empty string is true, including 'false', 'no', 'off', and 'hello'.

This matters when handling form fields, environment variables, query parameters, JSON-like text, or configuration files. Those sources often represent Booleans as text, so they must be parsed according to the format's rules rather than simply cast.

Think of settype() as a mechanic changing the contents of a labelled box.

• The variable $string is the box.
• settype($string, 'boolean') changes what is inside the box.
• The function's return value is the mechanic saying, “The conversion was completed successfully.”

That success message is true; it is not the converted value.

Separately, a PHP Boolean cast asks a simple question about strings: “Is this string non-empty and not exactly '0'?” It does not read the English meaning of words such as 'false'. Use filter_var() when you need PHP to recognize common Boolean words.

Use filter_var() with FILTER_VALIDATE_BOOLEAN to parse common text representations of Booleans.

$value = 'false';
$testMode = filter_var($value, FILTER_VALIDATE_BOOLEAN);

var_dump($testMode); // bool(false)

FILTER_VALIDATE_BOOLEAN recognizes these values case-insensitively:

For unknown input, add FILTER_NULL_ON_FAILURE so invalid text is distinguishable from a valid false value:

$value = 'perhaps';
$parsed = filter_var(
    $value,
    FILTER_VALIDATE_BOOLEAN,
    FILTER_NULL_ON_FAILURE
);

var_dump($parsed); // NULL

A direct cast is appropriate only when you specifically want PHP's native casting rules:

var_dump((bool) '');      // bool(false)
var_dump((bool) '0');     // bool(false)
var_dump((bool) 'false'); // bool(true)

To use settype(), inspect the changed variable, not the return value:

$value = '0';
settype($value, 'boolean');

var_dump($value); // bool(false)

Consider this code:

$input = 'false';
$isTestMode = filter_var($input, FILTER_VALIDATE_BOOLEAN);

if ($isTestMode) {
    echo 'Test mode is on.';
} else {
    echo 'Test mode is off.';
}

Execution trace:

1. $input stores the string 'false'.
2. filter_var() applies the Boolean validation filter.
3. The filter recognizes 'false' as a false representation and returns the Boolean false.
4. $isTestMode now contains false.
5. The if condition is false, so the else branch runs.
6. The output is Test mode is off.

Compare that with a cast:

$isTestMode = (bool) 'false';

The string is non-empty and is not '0', so PHP stores true. That is normal PHP casting behavior, not an error.

• Environment variables: Deployment settings such as APP_DEBUG=false are delivered as strings. Parse them before enabling debugging.
• HTML forms: A checkbox or select menu may submit 'on', 'off', 'yes', or 'no'.
• API query parameters: An endpoint such as /users?includeInactive=false receives text, not a native Boolean.
• Configuration files: INI-style or custom configuration values may need conversion before application logic uses them.
• CSV imports: Spreadsheets often contain values like TRUE, FALSE, Yes, and No that need predictable validation.

In each case, use FILTER_NULL_ON_FAILURE if invalid input should produce an error instead of silently becoming false.

In production code, parse external input at the boundary of your application. Once validated, pass real bool values through the rest of the codebase.

Validate an optional query parameter

$rawValue = $_GET['include_inactive'] ?? 'false';

$includeInactive = filter_var(
    $rawValue,
    FILTER_VALIDATE_BOOLEAN,
    FILTER_NULL_ON_FAILURE
);

if ($includeInactive === null) {
    http_response_code(400);
    exit('include_inactive must be true or false.');
}

// $includeInactive is now definitely bool(true) or bool(false).

Use a guard clause for required configuration

$debug = filter_var(
    getenv('APP_DEBUG'),
    FILTER_VALIDATE_BOOLEAN,
    FILTER_NULL_ON_FAILURE
);

if ($debug === null) {
    throw new RuntimeException('APP_DEBUG must be a valid Boolean value.');
}

The strict comparison === null is important. A valid parsed value of false must not be treated as an error.

Assigning settype() to another variable

$value = 'false';
$isEnabled = settype($value, 'boolean');

var_dump($isEnabled); // bool(true)

$isEnabled receives the success status of settype(). The changed value is $value.

$value = 'false';
settype($value, 'boolean');

var_dump($value); // bool(true), due to PHP casting rules

Expecting (bool) 'false' to be false

$isEnabled = (bool) 'false'; // true

PHP does not interpret the word. Use filter_var() for text Boolean values.

Treating invalid input as valid false

$isEnabled = filter_var('maybe', FILTER_VALIDATE_BOOLEAN);
var_dump($isEnabled); // bool(false)

Without FILTER_NULL_ON_FAILURE, an invalid string and 'false' can both result in false. Use the flag when validation matters.

$isEnabled = filter_var(
    'maybe',
    FILTER_VALIDATE_BOOLEAN,
    FILTER_NULL_ON_FAILURE
);

if ($isEnabled === null) {
    echo 'Invalid Boolean value';
}

Using loose checks when null is possible

if (!$isEnabled) {
    // This runs for both false and null.
}

Use strict checks to distinguish them:

if ($isEnabled === null) {
    // Invalid input
} elseif ($isEnabled === false) {
    // Valid false input
}

settype() and (bool) follow the same string conversion rule. Their main difference is that (bool) creates a converted value in an expression, while settype() modifies an existing variable.

// Parse text Boolean values
$enabled = filter_var('true', FILTER_VALIDATE_BOOLEAN); // true
$enabled = filter_var('false', FILTER_VALIDATE_BOOLEAN); // false

// Detect invalid input
$enabled = filter_var(
    'unknown',
    FILTER_VALIDATE_BOOLEAN,
    FILTER_NULL_ON_FAILURE
); // null

// Check parsing result safely
if ($enabled === null) {
    // Invalid input
}

// PHP native casts: only '' and '0' are false strings
(bool) '';       // false
(bool) '0';      // false
(bool) 'false';  // true
(bool) 'no';     // true

// settype mutates its first argument and returns success
$value = '0';
$success = settype($value, 'boolean');
// $success is true; $value is false

Rules to remember:

• Do not use a Boolean cast to interpret English words such as 'false'.
• Use FILTER_NULL_ON_FAILURE when invalid input must be identified.
• Use === null, not !$value, to test for an invalid filtered result.

Why does settype() return true in PHP?

It returns whether the type conversion succeeded. The converted value is stored back in the first argument.

Why is (bool) 'false' true in PHP?

Because 'false' is a non-empty string and is not exactly '0'. PHP's standard cast does not parse the word's meaning.

What is the best way to convert 'true' and 'false' strings in PHP?

Use filter_var($value, FILTER_VALIDATE_BOOLEAN). Add FILTER_NULL_ON_FAILURE when invalid values should be rejected.

Does FILTER_VALIDATE_BOOLEAN support uppercase values?

Yes. It recognizes supported text values case-insensitively, such as 'TRUE' and 'False'.

How can I distinguish false from invalid input?

Use FILTER_NULL_ON_FAILURE, then check === null. false is a valid parsed value; null indicates failure.

Should I use settype() or a Boolean cast?

A cast such as (bool) $value is usually clearer when native PHP conversion is intended. Use neither to parse textual 'true' and 'false'; use filter_var() instead.

• PHP type juggling — Explains how PHP automatically converts values between types.
• Type casting in PHP — Covers explicit casts such as (bool), (int), and (string).
• filter_var() validation — Provides filters for validating and sanitizing external input.
• Strict comparison operators — === helps distinguish false, null, and other values.
• PHP forms and $_GET / $_POST — Request data commonly arrives as strings and needs validation.
• Environment variables in PHP — Configuration values from getenv() are usually strings.