ArgumentCountError — Klasse · PHP-Referenz

Signatur

class ArgumentCountError extends TypeError

Beschreibung

ArgumentCountError ist eine Fehlerklasse, die geworfen wird, wenn eine benutzerdefinierte Funktion oder Methode mit zu wenigen Argumenten aufgerufen wird. Sie erbt von TypeError und ist damit Teil der Fehlerhierarchie unterhalb von Error.

Typische Auslöser sind Funktionsaufrufe, bei denen Pflichtparameter nicht übergeben werden, oder Aufrufe über call_user_func_array() mit einem zu kurzen Argument-Array. Im Gegensatz zu nativen PHP-Funktionen, die bei zu wenigen Argumenten ebenfalls einen ArgumentCountError auslösen können, betrifft diese Klasse primär benutzerdefinierte Funktionen.

Da ArgumentCountError von Error (nicht von Exception) erbt, muss sie entweder mit einem spezifischen catch(ArgumentCountError $e)-Block oder einem allgemeinen catch(Error $e)- bzw. catch(Throwable $e)-Block abgefangen werden. Dies ist besonders in Frameworks und Plugin-Architekturen relevant, wo Funktionen dynamisch aufgerufen werden.

Ab PHP 8.0 wird ArgumentCountError auch geworfen, wenn beim Aufruf interner PHP-Funktionen zu wenige Argumente übergeben werden – vorher war das Verhalten dort undefiniert oder erzeugte nur Warnungen.

Beispiele

Einfacher ArgumentCountError durch fehlende Pflichtargumente

<?php
function addiere(int $a, int $b): int {
    return $a + $b;
}

try {
    $ergebnis = addiere(5); // $b fehlt
} catch (ArgumentCountError $e) {
    echo 'Fehler: ' . $e->getMessage() . PHP_EOL;
    echo 'In Datei: ' . $e->getFile() . ', Zeile: ' . $e->getLine() . PHP_EOL;
}

Fehler: addiere(): Argument #2 ($b) not passed In Datei: /pfad/zur/datei.php, Zeile: 7

ArgumentCountError beim dynamischen Funktionsaufruf über call_user_func_array

<?php
function begruessung(string $name, string $titel): string {
    return "Hallo, {$titel} {$name}!";
}

$argumente = ['Müller']; // $titel fehlt

try {
    $ergebnis = call_user_func_array('begruessung', $argumente);
    echo $ergebnis . PHP_EOL;
} catch (ArgumentCountError $e) {
    echo 'Zu wenige Argumente übergeben: ' . $e->getMessage() . PHP_EOL;
} catch (TypeError $e) {
    echo 'Typfehler: ' . $e->getMessage() . PHP_EOL;
}

Zu wenige Argumente übergeben: begruessung(): Argument #2 ($titel) not passed

Eigene Unterklasse für spezifischere Fehlerbehandlung

<?php
class ApiArgumentCountError extends ArgumentCountError {
    public function __construct(string $funktion, int $erwartet, int $erhalten) {
        $nachricht = "API-Aufruf '{$funktion}' erwartet {$erwartet} Argumente, {$erhalten} erhalten.";
        parent::__construct($nachricht);
    }
}

function apiAufruf(string $endpunkt, array $parameter, string $token): void {
    if (func_num_args() < 3) {
        throw new ApiArgumentCountError('apiAufruf', 3, func_num_args());
    }
    // API-Logik ...
}

try {
    throw new ApiArgumentCountError('apiAufruf', 3, 1);
} catch (ApiArgumentCountError $e) {
    echo $e->getMessage() . PHP_EOL;
} catch (ArgumentCountError $e) {
    echo 'Allgemeiner ArgumentCountError: ' . $e->getMessage() . PHP_EOL;
}

API-Aufruf 'apiAufruf' erwartet 3 Argumente, 1 erhalten.

// Wichtig · Fallstricke

Vererbungshierarchie: ArgumentCountError → TypeError → Error → Throwable. Ein catch(Exception $e)-Block fängt diesen Fehler nicht ab.

PHP 8.0+: Ab PHP 8.0 werden auch zu wenige Argumente bei eingebauten PHP-Funktionen (wie strlen(), array_map() etc.) als ArgumentCountError geworfen, anstatt nur eine Warnung auszugeben. Code, der bislang Warnungen ignorierte, kann in PHP 8+ unerwartet abbrechen.

Variadische Funktionen: Bei Funktionen mit variadischen Parametern (...$args) wird kein ArgumentCountError geworfen, wenn keine Argumente für den variadischen Teil übergeben werden – dieser Teil ist implizit optional.

Siehe auch

TypeError Error Throwable call_user_func_array func_num_args ValueError