PHP ist eine dynamisch typisierte Sprache, in der Variablen keinen festen Typ besitzen. Das sorgt für Flexibilität, führt aber auch zu schwer aufspürbaren Fehlern, wenn eine Funktion einen String erwartet und stattdessen ein Array erhält. Type Hints (auch Typdeklarationen genannt) schaffen hier Abhilfe, indem sie den erwarteten Typ für Parameter, Rückgabewerte und Klassen-Properties festlegen. Dieses Tutorial erklärt alle Varianten von Type Hinting in PHP, zeigt den Unterschied zwischen dem Standard-Modus und strict_types und behandelt moderne Funktionen wie Union Types und Typed Properties.
Zum Einstieg wird zunächst geklärt, was Type Hints sind, wie sie funktionieren und welchen Mehrwert sie im Alltag bieten.
Was sind Type Hints?
Type Hints sind optionale Typangaben, die PHP mitteilen, welchen Datentyp ein Parameter, ein Rückgabewert oder eine Eigenschaft haben soll. Wird ein falscher Typ übergeben, wirft PHP einen TypeError. Dadurch werden Fehler frühzeitig erkannt, anstatt erst zur Laufzeit unerwartetes Verhalten zu verursachen. Gleichzeitig verbessern Type Hints die Lesbarkeit des Codes und die Unterstützung durch IDEs und statische Analyse-Tools.
<?php
function addiere(int $a, int $b): int
{
return $a + $b;
}
echo addiere(3, 7);
/* Ausgabe: 10 */
In diesem Beispiel legen int $a und int $b fest, dass beide Parameter ganzzahlig sein müssen. Der Teil : int nach der Parameterliste definiert den Rückgabetyp. Wird ein inkompatiler Wert übergeben, reagiert PHP je nach Konfiguration mit einer automatischen Konvertierung oder einem Fehler.
Typen für Funktionsparameter
Die häufigste Anwendung von Type Hints betrifft die Parameter einer Funktion. Seit PHP 7.0 stehen die vier skalaren Typen int, string, float und bool als Deklaration zur Verfügung. Zusätzlich lassen sich array, callable, Klassennamen und Interfaces als Typ angeben.
<?php
function begruessung(string $name, int $alter): string
{
return "Hallo {$name}, du bist {$alter} Jahre alt.";
}
echo begruessung('Anna', 28);
/* Ausgabe: Hallo Anna, du bist 28 Jahre alt. */
function summe(array $zahlen): float
{
return array_sum($zahlen);
}
echo summe([1.5, 2.3, 4.2]);
/* Ausgabe: 8 */
Der Parameter string $name stellt sicher, dass nur ein String als Name akzeptiert wird. Der Parameter array $zahlen garantiert, dass ein Array übergeben wird. Ohne diese Deklarationen könnte ein Aufrufer beliebige Werte übergeben, was erst später im Code zu unverständlichen Fehlern führen würde. Neben den skalaren Typen lassen sich auch eigene Klassen und Interfaces als Typ angeben. Ein Parameter mit dem Typ DateTimeInterface akzeptiert beispielsweise nur Objekte, die dieses Interface implementieren. Das macht den Code selbstdokumentierend und ermöglicht der IDE eine präzise Autovervollständigung.
Rückgabetypen deklarieren
Neben den Parametern lässt sich auch der Rückgabetyp einer Funktion festlegen. Die Deklaration steht nach einem Doppelpunkt hinter der Parameterliste. Besonders nützlich ist der Typ void, der angibt, dass eine Funktion keinen Wert zurückgibt.
<?php
function logge(string $nachricht): void
{
file_put_contents(
'app.log',
date('Y-m-d H:i:s') . " {$nachricht}" . PHP_EOL,
FILE_APPEND
);
/* Kein return-Wert erlaubt */
}
logge('Benutzer eingeloggt');
function berechneRabatt(float $preis, float $prozent): float
{
return $preis * ($prozent / 100);
}
echo berechneRabatt(99.90, 15);
/* Ausgabe: 14.985 */
Eine Funktion mit dem Rückgabetyp void darf kein return mit einem Wert enthalten. Ein leeres return; ohne Wert ist jedoch erlaubt, um die Funktion vorzeitig zu beenden. Seit PHP 8.1 gibt es zusätzlich den Typ never, der signalisiert, dass eine Funktion niemals normal beendet wird, etwa weil sie immer eine Exception wirft oder das Skript mit exit() beendet.
Nullable Types
In vielen Situationen soll eine Funktion neben dem eigentlichen Typ auch null als Wert akzeptieren oder zurückgeben können. Der Fragezeichen-Präfix ermöglicht genau das.
<?php
function findeBenutzer(int $id): ?string
{
$benutzer = [1 => 'Anna', 2 => 'Ben'];
return $benutzer[$id] ?? null;
}
$name = findeBenutzer(3);
/* $name ist null, kein Fehler */
$name = findeBenutzer(1);
/* $name ist 'Anna' */
function setzeSpitzname(?string $spitzname): string
{
if ($spitzname === null) {
return 'Kein Spitzname gesetzt';
}
return "Spitzname: {$spitzname}";
}
echo setzeSpitzname(null);
/* Ausgabe: Kein Spitzname gesetzt */
Die Schreibweise ?string bedeutet, dass der Wert entweder ein String oder null sein darf. Ohne das Fragezeichen würde die Übergabe von null einen TypeError auslösen. Nullable Types sind besonders hilfreich bei Datenbankabfragen, die kein Ergebnis liefern, oder bei optionalen Parametern. Seit PHP 8.0 kann statt ?string auch die Union-Schreibweise string|null verwendet werden. Beide Varianten sind funktional identisch, doch die Fragezeichen-Syntax ist kürzer und wird in der Praxis häufiger eingesetzt.
Strict Types aktivieren
Standardmäßig arbeitet PHP im sogenannten „coercive mode“. Das bedeutet, dass PHP versucht, einen übergebenen Wert automatisch in den erwarteten Typ umzuwandeln. Der String "5" wird beispielsweise stillschweigend zur Ganzzahl 5 konvertiert. Mit declare(strict_types=1) lässt sich dieses Verhalten unterbinden.
<?php
declare(strict_types=1);
function verdopple(int $zahl): int
{
return $zahl * 2;
}
echo verdopple(5);
/* Ausgabe: 10 */
echo verdopple("5");
/* TypeError: verdopple(): Argument #1 ($zahl) must be of type int, string given */
Ohne strict_types würde PHP den String "5" automatisch in die Ganzzahl 5 umwandeln und die Funktion würde 10 zurückgeben. Mit strict_types=1 wirft PHP stattdessen einen TypeError. Diese Deklaration muss in der allerersten Zeile der Datei stehen (nach dem öffnenden PHP-Tag) und gilt ausschließlich für die Datei, in der sie steht. Funktionen, die aus anderen Dateien aufgerufen werden, behalten ihr eigenes Verhalten.
Das folgende Diagramm veranschaulicht den Unterschied zwischen dem coercive mode und dem strict mode.
flowchart TD
A["Funktionsaufruf mit Type Hint"] --> B{"strict_types=1?"}
B -->|Nein| C["Coercive Mode"]
B -->|Ja| D["Strict Mode"]
C --> E{"Konvertierung möglich?"}
E -->|Ja| F["Wert wird umgewandelt"]
E -->|Nein| G["TypeError"]
D --> H{"Typ stimmt exakt?"}
H -->|Ja| I["Wert wird akzeptiert"]
H -->|Nein| G
Type Hints für Klassen-Properties
Seit PHP 7.4 lassen sich auch die Eigenschaften einer Klasse mit einem Typ versehen. Diese sogenannten Typed Properties verhindern, dass einer Eigenschaft ein Wert mit falschem Typ zugewiesen wird.
<?php
class Produkt
{
public string $name;
public float $preis;
public ?string $beschreibung = null;
public function __construct(string $name, float $preis)
{
$this->name = $name;
$this->preis = $preis;
}
public function info(): string
{
return "{$this->name}: {$this->preis} EUR";
}
}
$laptop = new Produkt('Laptop', 899.99);
echo $laptop->info();
/* Ausgabe: Laptop: 899.99 EUR */
Eine wichtige Stolperfalle bei Typed Properties betrifft den Zugriff vor der Initialisierung. Wird eine typisierte Eigenschaft gelesen, bevor ihr ein Wert zugewiesen wurde, wirft PHP den Fehler „must not be accessed before initialization“. Deshalb ist es empfehlenswert, alle typisierten Properties im Konstruktor zu setzen oder einen Standardwert anzugeben. Die Eigenschaft ?string $beschreibung = null zeigt, wie ein Nullable-Typ mit einem Standardwert kombiniert wird.
Union Types und Intersection Types
Seit PHP 8.0 ermöglichen Union Types die Angabe mehrerer erlaubter Typen für einen Parameter, einen Rückgabewert oder eine Property. Die Typen werden mit dem Pipe-Zeichen getrennt. Seit PHP 8.1 gibt es zusätzlich Intersection Types, die verlangen, dass ein Wert mehreren Typen gleichzeitig entspricht.
<?php
class Rechnung
{
public int|string $nummer;
public float $betrag;
public function __construct(int|string $nummer, float $betrag)
{
$this->nummer = $nummer;
$this->betrag = $betrag;
}
public function formatiere(): string
{
return "Rechnung {$this->nummer}: {$this->betrag} EUR";
}
}
$r1 = new Rechnung(1001, 249.99);
echo $r1->formatiere();
/* Ausgabe: Rechnung 1001: 249.99 EUR */
$r2 = new Rechnung('INV-2024', 549.00);
echo $r2->formatiere();
/* Ausgabe: Rechnung INV-2024: 549 EUR */
Der Union Type int|string erlaubt sowohl ganzzahlige als auch textbasierte Rechnungsnummern. Intersection Types verwenden das Zeichen & und sind vor allem bei Interfaces nützlich: Ein Parameter mit dem Typ Countable&Iterator akzeptiert nur Objekte, die beide Interfaces implementieren. Seit PHP 8.2 lassen sich Union und Intersection Types mit Klammern sogar kombinieren, beispielsweise (Countable&Iterator)|null.
Entwicklung der Type Hints in PHP
Type Hints haben sich über mehrere PHP-Versionen hinweg entwickelt. Die folgende Übersicht zeigt die wichtigsten Meilensteine.
In PHP 5 waren ausschließlich Klassen und Interfaces als Typangaben für Parameter möglich. Mit PHP 7.0 kamen die skalaren Typen int, string, float und bool hinzu, zusammen mit Rückgabetypen und der Direktive declare(strict_types=1). PHP 7.1 brachte Nullable Types mit dem Fragezeichen-Präfix sowie den Rückgabetyp void. In PHP 7.4 folgten Typed Properties für Klasseneigenschaften. PHP 8.0 führte Union Types und den Typ mixed ein, der jeden beliebigen Wert akzeptiert. Mit PHP 8.1 kamen Intersection Types und der Rückgabetyp never. PHP 8.2 ergänzte schließlich die sogenannten DNF Types (Disjunctive Normal Form), die Union und Intersection Types in Kombination erlauben.
Diese stetige Weiterentwicklung zeigt, dass PHP immer mehr Werkzeuge für Typsicherheit bereitstellt, ohne dabei die Rückwärtskompatibilität aufzugeben. Jede neue Version macht den Einsatz von Type Hints leistungsfähiger und ausdrucksstärker. Bestehender Code ohne Typdeklarationen funktioniert weiterhin, da alle Type Hints optional bleiben. Teams können ihre Codebasis schrittweise mit Typangaben erweitern, anstatt alles auf einmal umstellen zu müssen. Besonders in größeren Projekten zahlt sich diese Investition durch weniger Laufzeitfehler und eine bessere Wartbarkeit aus.
Fazit
Type Hints gehören zu den wichtigsten Sprachfeatures für robusten PHP Code. Sie machen den erwarteten Datentyp von Parametern, Rückgabewerten und Properties explizit sichtbar und verhindern typbedingte Fehler bereits beim Funktionsaufruf. Im coercive mode konvertiert PHP inkompatible Werte nach Möglichkeit automatisch, während declare(strict_types=1) eine strenge Typprüfung erzwingt. Nullable Types mit dem Fragezeichen-Präfix erlauben null als zusätzlichen Wert, und Union Types bieten die Flexibilität, mehrere Typen für einen Parameter zu akzeptieren. Typed Properties seit PHP 7.4 erweitern die Typsicherheit auf Klasseneigenschaften. Wer Type Hints konsequent einsetzt, profitiert von besserer IDE-Unterstützung, aussagekräftigeren Fehlermeldungen und einem Code, der auch im Team verständlich und wartbar bleibt. Der Einstieg gelingt am besten, indem zunächst alle neuen Funktionen und Methoden mit Typdeklarationen geschrieben werden. Bestehender Code kann dann Schritt für Schritt nachgerüstet werden, bis das gesamte Projekt von durchgängiger Typsicherheit profitiert.
