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:

10

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 add a note

User Contributed Notes 15 notes

up
96
php at richardneill dot org
8 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".
*/
?>
up
33
gabriel at figdice dot org
7 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
?>
up
12
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

?>
up
14
Sergio Santana: ssantana at tlaloc dot imta dot mx
18 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.
up
6
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
?>
up
5
info at keraweb dot nl
6 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"
up
4
Hayley Watson
6 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.
up
3
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
up
5
Horst Schirmeier
10 years ago
Editor's note: what is expected here by the parser is a non-evaluated expression. An operand and two constants requires evaluation, which is not done by the parser. However, this feature is included as of PHP 5.6.0. See this page for more information: http://php.net/migration56.new-features#migration56.new-features.const-scalar-exprs
--------

"The default value must be a constant expression" is misleading (or even wrong).  PHP 5.4.4 fails to parse this function definition:

function htmlspecialchars_latin1($s, $flags = ENT_COMPAT | ENT_HTML401) {}

This yields a " PHP Parse error:  syntax error, unexpected '|', expecting ')' " although ENT_COMPAT|ENT_HTML401 is certainly what a compiler-affine person would call a "constant expression".

The obvious workaround is to use a single special value ($flags = NULL) as the default, and to set it to the desired value in the function's body (if ($flags === NULL) { $flags = ENT_COMPAT | ENT_HTML401; }).
up
2
Hayley Watson
6 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.
up
0
rsperduta at gmail dot com
3 years ago
About example #2: That little comma down at the end and often obscured by a line comment is easily over looked. I think it's worth considering putting it at the head of the next line to make clear what it's relationship is to the surrounding lines. Consider how much clearer it's continuation as a list of parameters:

<?php
function takes_many_args(
   
$first_arg // some description
   
, $second_arg // another comment
   
, $a_very_long_argument_name = something($complicated) // IDK
   
, $arg_with_default = 5
   
, $again = 'a default string', // IMHO this trailing comma encourages illegible code and not being permitted seemed  a good idea lost with 8.0.0.
) {
   
// ...
}
?>

This principle can be applied equally to complicated boolean expressions of an "if" statement (or the parts of a for statement).
up
0
shaman_master at list dot ru
4 years ago
You can use the class/interface as a type even if the class/interface is not  defined yet or the class/interface implements current class/interface.
<?php
interface RouteInterface
{
    public function
getGroup(): ?RouteGroupInterface;
}
interface
RouteGroupInterface extends RouteInterface
{
    public function
set(RouteInterface $item);
}
?>
'self' type - alias to current class/interface, it's not changed in implementations. This code looks right but throw error:
<?php
class Route
{
    protected
$name;
    
// method must return Route object
   
public function setName(string $name): self
   
{
        
$this->name = $name;
         return
$this;
    }
}
class
RouteGroup extends Route
{
   
// method STILL must return only Route object
   
public function setName(string $name): self
   
{
        
$name .= ' group';
         return
parent::setName($name);
    }
}
?>
up
0
dmitry dot balabka at gmail dot com
5 years ago
There is a possibility to use parent keyword as type hint which is not mentioned in the documentation.

Following code snippet will be executed w/o errors on PHP version 7. In this example, parent keyword is referencing on ParentClass instead of ClassTrait.
<?php
namespace TestTypeHints;

class
ParentClass
{
    public function
someMethod()
    {
        echo
'Some method called' . \PHP_EOL;
    }
}

trait
ClassTrait
{
    private
$original;

    public function
__construct(parent $original)
    {
       
$this->original = $original;
    }

    protected function
getOriginal(): parent
   
{
        return
$this->original;
    }
}

class
Implementation extends ParentClass
{
    use
ClassTrait;

    public function
callSomeMethod()
    {
       
$this->getOriginal()->someMethod();
    }
}

$obj = new Implementation(new ParentClass());
$obj->callSomeMethod();
?>

Outputs:
Some method called
up
2
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)
up
-2
igorsantos07 at gmail dot com
6 years ago
PHP 7+ does type coercion if strict typing is not enabled, but there's a small gotcha: it won't convert null values into anything.

You must explicitly set your default argument value to be null (as explained in this page) so your function can also receive nulls.

For instance, if you type an argument as "string", but pass a null variable into it, you might expect to receive an empty string, but actually, PHP will yell at you a TypeError.

<?php
function null_string_wrong(string $str) {
 
var_dump($str);
}
function
null_string_correct(string $str = null) {
 
var_dump($str);
}
$null = null;
null_string_wrong('a');     //string(1) "a"
null_string_correct('a');   //string(1) "a"
null_string_correct();      //NULL
null_string_correct($null); //NULL
null_string_wrong($null);   //TypeError thrown
?>
To Top