Mit einer Parameterliste kann man Informationen an eine Funktion übergeben. Die Parameterliste ist eine durch Kommas getrennte Liste von Ausdrücken.
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 rechne_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_anderes_an(&$string)
{
$string .= 'und nun zu etwas anderem.';
}
$str = 'Dies ist ein String, ';
fuege_etwas_anderes_an($str);
echo $str; // Ausgabe: 'Dies ist ein String, und nun zu etwas anderem.'
?>
Eine Funktion kann C++-artige Vorgabewerte für skalare Parameter wie folgt definieren:
Beispiel #3 Einsatz von Vorgabeparametern
<?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 oberes 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:
Type declarations were also known as type hints in PHP 5.
Type declarations allow functions to require that parameters are of a certain type at call time. If the given value is of the incorrect type, then an error is generated: in PHP 5, this will be a recoverable fatal error, while PHP 7 will throw a TypeError exception.
To specify a type declaration, the type name should be added before the
parameter name. The declaration can be made to accept NULL values if
the default value of the parameter is set to NULL.
| Type | Description | Minimum PHP version |
|---|---|---|
| Class/interface name | The parameter must be an instanceof the given class or interface name. | PHP 5.0.0 |
| array | The parameter must be an array. | PHP 5.1.0 |
| callable | The parameter must be a valid callable. | PHP 5.4.0 |
| bool | The parameter must be a boolean value. | PHP 7.0.0 |
| float | The parameter must be a floating point number. | PHP 7.0.0 |
| int | The parameter must be an integer. | PHP 7.0.0 |
| string | The parameter must be a string. | PHP 7.0.0 |
Beispiel #7 Basic class type declaration
<?php
class C {}
class D extends C {}
// This doesn't extend C.
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 Basic interface type declaration
<?php
interface I { public function f(); }
class C implements I { public function f() {} }
// This doesn't implement I.
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 type declaration
<?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
By default, PHP will coerce values of the wrong type into the expected scalar type if possible. For example, a function that is given an integer for a parameter that expects a string will get a variable of type string.
It is possible to enable strict mode on a per-file basis. In strict mode, only a variable of exact type of the type declaration will be accepted, or a TypeError will be thrown. The only exception to this rule is that an integer may be given to a function expecting a float.
To enable strict mode, the declare statement is used with the strict_types declaration:
Enabling strict mode will also affect return type declarations.
Hinweis:
Strict typing applies to function calls made from within the file with strict typing enabled, not to the functions declared within that file. If a file without strict typing enabled makes a call to a function that was defined in a file with strict typing, the caller's preference (weak typing) will be respected, and the value will be coerced.
Hinweis:
Strict typing is only defined for scalar type declarations, and as such, requires PHP 7.0.0 or later, as scalar type declarations were added in that version.
Beispiel #10 Strict typing
<?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 Weak typing
<?php
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
// These will be coerced to integers: note the output below!
var_dump(sum(1.5, 2.5));
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
int(3) int(3)
Beispiel #12 Catching 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 'Error: '.$e->getMessage();
}
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
int(3) Error: 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 ü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 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 früher so umgesetzt werden können:
Beispiel #16 Zugriff auf variable Parameter in PHP 5.5 und früher
<?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