Modernes PHP unterstützt Typ-Deklarationen bei Funktionsparametern, Rückgabewerten und Klasseneigenschaften — und declare(strict_types=1) zur strikten Durchsetzung. Zusammen bringen sie einen großen Teil der Sicherheit statisch typisierter Sprachen nach PHP und fangen Fehler früh ab.
{
= ;
? = ;
{
->balance += ;
}
{
->balance;
}
}
Du kannst Parameter, Rückgabewerte und Klasseneigenschaften typisieren. Typen umfassen Skalare (int, float, string, bool), Klassen/Interfaces, array, ?Type (nullable) und 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 hat Union Types (int|string), Intersection Types und spezielle Rückgabetypen (static, never) hinzugefügt.
<?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) wechselt von lockerer Typumwandlung zu strikter Durchsetzung — PHP lehnt Typ-Mismatches ab, anstatt sie stillschweigend zu konvertieren. Dies fängt Fehler ab, die durch Typumwandlung verborgen würden.
Typ-Deklarationen und strikte Typen sind wichtig für das Schreiben von robustem, wartbarem modernem PHP und stellen eine große Weiterentwicklung der Sprache über ihre ursprüngliche schwach typisierte Natur dar.
Typ-Deklarationen bei Parametern, Rückgabewerten und Eigenschaften machen Code selbstdokumentierend (Signaturen zeigen deutlich Erwartungen) und ermöglichen PHP, Typ-Fehler automatisch zu erkennen, während moderne Ergänzungen (Union Types, nullable Types) Signaturen präzise machen.
Die wichtigste Praxis ist declare(strict_types=1): Es wechselt PHP von lockerer Typumwandlung (bei der "5" stillschweigend zu 5 wird und potenziell Fehler verbirgt) zu strikter Durchsetzung (lehnt nicht übereinstimmende Typen mit klarem TypeError ab) — ein Schlüsselwerkzeug zum frühen Erkennen von Fehlern und zum Schreiben zuverlässigen Codes, und der empfohlene moderne Standard.
Das Verständnis von Typ-Deklarationen und die Verwendung strikter Typen ist professionelles, alltägliches Wissen für moderne PHP-Entwicklung — es bringt einen großen Teil der Sicherheit statisch typisierter Sprachen nach PHP und macht Code robuster und leichter wartbar.
Da moderne PHP-Frameworks und gut geschriebene Codebasen Typing umfangreich nutzen (und strikte Typen überall verwenden), ist die Beherrschung hiervon wesentlich für das Schreiben und Arbeiten mit qualitativ hochwertigem zeitgenössischem PHP und unterscheidet typsicheren modernen Code vom fehleranfälligen schwach typisierten Stil älterer PHP-Versionen.