Casting is still necessary in PHP 8 despite improved type safety, primarily at input boundaries like HTTP requests or APIs where data arrives as strings. 2. Union types make casting safer by clearly defining acceptable input types, allowing controlled conversions only after validation. 3. Always cast early during data ingestion, not within business logic, to maintain type integrity. 4. Combine casting with validation (e.g., is_numeric, ctype_digit) and use it in DTOs or transformers to ensure clean, predictable behavior. 5. Encapsulate casting in constructors or static factory methods with proper error handling to turn untrusted input into reliably typed values. Used intentionally, casting bridges external data and strict typing without undermining type safety.

PHP 8 brought major improvements to type safety with the introduction of union types and the ability to run in strict mode via declare(strict_types=1);. These features make PHP feel more modern and predictable, reducing runtime surprises. But even in this stricter world, casting still plays a practical role — not because we’re bypassing types recklessly, but because real-world data doesn’t always arrive in the right form.

Let’s break down how casting fits into a modern, strictly-typed PHP application.

1. Type Declarations Reduce the Need for Casting — But Don’t Eliminate It

With PHP 8’s union types (int|string, array|null, etc.) and scalar type hints (int, string, bool, float), functions can now clearly define what they accept:

function processAge(int $age): string {
    return "User is $age years old.";
}

In strict_types=1 mode, you cannot pass a string like "25" to this function — it will throw a TypeError. That’s good: it enforces correctness at the boundary.

But here’s the catch: external input is rarely typed. Whether it’s from:

• HTTP requests ($_GET, $_POST)
• JSON APIs
• Database rows
• Configuration files

…you’re often dealing with strings, even when you need integers or booleans.

So while you shouldn’t cast inside a function that expects an int, you might cast before calling it — at the input layer.

// Controller or request handler
$rawAge = $_GET['age'] ?? null;

if (is_numeric($rawAge)) {
    $age = (int) $rawAge;
    echo processAge($age); // Now safe
}

? Casting happens at the edge, not in business logic.

2. Union Types Make Casting Safer and More Predictable

Before PHP 8, you might have written functions that accepted mixed types and did internal casting:

function formatPrice($price) {
    if (is_string($price)) {
        $price = (float) $price;
    }
    return number_format($price, 2);
}

Now, you can be explicit:

function formatPrice(int|float|string $price): string {
    $numericPrice = is_string($price) ? (float) $price : $price;
    return number_format($numericPrice, 2);
}

This is clearer and safer. The union type documents the valid inputs, and the casting is limited to known, safe conversions.

?? Important: Avoid casting blindly. (int)"hello" becomes 0, which might be dangerous. Always validate first.

function parsePort(string $port): ?int {
    if (ctype_digit($port) && $port > 0 && $port <= 65535) {
        return (int) $port;
    }
    return null;
}

3. When to Cast — and When Not To

Here’s a practical guide:

? Do cast at input boundaries:

• Convert string from HTTP to int, bool, etc.
• Normalize data before passing to typed functions
• Use casting after validation

? Don’t cast inside domain logic:

• Avoid (int)$this->id in an entity if it should already be an int
• Don’t use casting to “fix” type mismatches — fix the design instead

? Use casting in data transformers or DTOs:

class UserRequest
{
    public function __construct(
        public readonly int $id,
        public readonly string $name,
        public readonly bool $isActive
    ) {}

    public static function fromArray(array $data): self
    {
        return new self(
            id: (int) ($data['id'] ?? 0),
            name: (string) ($data['name'] ?? ''),
            isActive: (bool) ($data['active'] ?? false)
        );
    }
}

This keeps casting isolated and intentional.

4. Casting vs. Constructor Promotion and Validation

Even with strict types, you can’t fully avoid casting when building objects from arrays or external sources. But you can minimize risk:

• Use typed properties and constructors to enforce types after casting
• Combine casting with validation (e.g., filter_var, is_numeric, ctype_digit)
• Throw meaningful exceptions if casting fails

class UserId
{
    public function __construct(public readonly int $value)
    {
        if ($value <= 0) {
            throw new InvalidArgumentException('User ID must be positive.');
        }
    }

    public static function from(mixed $input): self
    {
        if (is_numeric($input)) {
            return new self((int) $input);
        }
        throw new InvalidArgumentException('Invalid user ID format.');
    }
}

Now casting is encapsulated, validated, and safe.

Bottom Line

In PHP 8 with strict and union types, casting isn’t obsolete — it’s just relocated. You don’t need it as much in the middle of your code, but you still need it at the edges where untyped data enters your system.

The key is discipline:

• Cast early, then rely on types
• Validate before casting
• Keep casting out of business logic
• Use union types to document acceptable inputs clearly

Used wisely, casting becomes a bridge — not a crutch.

Basically, it’s not about avoiding casting altogether. It’s about knowing where and why you’re doing it.

The above is the detailed content of The Role of Casting in a World of PHP 8 Strict and Union Types. For more information, please follow other related articles on the PHP Chinese website!