Use declare(strict_types=1) to enforce strict typing and prevent implicit type coercion; 2. Perform manual type conversion explicitly using casting or filter_var() for reliable input handling; 3. Apply return type declarations and union types to ensure internal consistency and controlled flexibility; 4. Adopt scalar type declarations to catch errors early and improve code clarity; 5. Validate and convert data at entry points to maintain integrity throughout the application—this approach results in more predictable, maintainable, and robust PHP code.

PHP has come a long way from its loosely-typed roots. Once known for its forgiving, dynamic type system, modern PHP now encourages—and even enforces—type strictness in ways that improve code reliability, maintainability, and developer confidence. A key part of this evolution is type conversion in the context of strict typing, where developers can control how values are interpreted and prevent unintended behavior.

Let’s break down how PHP handles type conversion today and how embracing strictness leads to better code.

1. Understanding Type Juggling vs. Strict Typing

By default, PHP performs type juggling—automatically converting values between types based on context:

function add(int $a, int $b) {
    return $a   $b;
}

echo add("5", "10"); // Works: strings are silently converted to integers

This works, but it hides potential bugs. The function claims to accept int, yet receives strings. This is coercive mode, the default in PHP.

To opt out of this leniency, use strict mode:

declare(strict_types=1);

function add(int $a, int $b) {
    return $a   $b;
}

add("5", "10"); // TypeError: Argument 1 must be of type int, string given

With strict_types=1, PHP no longer coerces values. The types must match exactly—or you get a clear error.

? Key takeaway: declare(strict_types=1) should be at the top of every PHP file where you want strict parameter and return type enforcement.

2. Manual Type Conversion: When and How

Even with strict typing, you’ll often need to convert data—especially when dealing with user input, databases, or APIs, where everything starts as a string.

Instead of relying on PHP’s loose conversion, explicit conversion makes intent clear:

$age = (int) $_POST['age'];           // Cast to integer
$price = (float) $_POST['price'];     // Cast to float
$isActive = filter_var($_POST['active'], FILTER_VALIDATE_BOOLEAN); // Proper bool conversion

Avoid this common mistake:

(bool) "false" // true — because non-empty string casts to true!

Use filter_var() instead:

filter_var("false", FILTER_VALIDATE_BOOLEAN); // false

? Best practice: Validate and convert input early—preferably at the entry point of your application (e.g., request handlers or DTOs).

3. Return Type Enforcement and Internal Consistency

Modern PHP lets you define return types, which also benefit from strictness:

declare(strict_types=1);

function divide(float $a, float $b): float {
    if ($b === 0.0) {
        throw new InvalidArgumentException("Division by zero");
    }
    return $a / $b;
}

Without strict types, passing integers would still work (they’d be coerced). With strict types, you’re forced to pass floats—making the contract clearer.

But what if you want flexibility? Use union types (PHP 8.0 ):

function parseId(string|int $id): int {
    return (int) $id;
}

Now the function accepts either type, but still controls the return. This balances flexibility with safety.

4. Scalar Type Declarations: A Game Changer

Before PHP 7.0, you couldn’t type-hint scalar types like int, string, bool, or float. Now you can:

function greet(string $name, int $age): string {
    return "Hello, $name! You are $age years old.";
}

Combined with strict types, this prevents subtle bugs from incorrect data types creeping in.

?? Note: Strict types only affect function calls within the same file. If you're calling a function in another file, make sure that file also declares strict_types=1.

Final Thoughts

Embracing strict typing in PHP doesn’t eliminate type conversion—it just shifts it from implicit and unpredictable to explicit and controlled. You’re no longer hoping PHP guesses right; you’re telling it exactly what to do.

Here’s how to make the most of it:

• ? Always use declare(strict_types=1); in files with function calls you control
• ? Use scalar type hints and return types liberally
• ? Convert and validate input data early
• ? Prefer filter_var() for booleans and complex types
• ? Leverage union types instead of falling back to mixed or object

The result? Code that’s easier to test, debug, and evolve—without sacrificing PHP’s practical flexibility.

Basically, strictness isn’t about rigidity. It’s about clarity. And in modern PHP, that’s a win.

The above is the detailed content of Type Conversion in Modern PHP: Embracing Strictness. For more information, please follow other related articles on the PHP Chinese website!