Lange Funktionsaufrufe mit mehreren Wahrheitswerten oder Zahlen sind schwer zu lesen, weil aus dem Aufruf allein nicht hervorgeht, welcher Wert wofür steht. Seit PHP 8.0 lösen benannte Argumente dieses Problem, indem sie jedem Wert den passenden Parameternamen voranstellen. Dieser Beitrag zeigt die Syntax, die Reihenfolge-Regeln und die wichtigsten Einsatzgebiete.
Was sind PHP Named Arguments?
Wer schon einmal einen Funktionsaufruf wie setOption(true, false, true, 30, 'red') gelesen hat, kennt das Problem: Was bedeutet das dritte true? Welcher Wert steht für was? Genau hier setzen PHP Named Arguments an. Seit PHP 8.0 lassen sich Argumente beim Aufruf mit dem Parameternamen versehen, und der Code wird auf einen Schlag deutlich lesbarer. Aus der kryptischen Zeile wird setOption(enabled: true, persistent: false, secure: true, timeout: 30, color: 'red').
Bevor Syntax, Reihenfolge-Regeln und Constructor Promotion an die Reihe kommen, ein kurzer Blick auf den Lesbarkeits-Gewinn im Alltag.
PHP Named Arguments wirken auf den ersten Blick wie eine Kleinigkeit, sind aber eines der wichtigsten Lesbarkeits-Features in moderner PHP-Entwicklung. Sie machen Boolean-Parameter selbsterklärend, ersetzen das alte Array-Optionen-Pattern für Methoden mit vielen Parametern und passen perfekt zu Constructor Promotion. Wer die Parameternamen in der Funktionssignatur konsistent pflegt, kann optionale Argumente gezielt überspringen. Dieses Tutorial zeigt die Syntax, die Reihenfolge-Regeln, das Zusammenspiel mit Variadics und Spread-Operator sowie die typischen Stolperfallen.
Syntax und Reihenfolge-Regeln
Die Syntax ist denkbar einfach: Ein Argument wird mit dem Parameternamen, einem Doppelpunkt und dem Wert übergeben. Positionale Argumente können kombiniert werden, müssen aber zuerst stehen. Sobald ein benanntes Argument verwendet wurde, sind alle folgenden Argumente ebenfalls benannt.
<?php
function setOption(bool $enabled, bool $persistent, bool $secure, int $timeout, string $color): void
{
/* ... */
}
/* Variante 1: alle positional, schwer lesbar */
setOption(true, false, true, 30, 'red');
/* Variante 2: alle benannt, klar lesbar */
setOption(
enabled: true,
persistent: false,
secure: true,
timeout: 30,
color: 'red',
);
/* Variante 3: positional + benannt (positional zuerst) */
setOption(true, false, secure: true, timeout: 30, color: 'red');
Wichtig ist die Regel "positional zuerst, benannt danach". Wer ein positionales Argument nach einem benannten verwendet, bekommt einen Syntax-Fehler. Die Reihenfolge der benannten Argumente ist dagegen egal: setOption(color: 'red', enabled: true, ...) funktioniert genauso wie die andere Reihenfolge.
Optionale Parameter überspringen
Ein typischer Anwendungsfall für PHP Named Arguments ist das Überspringen optionaler Parameter. Früher musste man explizit null oder den Default-Wert erneut angeben, um einen späteren Parameter zu erreichen. Mit benannten Argumenten greift man direkt den Parameter, der gesetzt werden soll.
<?php
function greet(string $name, string $greeting = 'Hallo', string $tone = 'freundlich'): string
{
return "$greeting, $name (Ton: $tone)";
}
/* Frueher musste man die Defaults erneut setzen */
echo greet('Lukas', 'Hallo', 'foermlich');
/* Heute reicht ein benanntes Argument */
echo greet('Lukas', tone: 'foermlich');
/* "Hallo, Lukas (Ton: foermlich)" */
Damit fallen viele null, null, null-Sequenzen weg, die in alten APIs noch zu finden sind. Der Aufruf zeigt sofort, welcher Parameter geändert wird, und alle anderen behalten ihre Defaults.
Named Arguments mit Constructor Promotion
Die Kombination aus PHP Named Arguments und Constructor Promotion macht DTO-Klassen besonders kompakt. Ein DTO mit fünf Eigenschaften wird in zwei Zeilen definiert und beim new selbsterklärend befüllt.
<?php
final class User
{
public function __construct(
public string $name,
public string $email,
public ?int $age = null,
public bool $isAdmin = false,
) {}
}
$user = new User(
name: 'Lukas',
email: 'lukas@example.com',
isAdmin: true,
);
Hier wird $age automatisch auf den Default null gesetzt, weil das Argument nicht übergeben wurde. Wer das DTO erweitert, ergänzt einfach einen weiteren Parameter mit Default, und alle bestehenden Aufrufer bleiben kompatibel. Diese Kombination ist einer der stärksten Gründe, in PHP 8 konsequent auf Named Arguments umzusteigen.
Vergleich zum Array-Optionen-Pattern
Vor PHP 8 war es üblich, Methoden mit vielen Optionen ein assoziatives Array entgegennehmen zu lassen. Das war flexibel, hatte aber drei Nachteile: keine Type-Hints, kein Auto-Complete der IDE und Tippfehler in Schlüsseln blieben unerkannt. PHP Named Arguments lösen alle drei Probleme auf einmal.
<?php
/* Frueher: assoziatives Array, kein Type-Hint, kein IDE-Support */
function makeRequestOld(string $url, array $options = []): void
{
$timeout = $options['timeout'] ?? 30;
$verify = $options['verify'] ?? true;
}
makeRequestOld('https://example.com', ['timeout' => 10, 'verify' => false]);
/* Heute: typisierte Parameter mit Defaults plus Named Arguments */
function makeRequest(string $url, int $timeout = 30, bool $verify = true): void
{
/* ... */
}
makeRequest('https://example.com', timeout: 10, verify: false);
Der typisierte Aufruf erlaubt der IDE Auto-Complete für alle Parameter, statische Analyse-Tools wie PHPStan und Psalm prüfen Typen und Tippfehler im Parameternamen werden zur Laufzeit als Error: Unknown named parameter gemeldet, statt still ignoriert zu werden.
flowchart TD
A[Funktionsaufruf] --> B{Named Argument?}
B -->|Ja| C[Parameter per Name zuweisen]
B -->|Nein| D[Parameter per Position zuweisen]
C --> E{Tippfehler?}
E -->|Ja| F[Error: Unknown named parameter]
E -->|Nein| G[Aufruf erfolgreich]
D --> G
Variadics und Spread-Operator
Die Kombination aus PHP Named Arguments und Variadic-Parametern ist eine der weniger bekannten Eigenschaften. Wenn eine Funktion einen ...$args-Parameter hat, landen benannte Argumente im Array $args mit dem Parameternamen als Schlüssel.
<?php
function buildQuery(string $base, mixed ...$params): string
{
/* benannte Argumente landen in $params als assoziatives Array */
return $base . '?' . http_build_query($params);
}
echo buildQuery('search', q: 'php', limit: 10);
/* "search?q=php&limit=10" */
Auch der Spread-Operator arbeitet mit Named Arguments zusammen. Wer ein assoziatives Array hat, dessen Keys den Parameternamen entsprechen, kann es per ...$data direkt als Konstruktor-Argumente übergeben.
<?php
$data = ['name' => 'Lukas', 'email' => 'a@b.de', 'isAdmin' => true];
$user = new User(...$data);
/* aequivalent zu: new User(name: 'Lukas', email: 'a@b.de', isAdmin: true) */
Voraussetzung ist, dass die Array-Keys exakt mit den Parameternamen übereinstimmen, sonst wirft PHP einen Fehler. Diese Schreibweise ist besonders praktisch beim Mapping von API-Antworten oder Datenbank-Zeilen auf typisierte Objekte.
Stolperfallen und Best Practices
Im Alltag mit PHP Named Arguments lauern drei typische Fallen. Erstens: Tippfehler in Parameternamen erzeugen einen Error: Unknown named parameter $name. Eine gute IDE markiert das schon vor dem Ausführen, ein Blick auf die Funktionssignatur hilft im Zweifel.
Zweitens: Parameternamen werden Teil der öffentlichen API. Wer einen Parameter umbenennt, bricht alle Aufrufer-Calls, die ihn benannt verwenden. Bei Bibliotheks-Code ist das ein Breaking Change und gehört in den Changelog. Drittens: Named Arguments funktionieren erst ab PHP 8.0. Wer noch 7.4 oder älter im Einsatz hat, bekommt einen Parse-Error. Eine kurze Prüfung der Mindest-PHP-Version im composer.json schützt vor unangenehmen Überraschungen.
Eine gute Faustregel für den Einsatz lautet: Bei Funktionen mit vier oder mehr Parametern oder bei einem Boolean-Argument fast immer benannt aufrufen. Bei einem oder zwei Parametern ist die positionale Schreibweise oft kompakter und bleibt gut lesbar. So bekommt der Code die Lesbarkeit, ohne unnötig aufgebläht zu werden.
Eine Frage, die im Code-Review oft auftaucht, ist die Reihenfolge benannter Argumente. Soll man sie in der Reihenfolge der Funktionssignatur schreiben oder thematisch gruppieren? Beide Varianten sind syntaktisch erlaubt. In der Praxis hilft es, der Reihenfolge der Funktionssignatur zu folgen, weil das die Diff-Lesbarkeit verbessert und gut zu IDE-Refactorings passt. Eine thematische Gruppierung ist nur bei sehr langen DTO-Konstruktoren mit mehr als zehn Parametern wirklich hilfreich.
Ein letzter Hinweis betrifft die Performance. PHP Named Arguments haben praktisch keinen Overhead gegenüber positionalen Argumenten. Der Compiler ordnet die Argumente bereits beim Parsen den passenden Parametern zu, und zur Laufzeit verhält sich der Aufruf wie ein klassischer positional Call. Wer also eine Funktion mit Named Arguments aufruft, zahlt keinen messbaren Preis für die bessere Lesbarkeit. Damit steht den PHP Named Arguments im Alltag eigentlich nichts mehr im Wege, ausser der unbedingten Voraussetzung PHP 8.0 oder neuer.
Fazit
PHP Named Arguments sind ein kleines Feature mit großer Wirkung. Sie verwandeln kryptische Funktionsaufrufe in lesbare Code-Zeilen, überspringen optionale Parameter elegant und ersetzen das alte Array-Optionen-Pattern für Konfigurations-Methoden. Zusammen mit Constructor Promotion entstehen sehr kompakte DTO-Klassen, und im Zusammenspiel mit Spread-Operator und Variadics lassen sich Daten flexibel weitergeben. Wer PHP 8.0 oder neuer einsetzt, sollte PHP Named Arguments fest in seinen Werkzeugkasten aufnehmen und im Code-Review aktiv einfordern, sobald ein Funktionsaufruf nicht mehr selbsterklärend ist.
