Modern PHP supports type declarations on function parameters, return values, and class properties — and declare(strict_types=1) to enforce them strictly. Together they bring much of the safety of statically-typed languages to PHP, catching bugs early.
{
= ;
? = ;
{
->balance += ;
}
{
->balance;
}
}
You can type parameters, return values, and class properties. Types include scalars (int, float, string, bool), classes/interfaces, array, ?Type (nullable), and void.
function process(int|string $id): User|null { } // union type — int OR string
function handle(Countable&Iterator $x): void { } // intersection (PHP 8.1) — BOTH
function get(): static { } // return the called class's type
function nothing(): never { } // never returns (throws/exits, PHP 8.1)
PHP 8 added union types (int|string), intersection types, and special return types (static, never).
<?php
declare(strict_types=1); // MUST be the first statement in the file
function add(int $a, int $b): int { return $a + $b; }
add(5, 3); // ✅ 8
add("5", 3); // ❌ TypeError — strict_types REJECTS the string (no coercion)
WITHOUT strict_types (default "coercive" mode):
add("5", 3) → "5" is silently coerced to int 5 → returns 8 (lenient, can hide bugs)
WITH strict_types=1:
add("5", 3) → TypeError immediately (must pass the exact declared type)
declare(strict_types=1) switches from lenient coercion to strict enforcement — PHP rejects type mismatches instead of silently converting them. This catches bugs that coercion would hide.
Type declarations and strict types are important for writing robust, maintainable modern PHP, and they represent a major evolution of the language beyond its loosely-typed origins.
Type declarations on parameters, returns, and properties make code self-documenting (signatures clearly state expectations) and let PHP catch type errors automatically, while modern additions (union types, nullable types) make signatures precise.
The most important practice is declare(strict_types=1): it switches PHP from lenient coercion (where "5" silently becomes 5, potentially hiding bugs) to strict enforcement (rejecting mismatched types with a clear TypeError) — a key tool for catching bugs early and writing reliable code, and the recommended modern default.
Understanding type declarations and using strict types is professional, everyday knowledge for modern PHP development — it brings much of the safety of statically-typed languages to PHP, making code more robust and easier to maintain.
Since modern PHP frameworks and well-written codebases use typing extensively (and strict types throughout), mastering this is essential for writing and working with quality contemporary PHP, distinguishing type-safe modern code from the error-prone loosely-typed style of older PHP.