Mit einer Parameterliste kann man Informationen an eine Funktion übergeben. Die Parameterliste ist eine durch Kommas getrennte Liste von Ausdrücken. Die Parameter werden von links nach rechts ausgewertet.
PHP unterstützt die Weitergabe von Parametern als Werte (das ist der Standard), als Verweise und als Vorgabewerte. Eine variable Anzahl von Parametern wird ebenfalls unterstützt.
Beispiel #1 Arrays an Funktionen übergeben
<?php
function nimm_array($eingabe)
{
echo "$eingabe[0] + $eingabe[1] = ", $eingabe[0]+$eingabe[1];
}
?>
Normalerweise werden den Funktionen Werte als Parameter übermittelt. Wenn man den Wert dieses Parameters innerhalb der Funktion ändert, bleibt der Parameter außerhalb der Funktion unverändert. Wollen Sie aber erreichen, dass die Änderung auch außerhalb der Funktion sichtbar wird, müssen Sie die Parameter als Verweise (Referenzen) übergeben.
Wenn eine Funktion einen Parameter generell als Verweis behandeln soll, setzt man in der Funktionsdefinition ein kaufmännisches Und (&) vor den Parameternamen:
Beispiel #2 Übergeben von Funktionsparametern als Verweis
<?php
function fuege_etwas_an(&$string)
{
$string .= 'und etwas mehr.';
}
$str = 'Dies ist ein String, ';
fuege_etwas_an($str);
echo $str; // Ausgabe: 'Dies ist ein String, und etwas mehr.'
?>
Eine Funktion kann C++-artige Vorgabewerte für skalare Parameter wie folgt definieren:
Beispiel #3 Einsatz von Vorgabeparametern in Funktionen
<?php
function machkaffee($typ = "Cappucino")
{
return "Ich mache eine Tasse $typ.\n";
}
echo machkaffee();
echo machkaffee(null);
echo machkaffee("Espresso");
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Ich mache eine Tasse Cappucino. Ich mache eine Tasse . Ich mache eine Tasse Espresso.
PHP gestattet es, Arrays und den speziellen Typ NULL als
Vorgabewert zu nutzen, zum Beispiel:
Beispiel #4 Nichtskalare Typen als Vorgabewert
<?php
function makecoffee($types = array("cappuccino"), $coffeeMaker = NULL)
{
$device = is_null($coffeeMaker) ? "hands" : $coffeeMaker;
return "Ich mache eine Tasse ".join(", ", $types)." mit $device.\n";
}
echo makecoffee();
echo makecoffee(array("cappuccino", "lavazza"), "teapot");
?>
Der Vorgabewert muss ein konstanter Ausdruck sein, darf also zum Beispiel keine Variable, Eigenschaft einer Klasse oder ein Funktionsaufruf sein.
Bitte beachten Sie, dass alle Parameter mit Vorgabewert rechts von den Parametern ohne Vorgabewert stehen müssen - sonst wird es nicht funktionieren. Betrachten Sie folgendes Beispiel:
Beispiel #5 Ungültige Anwendung von Vorgabewerten
<?php
function mach_joghurt($typ = "rechtsdrehendes", $geschmack)
{
return "Mache einen Becher $typ $geschmack-joghurt.\n";
}
echo mach_joghurt("Brombeer"); // arbeitet nicht wie erwartet
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Warning: Missing argument 2 in call to mach_joghurt() in /usr/local/etc/httpd/htdocs/phptest/functest.html on line 41 Mache einen Becher Brombeer -joghurt.
Nun vergleichen Sie bitte obiges Beispiel mit folgendem:
Beispiel #6 Richtiger Einsatz von Vorgabewerten
<?php
function mach_joghurt($geschmack, $typ = "rechtsdrehendes")
{
return "Mache einen Becher $typ $geschmack-Joghurt.\n";
}
echo mach_joghurt("Brombeer"); // arbeitet wie erwartet.
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Mache einen Becher rechtsdrehendes Brombeer-Joghurt.
Hinweis: Das Setzen von Standardwerten für Argumente, die als Referenz übergeben werden ("passed by reference") wird seit PHP 5 unterstützt.
Hinweis:
Typdeklarationen waren unter PHP 5 ebenfalls unter dem Namen Type-Hints bekannt.
Typdeklarationen erlauben es, dass Funktionsparameter zur Aufrufzeit von einem bestimmten Typ sind. Ist der gegebene Wert von einem falschen Typ, dann wird ein Fehler generiert: in PHP 5 ist es ein recoverable fatal error, während PHP 7 eine TypeError-Exception auslöst.
Um eine Typdeklaration zu spezifizieren, sollte der Typname vor dem Parameternamen hinzugefügt werden.
Wird der Vorgabewert des Parameters als NULL definiert, akzeptiert die Funktion die Übergabe von NULL.
| Typ | Beschreibung | Minimale PHP-Version |
|---|---|---|
| Klassen/Interface-Name | Der Parameter muss ein Exemplar (instanceof) der gegebenen Klasse oder des Interface sein. | PHP 5.0.0 |
| self | Der Parameter muss ein Exemplar (instanceof) der selben Klasse sein für die die Methode definiert ist. Dies kann nur für Klassen- und Objektmethoden verwendet werden. | PHP 5.0.0 |
| array | Der Parameter muss ein Array sein. | PHP 5.1.0 |
| callable | Der Parameter muss ein gültiges Callable sein. | PHP 5.4.0 |
| bool | Der Parameter muss ein Boolescher Wert (boolean) sein. | PHP 7.0.0 |
| float | Der Parameter muss eine Gleitkommazahl (float) sein. | PHP 7.0.0 |
| int | Der Parameter muss eine Ganzzahl (integer) sein. | PHP 7.0.0 |
| string | Der Parameter muss ein String sein. | PHP 7.0.0 |
Aliase der oben genannten skalaren Typen werden nicht unterstützt. Statt dessen werden sie als Klassen- oder Schnittstellennamen angesehen. Zum Beispiel erfordert die Verwendung von boolean als Parameter oder Rückgabetyp ein Argument oder einen Rückgabewert, der ein Exemplar (instanceof) der Klasse oder Schnittstelle boolean ist, anstatt vom Typ bool:
<?php
function test(boolean $param) {}
test(true);
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Fatal error: Uncaught TypeError: Argument 1 passed to test() must be an instance of boolean, boolean given, called in - on line 1 and defined in -:1
Beispiel #7 Grundlegende Klassen-Typdeklaration
<?php
class C {}
class D extends C {}
// Dies erweitert C nicht.
class E {}
function f(C $c) {
echo get_class($c)."\n";
}
f(new C);
f(new D);
f(new E);
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
C
D
Fatal error: Uncaught TypeError: Argument 1 passed to f() must be an instance of C, instance of E given, called in - on line 14 and defined in -:8
Stack trace:
#0 -(14): f(Object(E))
#1 {main}
thrown in - on line 8
Beispiel #8 Gundlegende Interface-Typdeklaration
<?php
interface I { public function f(); }
class C implements I { public function f() {} }
// Dies implementiert I nicht.
class E {}
function f(I $i) {
echo get_class($i)."\n";
}
f(new C);
f(new E);
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
C
Fatal error: Uncaught TypeError: Argument 1 passed to f() must implement interface I, instance of E given, called in - on line 13 and defined in -:8
Stack trace:
#0 -(13): f(Object(E))
#1 {main}
thrown in - on line 8
Beispiel #9 Nullable Typdeklaration
<?php
class C {}
function f(C $c = null) {
var_dump($c);
}
f(new C);
f(null);
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
object(C)#1 (0) {
}
NULL
Standardmäßig erzwingt PHP die Umwandlung von Wertem des falschen Typs in den erwarteten skalaren Typ, falls möglich. Zum Beispiel erhält eine Funktion, der ein Integer für einen Parameter, der einen String erwartet, übergeben wurde, eine Variable vom Typ String.
Es ist möglich die strenge Typsierung für einzelne Dateien zu aktivieren. Im strengem Typisierungsmodus werden nur Variablen von genau dem Typ der Typdeklaration akzeptiert, oder ein TypeError wird ausgelöst. Die einzige Ausnahme dieser Regel ist, dass ein Integer an eine Funktion, die ein Float erwartet, übergeben werden darf. Funktionsaufrufe innerhalb von internen Funktionen sind nicht von der strict_types-Deklaration betroffen.
Um die strenge Typisierung zu aktivieren, wird die declare-Anweisung mit der strict_types-Deklaration verwendet:
Das Aktivieren der strengen Typisierung betrifft ebenfalls Rückgabe-Typdeklarationen.
Hinweis:
Strenge Typisierung gilt für Funktionsaufrufe, die innerhalb einer Datei im strengen Typisierungsmodus durchgeführt werden, nicht für Funktionen, die innerhalb dieser Datei deklariert wurden. Ruft eine Datei, für die strenge Typisierung nicht aktiviert ist, eine Funktion, die in einer Datei im strengen Typisierungsmodus definiert wurde, auf, wird die Präferenz des Aufrufers (schwache Typsierung) beachtet, und die Konvertierung des Werts wird erzwungen.
Hinweis:
Strenge Typsierung ist nur für skalare Typdeklarationen gültig, und erfodert folglich PHP 7.0.0 oder höher, da skalare Typdeklarationen erst in dieser Version hinzugefügt wurden.
Beispiel #10 Strenge Typisierung
<?php
declare(strict_types=1);
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
int(3)
Fatal error: Uncaught TypeError: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 9 and defined in -:4
Stack trace:
#0 -(9): sum(1.5, 2.5)
#1 {main}
thrown in - on line 4
Beispiel #11 Schwache Typisierung
<?php
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
// Die Konvertierung nach Integer wird erzwungen: beachten Sie die Ausgabe weiter unten!
var_dump(sum(1.5, 2.5));
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
int(3) int(3)
Beispiel #12 Abfangen von TypeError
<?php
declare(strict_types=1);
function sum(int $a, int $b) {
return $a + $b;
}
try {
var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
} catch (TypeError $e) {
echo 'Fehler: '.$e->getMessage();
}
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
int(3) Fehler: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 10
PHP unterstützt eine variable Anzahl an Parametern für benutzerdefinierte Funktionen. Dies wird seit PHP 5.6 durch das Token ... umgesetzt. Für ältere Versionen von PHP stehen die Funktionen func_num_args(), func_get_arg(), und func_get_args() bereit.
Ab PHP 5.6 kann eine Liste von Parametern das Token ... enthalten, um anzugeben, dass die Funktion eine variable Anzahl von Paramtern akzeptiert. Die zusätzlichen Werte werden als Array an die entsprechende Variable übergeben. Zum Beispiel:
Beispiel #13 Verwendung von ... für den Zugriff auf variable Parameter
<?php
function sum(...$numbers) {
$acc = 0;
foreach ($numbers as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
10
Das Token ... kann ebenfalls dazu verwendet werden, um ein Array oder Traversable-Objekt als Liste von Parametern zu übergeben:
Beispiel #14 Verwendung von ... zur Übergabe einer Parameterliste
<?php
function add($a, $b) {
return $a + $b;
}
echo add(...[1, 2])."\n";
$a = [1, 2];
echo add(...$a);
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
3 3
Die Definition von regulären, positionierten Parametern vor dem ... ist natürlich weiterhin möglich. In einem solchen Fall werden dann nur die zusätzlichen Werte, die zu keinem positionierten Parameter gehören, in das durch ... erzeugte Array übernommen.
Es ist zudem ebenfalls möglich dem ... Token eine Typangabe voran zu stellen. Ist dies der Fall, müssen alle Werte, die für ... relevant sind, vom entsprechenden Typ sein.
Beispiel #15 Variable Paramter mit Vorgabe des Typs
<?php
function total_intervals($unit, DateInterval ...$intervals) {
$time = 0;
foreach ($intervals as $interval) {
$time += $interval->$unit;
}
return $time;
}
$a = new DateInterval('P1D');
$b = new DateInterval('P2D');
echo total_intervals('d', $a, $b).' days';
// Dieser Aufruf wird scheitern, da null keine Instanz von DateInterval ist
echo total_intervals('d', null);
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
3 days Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
Durch ein voran gestelltes & ist auch die Übergabe von variablen Parametern als Referenz möglich.
Eine spezielle Syntax ist zur Definition von variablen Paramtern nicht notwendig. Um auf die übergebenen Werte zugreifen zu können, stehen die Funktionen func_num_args(), func_get_arg() und func_get_args() bereit.
Das erste Beispiel von weiter oben würde in PHP 5.5 und davor so umgesetzt werden können:
Beispiel #16 Zugriff auf variable Parameter in PHP 5.5 und davor
<?php
function sum() {
$acc = 0;
foreach (func_get_args() as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
10