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 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:

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 = () ;

• 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 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.

// 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:

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; indicates failure.

• 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.