Funktionsparameter
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];
}
?>
As of PHP 8.0.0, the list of function arguments may include a trailing comma, which
will be ignored. That is particularly useful in cases where the list of arguments is
long or contains long variable names, making it convenient to list arguments vertically.
Beispiel #2 Function Argument List with trailing Comma
<?php
function takes_many_args(
$first_arg,
$second_arg,
$a_very_long_argument_name,
$arg_with_default = 5,
$again = 'a default string', // This trailing comma was not permitted before 8.0.0.
)
{
// ...
}
?>
As of PHP 8.0.0, passing mandatory arguments after optional arguments
is deprecated. This can generally be resolved by dropping the default value.
One exception to this rule are arguments of the form
Type $param = null
, where the null
default makes the type implicitly
nullable. This usage remains allowed, though it is recommended to use an
explicit nullable type instead.
Beispiel #3 Passing optional arguments after mandatory arguments
<?php
function foo($a = [], $b) {} // Before
function foo($a, $b) {} // After
function bar(A $a = null, $b) {} // Still allowed
function bar(?A $a, $b) {} // Recommended
?>
Parameter als Verweise übergeben
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 #4 Ü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.'
?>
Vorgabewerte für Parameter
Eine Funktion kann C++-artige Vorgabewerte für skalare Parameter
wie folgt definieren:
Beispiel #5 Einsatz von Vorgabeparametern in Funktionen
<?php
function machkaffee($typ = "Cappuccino")
{
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 Cappuccino.
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 #6 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 #7 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 #8 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
unterstützt.
Variable Anzahl von Parametern
PHP unterstützt eine variable Anzahl an Parametern für benutzerdefinierte
Funktionen durch Verwendung des Token ...
.
Hinweis:
Es ist ebenfalls möglich eine variable Anzahl an Parametern durch Verwendung von
func_num_args(), func_get_arg(), und
func_get_args() zu realisieren.
Diese Technik wird nicht empfohlen, da sie vor der Einführung des ...
Tokens verwendet wurde.
Eine Liste von Parametern kann das Token ...
enthalten, um anzugeben, dass die Funktion eine variable Anzahl von
Parametern akzeptiert. Die zusätzlichen Werte werden als Array an die entsprechende Variable übergeben.
Zum Beispiel:
Beispiel #9 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:
Das Token ...
kann ebenfalls dazu verwendet werden, um
ein Array oder Traversable-Objekt als
Liste von Parametern zu übergeben:
Beispiel #10 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:
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
Typdeklaration voran zu
stellen. Ist dies der Fall, müssen alle Werte, die für ...
relevant sind, vom entsprechenden Typ sein.
Beispiel #11 Variable Parameter mit Typdeklaration
<?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.
Ältere Versionen von PHP
Eine spezielle Syntax ist zur Definition von variablen Parametern 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 alten PHP-Versionen so
umgesetzt werden können:
Beispiel #12 Zugriff auf variable Parameter in alten PHP-Versionen
<?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:
Named Arguments
PHP 8.0.0 introduced named arguments as an extension of the existing
positional parameters. Named arguments allow passing arguments to a
function based on the parameter name, rather than the parameter position.
This makes the meaning of the argument self-documenting, makes the
arguments order-independent and allows skipping default values arbitrarily.
Named arguments are passed by prefixing the value with the parameter name
followed by a colon. Using reserved keywords as parameter names is allowed.
The parameter name must be an identifier, specifying dynamically
is not allowed.
Beispiel #13 Named argument syntax
<?php
myFunction(paramName: $value);
array_foobar(array: $value);
// NOT supported.
function_name($variableStoringParamName: $value);
?>
Beispiel #14 Positional arguments versus named arguments
<?php
// Using positional arguments:
array_fill(0, 100, 50);
// Using named arguments:
array_fill(start_index: 0, num: 100, value: 50);
?>
The order in which the named arguments are passed does not matter.
Beispiel #15 Same example as above with a different order of parameters
<?php
array_fill(value: 50, num: 100, start_index: 0);
?>
Named arguments can be combined with positional arguments. In this case,
the named arguments must come after the positional arguments.
It is also possible to specify only some of the optional arguments of a
function, regardless of their order.
Beispiel #16 Combining named arguments with positional arguments
<?php
htmlspecialchars($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
?>
Passing the same parameter multiple times results in an Error exception.
Beispiel #17 Error exception when passing the same parameter multiple times
<?php
function foo($param) { ... }
foo(param: 1, param: 2);
// Error: Named parameter $param overwrites previous argument
foo(1, param: 2);
// Error: Named parameter $param overwrites previous argument
?>