MENU
Edit
In Place Editing Advanced Editing

Function arguments

Examples:
Passing arrays to functions

Information may be passed to functions via the argument list, which is a comma-delimited list of expressions. The arguments are evaluated from left to right.

PHP supports passing arguments by value (the default), passing by reference, and default argument values. Variable-length argument lists are also supported.

1
2
3
4
5
6
<?php
function takes_array($input)
{
    echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>
Passing function parameters by reference

By default, function arguments are passed by value (so that if the value of the argument within the function is changed, it does not get changed outside of the function). To allow a function to modify its arguments, they must be passed by reference.

To have an argument to a function always passed by reference, prepend an ampersand (&) to the argument name in the function definition:

1
2
3
4
5
6
7
8
9
<?php
function add_some_extra(&$string)
{
    $string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str;    // outputs 'This is a string, and something extra.'
?>
Use of default parameters in functions

A function may define C++-style default values for scalar arguments as follows:

1
2
3
4
5
6
7
8
9
<?php
function makecoffee($type = "cappuccino")
{
    return "Making a cup of $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>

The above example will output:

Making a cup of cappuccino.
Making a cup of .
Making a cup of espresso.
Using non-scalar types as default values

PHP also allows the use of arrays and the special type NULL as default values, for example:

1
2
3
4
5
6
7
8
9
<?php
function makecoffee($types = array("cappuccino"), $coffeeMaker = NULL)
{
    $device = is_null($coffeeMaker) ? "hands" : $coffeeMaker;
    return "Making a cup of ".join(", ", $types)." with $device.\n";
}
echo makecoffee();
echo makecoffee(array("cappuccino", "lavazza"), "teapot");
?>
Incorrect usage of default function arguments

The default value must be a constant expression, not (for example) a variable, a class member or a function call.

Note that when using default arguments, any defaults should be on the right side of any non-default arguments; otherwise, things will not work as expected. Consider the following code snippet:

1
2
3
4
5
6
7
8
<?php
function makeyogurt($type = "acidophilus", $flavour)
{
    return "Making a bowl of $type $flavour.\n";
}
  
echo makeyogurt("raspberry");   // won't work as expected
?>

The above example will output:

Warning: Missing argument 2 in call to makeyogurt() in 
/usr/local/etc/httpd/htdocs/phptest/functest.html on line 41
Making a bowl of raspberry .
Correct usage of default function arguments

Now, compare the above with this:

1
2
3
4
5
6
7
8
<?php
function makeyogurt($flavour, $type = "acidophilus")
{
    return "Making a bowl of $type $flavour.\n";
}
  
echo makeyogurt("raspberry");   // works as expected
?>

The above example will output:

Making a bowl of acidophilus raspberry.
The above example will output:

Aliases for the above scalar types are not supported. Instead, they are treated as class or interface names. For example, using boolean as a parameter or return type will require an argument or return value that is an instanceof the class or interface boolean, rather than of type bool:

1
2
3
4
<?php
 function test(boolean $param) {}
 test(true);
 ?>
 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
Basic class type declaration
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?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);
?>

The above example will output:

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
Basic interface type declaration
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?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);
?>

The above example will output:

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
Nullable type declaration
1
2
3
4
5
6
7
8
9
10
<?php
class C {}
 
function f(C $c = null) {
    var_dump($c);
}
 
f(new C);
f(null);
?>

The above example will output:

object(C)#1 (0) {
}
NULL
Strict typing

Note:

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.

Note:

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.

1
2
3
4
5
6
7
8
9
10
<?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));
?>

The above example will output:

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
Weak typing
1
2
3
4
5
6
7
8
9
10
<?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));
?>

The above example will output:

int(3)
int(3)
Catching TypeError
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?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();
}
?>

The above example will output:

int(3)
Error: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 10
Using ... to access variable arguments

In PHP 5.6 and later, argument lists may include the ... token to denote that the function accepts a variable number of arguments. The arguments will be passed into the given variable as an array; for example:

1
2
3
4
5
6
7
8
9
10
11
<?php
function sum(...$numbers) {
    $acc = 0;
    foreach ($numbers as $n) {
        $acc += $n;
    }
    return $acc;
}
 
echo sum(1, 2, 3, 4);
?>

The above example will output:

10
Using ... to provide arguments

You can also use ... when calling functions to unpack an array or Traversable variable or literal into the argument list:

1
2
3
4
5
6
7
8
9
10
<?php
function add($a, $b) {
    return $a + $b;
}
 
echo add(...[1, 2])."\n";
 
$a = [1, 2];
echo add(...$a);
?>

The above example will output:

3
3
Type hinted variable arguments

You may specify normal positional arguments before the ... token. In this case, only the trailing arguments that don't match a positional argument will be added to the array generated by ....

It is also possible to add a type hint before the ... token. If this is present, then all arguments captured by ... must be objects of the hinted class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?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';
 
// This will fail, since null isn't a DateInterval object.
echo total_intervals('d', null);
?>

The above example will output:

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
Accessing variable arguments in PHP 5.5 and earlier

No special syntax is required to note that a function is variadic; however access to the function's arguments must use func_num_args(), func_get_arg() and func_get_args().

The first example above would be implemented as follows in PHP 5.5 and earlier:

1
2
3
4
5
6
7
8
9
10
11
<?php
function sum() {
    $acc = 0;
    foreach (func_get_args() as $n) {
        $acc += $n;
    }
    return $acc;
}
 
echo sum(1, 2, 3, 4);
?>

The above example will output:

10
doc_php
doc_php
2025-01-10 15:47:30
Comments
Leave a Comment

Please login to continue.