PHP: Funktionsparameter

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, bevor die eigentliche Funktion aufgerufen wird, d. h. mit der sog. eager Evaluation (dt. eifrige Auswertung).

PHP unterstützt die Weitergabe von Parametern als Werte (das ist der Standard), als Verweise und als Vorgabewerte. Eine variable Anzahl von Parametern und benannte Parameter werden ebenfalls unterstützt.

Beispiel #1 Arrays an Funktionen übergeben

<?php
function nimm_array($eingabe)
{
    echo "$eingabe[0] + $eingabe[1] = ", $eingabe[0]+$eingabe[1];
}
?>

Seit PHP 8.0.0 kann die Liste der Funktionsparameter ein nachgestelltes Komma enthalten, das ignoriert wird. Das ist besonders nützlich in Fällen, in denen die Liste der Parameter lang ist oder lange Variablennamen enthält, sodass es praktisch ist, die Parameter vertikal aufzulisten.

Beispiel #2 Liste von Funktionsparametern mit nachgestelltem Komma

<?php
function takes_many_args(
    $first_arg,
    $second_arg,
    $a_very_long_argument_name,
    $arg_with_default = 5,
    $again = 'a default string', // Dieses nachgestellte Komma war vor 8.0.0
                                 // nicht erlaubt.
)
{
    // ...
}
?>

Parameter als Verweise übergeben

Normalerweise werden den Funktionen Werte als Parameter übermittelt. Wenn man also den Wert dieser Parameter innerhalb der Funktion ändert, bleiben sie 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 #3 Ü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.'
?>

Es ist ein Fehler, einen Wert als Parameter zu übergeben, der eigentlich als Referenz übergeben werden müsste.

Vorgabewerte für Parameter

Eine Funktion kann Standardwerte für Parameter definieren, indem sie eine ähnliche Syntax wie bei der Zuweisung von Variablen verwendet. Der Standardwert wird nur verwendet, wenn der Parameter nicht angegeben ist. Dabei ist insbesondere zu beachten, dass bei der Übergabe von null nicht der Standardwert zugewiesen wird.

Beispiel #4 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.

Die Standardwerte der Parameter können skalare Werte, Arrays, der spezielle Typ null und seit PHP 8.1.0 auch Objekte sein, die die new ClassName()-Syntax verwenden.

Beispiel #5 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"), "Teekanne");
?>

Beispiel #6 Verwendung von Objekten als Standardwerte (seit PHP 8.1.0)

<?php
class DefaultCoffeeMaker {
    public function brew() {
        return 'Koche Kaffee.';
    }
}
class FancyCoffeeMaker {
    public function brew() {
        return 'Bereite einen schönen Kaffee für Dich zu.';
    }
}
function makecoffee($coffeeMaker = new DefaultCoffeeMaker)
{
    return $coffeeMaker->brew();
}
echo makecoffee();
echo makecoffee(new FancyCoffeeMaker);
?>

Der Vorgabewert muss ein konstanter Ausdruck sein, darf also zum Beispiel keine Variable, keine Eigenschaft einer Klasse und kein Funktionsaufruf sein.

Es ist zu beachten, dass optionale Parameter nach den erforderlichen Parametern angegeben werden müssen, da sie sonst bei einem Aufruf nicht weggelassen werden können. Das nachfolgende Beispiel verdeutlicht dies:

Beispiel #7 Ungültige Verwendung von Vorgabewerten

<?php
function mach_joghurt($typ = "rechtsdrehendes", $geschmack)
{
    return "Mache einen Becher $typ $geschmack-Joghurt.\n";
}

echo mach_joghurt("Brombeer"); // "Brombeer" ist $typ, nicht $geschmack
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42

Zum Vergleich mit obigem Beispiel::

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"); // "Brombeer" ist $geschmack
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Mache einen Becher rechtsdrehendes Brombeer-Joghurt.

Seit PHP 8.0.0 können benannte Parameter verwendet werden, um mehrere optionale Parameter zu überspringen.

Beispiel #9 Korrekte Verwendung von Funktionsparametern mit Standardwerten

<?php
function makeyogurt($container = "bowl", $flavour = "raspberry", $style = "Greek")
{
    return "Making a $container of $flavour $style yogurt.\n";
}

echo makeyogurt(style: "natural");
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Making a bowl of raspberry natural yogurt.

Seit PHP 8.0.0 wird die Angabe von obligatorischen Parametern nach optionalen Parametern missbilligt. Dies kann im Allgemeinen durch das Weglassen des Standardwertes gelöst werden, da er nie verwendet wird. Eine Ausnahme von dieser Regel sind Parameter der Form Type $param = null, wobei der Standardwert null den Typ implizit nullbar macht. Diese Verwendung bleibt erlaubt, obwohl empfohlen wird, stattdessen einen explizit nullbaren Typ zu verwenden.

Beispiel #10 Angabe von optionalen Parametern nach obligatorischen Parametern

<?php
function foo($a = [], $b) {} // Seit PHP 8.0.0 veraltet; Standardwert wird nicht verwendet
function foo($a, $b) {}      // Funktionell identisch, aber ohne Veraltet-Hinweis

function bar(A $a = null, $b) {} // Noch erlaubt; $a wird benötigt, kann aber null sein
function bar(?A $a, $b) {}       // Empfohlen
?>

Hinweis: Seit PHP 7.1.0 wird ein ArgumentCountError ausgelöst, wenn ein Parameter weggelassen wird, für den kein Standardwert angegeben ist; in früheren Versionen löste es eine Warnung aus.

Hinweis: Parameter, die per Verweis übergeben werden, dürfen einen Standardwert haben.

Variable Anzahl von Parametern

PHP unterstützt eine variable Anzahl an Parametern in benutzerdefinierten Funktionen durch Verwendung des ...-Tokens.

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:

Beispiel #11 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 auch dazu verwendet werden, um ein Array oder ein Traversable-Objekt als Liste von Parametern zu übergeben:

Beispiel #12 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 auch möglich, dem ...-Token eine Typdeklaration voranzustellen. Ist dies der Fall, dann müssen alle Parameter, die von ... erfasst werden, vom entsprechenden Typ sein.

Beispiel #13 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.

Benannte Parameter

PHP 8.0.0 führt benannte Parameter als eine Erweiterung der bestehenden Positionsparameter ein. Benannte Parameter ermöglichen die Übergabe von Parametern an eine Funktion basierend auf dem Parameternamen und nicht auf der Position des Parameters. Das macht die Bedeutung von Parametern selbsterklärend, macht die Parameter unabhängig von der Reihenfolge und ermöglicht das willkürliche Überspringen von Standardwerten.

Benannte Parameter werden übergeben, indem dem Wert der Parametername gefolgt von einem Doppelpunkt vorangestellt wird. Reservierte Schlüsselwörter dürfen als Parameternamen verwendet werden. Der Parametername muss ein Bezeichner sein; eine dynamische Angabe ist nicht erlaubt.

Beispiel #14 Syntax benannter Parameter

<?php
myFunction(paramName: $value);
array_foobar(array: $value);

// Wird NICHT unterstützt
function_name($variableStoringParamName: $value);
?>

Beispiel #15 Positionsparameter im Vergleich zu benannten Parametern

<?php
// Verwendung von Positionsparametern:
array_fill(0, 100, 50);

// Verwendung von benannten Parametern:
array_fill(start_index: 0, count: 100, value: 50);
?>

Die Reihenfolge, in der die benannten Parameter übergeben werden, spielt keine Rolle.

Beispiel #16 Das gleiche Beispiel wie oben mit einer anderen Reihenfolge der Parameter

<?php
array_fill(value: 50, count: 100, start_index: 0);
?>

Benannte Parameter können mit Positionsparametern kombiniert werden. In diesem Fall müssen die benannten Parameter nach den Positionsparametern kommen. Es ist auch möglich, nur einige der optionalen Parameter einer Funktion anzugeben, unabhängig von ihrer Reihenfolge.

Beispiel #17 Kombinieren von benannten Parametern mit Positionsparametern

<?php
htmlspecialchars($string, double_encode: false);
// Ist das Gleiche wie
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>

Die mehrfache Übergabe desselben Parameters führt zu einer Error-Exception.

Beispiel #18 Die mehrfache Übergabe desselben Parameters erzeugt einen Fehler

<?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
?>

Seit PHP 8.1.0 ist es möglich, benannte Parameter nach dem Entpacken von Parametern zu verwenden. Ein bereits entpackter Parameter darf nicht durch einen benannten Parameter überschrieben werden.

Beispiel #19 Verwendung benannter Parameter nach dem Entpacken

<?php
function foo($a, $b, $c = 3, $d = 4) {
  return $a + $b + $c + $d;
}

var_dump(foo(...[1, 2], d: 40)); // 46
var_dump(foo(...['b' => 2, 'a' => 1], d: 40)); // 46

var_dump(foo(...[1, 2], b: 20)); // Fataler Fehler. Der benannte Parameter $b überschreibt den vorherige Parameter
?>

add a note

User Contributed Notes 14 notes

down

121

php at richardneill dot org ¶

9 years ago


To experiment on performance of pass-by-reference and pass-by-value, I used this  script. Conclusions are below. 

#!/usr/bin/php
<?php
function sum($array,$max){   //For Reference, use:  "&$array"
    $sum=0;
    for ($i=0; $i<2; $i++){
        #$array[$i]++;        //Uncomment this line to modify the array within the function.
        $sum += $array[$i];  
    }
    return ($sum);
}

$max = 1E7                  //10 M data points.
$data = range(0,$max,1);

$start = microtime(true);
for ($x = 0 ; $x < 100; $x++){
    $sum = sum($data, $max);
}
$end =  microtime(true);
echo "Time: ".($end - $start)." s\n";

/* Run times:
#    PASS BY    MODIFIED?   Time
-    -------    ---------   ----
1    value      no          56 us
2    reference  no          58 us

3    valuue     yes         129 s
4    reference  yes         66 us

Conclusions:

1. PHP is already smart about zero-copy / copy-on-write. A function call does NOT copy the data unless it needs to; the data is
   only copied on write. That's why  #1 and #2 take similar times, whereas #3 takes 2 million times longer than #4.
   [You never need to use &$array to ask the compiler to do a zero-copy optimisation; it can work that out for itself.]

2. You do use &$array  to tell the compiler "it is OK for the function to over-write my argument in place, I don't need the original
   any more." This can make a huge difference to performance when we have large amounts of memory to copy.
   (This is the only way it is done in C, arrays are always passed as pointers)

3. The other use of & is as a way to specify where data should be *returned*. (e.g. as used by exec() ).
   (This is a C-like way of passing pointers for outputs, whereas PHP functions normally return complex types, or multiple answers
   in an array)

4. It's  unhelpful that only the function definition has &. The caller should have it, at least as syntactic sugar. Otherwise
   it leads to unreadable code: because the person reading the function call doesn't expect it to pass by reference. At the moment,
   it's necessary to write a by-reference function call with a comment, thus:
    $sum = sum($data,$max);  //warning, $data passed by reference, and may be modified.

5. Sometimes, pass by reference could be at the choice of the caller, NOT the function definitition. PHP doesn't allow it, but it
   would be meaningful for the caller to decide to pass data in as a reference. i.e. "I'm done with the variable, it's OK to stomp
   on it in memory".
*/
?>

down

Simmo at 9000 dot 000 ¶

2 years ago


For anyone just getting started with php or searching, for an understanding, on what this page describes as a "... token" in Variable-length arguments:
https://www.php.net/manual/en/functions.arguments.php#functions.variable-arg-list
<?php

  func($a, ...$b) 

?>
The 3 dots, or elipsis, or "...", or dot dot dot is sometimes called the "spread operator" in other languages.

As this is only used in function arguments, it is probably not technically an true operator in PHP.  (As of 8.1 at least?).

(With having an difficult to search for name like "... token", I hope this note helps someone).

down

LilyWhite ¶

3 years ago


It is worth noting that you can use functions as function arguments

<?php
function run($op, $a, $b) {
  return $op($a, $b);
}

$add = function($a, $b) {
  return $a + $b;
};

$mul = function($a, $b) {
  return $a * $b;
};

echo run($add, 1, 2), "\n";
echo run($mul, 1, 2);
?>

Output:
3
2

down

tianyiw at vip dot qq dot com ¶

2 years ago


<?php
/**
 * Create an array using Named Parameters.
 *
 * @param mixed ...$values
 * @return array
 */
function arr(mixed ...$values): array
{
    return $values;
}

$arr = arr(
    name: 'php',
    mobile: 123456,
);

var_dump($arr);
// array(2) {
//   ["name"]=>
//   string(3) "php"
//   ["mobile"]=>
//   int(123456)
// }

down

gabriel at figdice dot org ¶

8 years ago


A function's argument that is an object, will have its properties modified by the function although you don't need to pass it by reference.

<?php
$x = new stdClass();
$x->prop = 1;

function f ( $o ) // Notice the absence of &
{
  $o->prop ++;
}

f($x);

echo $x->prop; // shows: 2
?>

This is different for arrays:

<?php
$y = [ 'prop' => 1 ];

function g( $a )
{
  $a['prop'] ++;
  echo $a['prop'];  // shows: 2
}

g($y);

echo $y['prop'];  // shows: 1
?>

down

Hayley Watson ¶

7 years ago


There are fewer restrictions on using ... to supply multiple arguments to a function call than there are on using it to declare a variadic parameter in the function declaration. In particular, it can be used more than once to unpack arguments, provided that all such uses come after any positional arguments.

<?php

$array1 = [[1],[2],[3]];
$array2 = [4];
$array3 = [[5],[6],[7]];

$result = array_merge(...$array1); // Legal, of course: $result == [1,2,3];
$result = array_merge($array2, ...$array1); // $result == [4,1,2,3]
$result = array_merge(...$array1, $array2); // Fatal error: Cannot use positional argument after argument unpacking.
$result = array_merge(...$array1, ...$array3); // Legal! $result == [1,2,3,5,6,7]
?>

The Right Thing for the error case above would be for $result==[1,2,3,4], but this isn't yet (v7.1.8) supported.

down

boan dot web at outlook dot com ¶

6 years ago


Quote:

"The declaration can be made to accept NULL values if the default value of the parameter is set to NULL."

But you can do this (PHP 7.1+):

<?php
function foo(?string $bar) {
    //...
}

foo(); // Fatal error
foo(null); // Okay
foo('Hello world'); // Okay
?>

down

Luna ¶

1 year ago


When using named arguments and adding default values only to some of the arguments, the arguments with default values must be specified at the end or otherwise PHP throws an error:

<?php

function test1($a, $c, $b = 2)
{
    return $a + $b + $c;
}

function test2($a, $b = 2, $c)
{
    return $a + $b + $c;
}

echo test1(a: 1, c: 3)."\n"; // Works
echo test2(a: 1, c: 3)."\n"; // ArgumentCountError: Argument #2 ($b) not passed

?>

I assume that this happens because internally PHP rewrites the calls to something like test1(1, 3) and test2(1, , 3). The first call is valid, but the second obviously isn't.

down

Sergio Santana: ssantana at tlaloc dot imta dot mx ¶

19 years ago


PASSING A "VARIABLE-LENGTH ARGUMENT LIST OF REFERENCES" TO A FUNCTION
As of PHP 5, Call-time pass-by-reference has been deprecated, this represents no problem in most cases, since instead of calling a function like this:
   myfunction($arg1, &$arg2, &$arg3);

you can call it
   myfunction($arg1, $arg2, $arg3);

provided you have defined your function as 
   function myfuncion($a1, &$a2, &$a3) { // so &$a2 and &$a3 are 
                                                             // declared to be refs.
    ... <function-code>
   }

However, what happens if you wanted to pass an undefined number of references, i.e., something like:
   myfunction(&$arg1, &$arg2, ..., &$arg-n);?
This doesn't work in PHP 5 anymore.

In the following code I tried to amend this by using the 
array() language-construct as the actual argument in the 
call to the function.

<?php

  function aa ($A) {
    // This function increments each 
    // "pseudo-argument" by 2s
    foreach ($A as &$x) { 
      $x += 2;
    }
  }
 
  $x = 1; $y = 2; $z = 3;
  
  aa(array(&$x, &$y, &$z));
  echo "--$x--$y--$z--\n";
  // This will output:
  // --3--4--5--
?>

I hope this is useful.

Sergio.

down

jcaplan at bogus dot amazon dot com ¶

18 years ago


In function calls, PHP clearly distinguishes between missing arguments and present but empty arguments.  Thus:

<?php
function f( $x = 4 ) { echo $x . "\\n"; }
f(); // prints 4
f( null ); // prints blank line
f( $y ); // $y undefined, prints blank line
?>

The utility of the optional argument feature is thus somewhat diminished.  Suppose you want to call the function f many times from function g, allowing the caller of g to specify if f should be called with a specific value or with its default value:

<?php
function f( $x = 4 ) {echo $x . "\\n"; }

// option 1: cut and paste the default value from f's interface into g's
function g( $x = 4 ) { f( $x ); f( $x ); }

// option 2: branch based on input to g
function g( $x = null ) { if ( !isset( $x ) ) { f(); f() } else { f( $x ); f( $x ); } }
?>

Both options suck.

The best approach, it seems to me, is to always use a sentinel like null as the default value of an optional argument.  This way, callers like g and g's clients have many options, and furthermore, callers always know how to omit arguments so they can omit one in the middle of the parameter list.

<?php
function f( $x = null ) { if ( !isset( $x ) ) $x = 4; echo $x . "\\n"; }

function g( $x = null ) { f( $x ); f( $x ); }

f(); // prints 4
f( null ); // prints 4
f( $y ); // $y undefined, prints 4
g(); // prints 4 twice
g( null ); // prints 4 twice
g( 5 ); // prints 5 twice

?>

down

catman at esteticas dot se ¶

8 years ago


I wondered if variable length argument lists and references works together, and what the syntax might be. It is not mentioned explicitly yet in the php manual as far as I can find. But other sources mention the following syntax "&...$variable" that works in php  5.6.16. 

<?php
function foo(&...$args)
{
    $i = 0;
    foreach ($args as &$arg) {
        $arg = ++$i;
    }
}
foo($a, $b, $c);
echo 'a = ', $a, ', b = ', $b, ', c = ', $c;
?>
Gives
a = 1, b = 2, c = 3

down

Hayley Watson ¶

7 years ago


If you use ... in a function's parameter list, you can use it only once for obvious reasons. Less obvious is that it has to be on the LAST parameter; as the manual puts it: "You may specify normal positional arguments BEFORE the ... token. (emphasis mine).

<?php
function variadic($first, ...$most, $last)
{/*etc.*/}

variadic(1, 2, 3, 4, 5);
?>
results in a fatal error, even though it looks like the Thing To Do™ would be to set $first to 1, $most to [2, 3, 4], and $last to 5.

down

info at keraweb dot nl ¶

7 years ago


You can use a class constant as a default parameter.

<?php

class A {
    const FOO = 'default';
    function bar( $val = self::FOO ) {
        echo $val;
    }
}

$a = new A();
$a->bar(); // Will echo "default"

down

John ¶

17 years ago


This might be documented somewhere OR obvious to most, but when passing an argument by reference (as of PHP 5.04) you can assign a value to an argument variable in the function call. For example:

function my_function($arg1, &$arg2) {
  if ($arg1 == true) {
    $arg2 = true;
  }
}
my_function(true, $arg2 = false);
echo $arg2;

outputs 1 (true)

my_function(false, $arg2 = false);
echo $arg2;

outputs 0 (false)

add a note