Les arguments de fonction

Des informations peuvent être passées à une fonction en utilisant une liste d'arguments, dont chaque expression est séparée par une virgule. Les arguments seront évalués depuis la gauche vers la droite, avant que la fonction soit actuellement appelée (évaluation immédiate).

PHP supporte le passage d'arguments par valeur (comportement par défaut), le passage par référence, et des valeurs d'arguments par défaut. Une liste variable d'arguments, ainsi que les Arguments Nommés sont également supportés.

Exemple #1 Nombre variable d'arguments sous forme de tableau

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

À partir de PHP 8.0.0, la liste des arguments de fonction peut inclure une virgule trainante, qui sera ignoré. Ceci est particulièrement pratique dans les cas où la liste d'arguments est longue ou contient des noms de variables longs, le rendant pratique pour lister les arguments verticalement.

Exemple #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', // Cette virgule trainant n'était pas permit avant 8.0.0.
)
{
// ...
}
?>

Passage d'arguments par référence

Par défaut, les arguments sont passés à la fonction par valeur (aussi, changer la valeur d'un argument dans la fonction ne change pas sa valeur à l'extérieur de la fonction). Si vous voulez que vos fonctions puissent changer la valeur des arguments, vous devez passer ces arguments par référence.

Si vous voulez qu'un argument soit toujours passé par référence, vous pouvez ajouter un '&' devant l'argument dans la déclaration de la fonction :

Exemple #3 Passage d'arguments par référence

<?php
function add_some_extra(&$string)
{
$string .= ', et un peu plus.';
}
$str = 'Ceci est une chaîne';
add_some_extra($str);
echo
$str; // Affiche : 'Ceci est une chaîne, et un peu plus.'
?>

C'est une erreur de passer une valeur en tant qu'argument qui est supposé d'être passé par référence.

Valeur par défaut des arguments

Une fonction peut définir des valeurs par défaut pour les arguments en utilisant une syntaxe similaire à l'affectation d'une variable. La valeur par défaut n'est utilisée que lorsque le paramètre n'est pas spécifié ; en particulier, notez que le passage de null n'assigne pas la valeur par défaut.

Exemple #4 Valeur par défaut des arguments de fonctions

<?php
function servir_cafe ($type = "cappuccino")
{
return
"Servir un $type.\n";
}
echo
servir_cafe();
echo
servir_cafe(null);
echo
servir_cafe("espresso");
?>

L'exemple ci-dessus va afficher :

Servir un cappuccino.
Servir un .
Servir un espresso.

Les valeurs par défaut des paramètres peuvent être des valeurs scalaires, des tableaus, le type spécial null, et à partir de PHP 8.1.0, des objets utilisant la syntaxe new ClassName().

Exemple #5 Utilisation de type non-scalaire comme valeur par défaut

<?php
function servir_cafe($types = array("cappuccino"), $coffeeMaker = NULL)
{
$device = is_null($coffeeMaker) ? "les mains" : $coffeeMaker;
return
"Préparation d'une tasse de ".join(", ", $types)." avec $device.\n";
}
echo
servir_cafe();
echo
servir_cafe(array("cappuccino", "lavazza"), "une cafetière");
?>

L'exemple ci-dessus va afficher :

Préparation d'une tasse de cappuccino avec les mains.
Préparation d'une tasse de cappuccino, lavazza avec une cafetière.

Exemple #6 Utilisation d'objets comme valeurs par défaut (à partir de PHP 8.1.0)

<?php
class DefaultCoffeeMaker {
public function
brew() {
return
'Faire du café.\n';
}
}
class
FancyCoffeeMaker {
public function
brew() {
return
'Créer un beau café rien que pour vous.\n';
}
}
function
makecoffee($coffeeMaker = new DefaultCoffeeMaker)
{
return
$coffeeMaker->brew();
}
echo
makecoffee();
echo
makecoffee(new FancyCoffeeMaker);
?>

L'exemple ci-dessus va afficher :

Faire du café.
Créer un beau café rien que pour vous.

La valeur par défaut d'un argument doit obligatoirement être une constante, et ne peut être ni une variable, ni un membre de classe, ni un appel de fonction.

Il est à noter que tous les arguments facultatifs doivent être spécifiés après les arguments obligatoires, sinon ils ne peuvent pas être omis dans les appels. Considérons le code suivant :

Exemple #7 Les arguments sans valeur par défaut doivent être en premiers : erreur

<?php
function faireunyaourt ($container = "bol", $flavour)
{
return
"Préparer un $container de yaourt à la $flavour.\n";
}

echo
faireunyaourt("framboise"); // "framboise" est $container, pas $flavour
?>

L'exemple ci-dessus va afficher :

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

Maintenant comparons l'exemple précédent avec l'exemple suivant :

Exemple #8 Les arguments sans valeur par défaut doivent être en premiers : valide

<?php
function faireunyaourt ($flavour, $container = "bol")
{
return
"Préparer un $container de yaourt à la $flavour.\n";
}

echo
faireunyaourt ("framboise"); // "framboise" est $flavour
?>

L'exemple ci-dessus va afficher :

Préparer un bol de yaourt à la framboise.

À partir de PHP 8.0.0, les arguments nommés peuvent être utilisées pour passer outre plusieurs paramètres optionnels.

Exemple #9 Utilisation correcte des arguments de fonction par défaut

<?php
function faireunyaourt($container = "bol", $flavour = "framboise", $style = "Grec")
{
return
"Préparer un $container de yaourt $style à la $flavour.\n";
}
echo
faireunyaourt(style: "naturel");
?>

L'exemple ci-dessus va afficher :

Préparer un bol de yaourt naturel à la framboise.

À partir de PHP 8.0.0, déclarer des arguments obligatoires après des arguments optionnels est obsolète. Ce problème peut généralement être résolu en abandonnant la valeur par défaut, puisqu'elle ne sera jamais utilisée. Une exception à cette règle concerne les arguments de la forme Type $param = null, où le null par défaut rend le type implicitement nullable. Cet usage reste autorisé, bien qu'il soit recommandé d'utiliser un type nullable explicite à la place.

Exemple #10 Déclarer des arguments facultatifs après les arguments obligatoires

<?php
function foo($a = [], $b) {} // Par défaut, non utilisé ; obsolète à partir de PHP 8.0.0.
function foo($a, $b) {} // Fonctionnement équivalent, pas de notice d’obsolescence
function bar(A $a = null, $b) {} // Toujours autorisé ; $a est obligatoire mais nullable.
function bar(?A $a, $b) {} // Recommandé
?>

Note: À partir de PHP 7.1.0, l'omission d'un paramètre qui ne spécifie pas une valeur par défaut lance un ArgumentCountError ; dans les versions précédentes, cela levait un avertissement.

Note: Les arguments passés par référence peuvent avoir une valeur par défaut.

Liste d'argument à nombre variable

PHP supporte les arguments à nombre variable dans les fonctions défini par l'utilisateur en utilisant le token ....

La liste des arguments peut inclure le token ... pour indiquer que cette fonction accepte un nombre variable d'arguments. Les arguments seront passés dans la variable fournie sous forme d'un tableau:

Exemple #11 Utilisation de ... pour accéder aux arguments variables

<?php
function sum(...$numbers) {
$acc = 0;
foreach (
$numbers as $n) {
$acc += $n;
}
return
$acc;
}

echo
sum(1, 2, 3, 4);
?>

L'exemple ci-dessus va afficher :

10

... peut aussi être utilisé lors des appels de fonctions pour extraire le tableau ou la variable Traversable ou le littéral dans la liste d'arguments :

Exemple #12 Utilisation de ... pour fournir des arguments

<?php
function add($a, $b) {
return
$a + $b;
}

echo
add(...[1, 2])."\n";

$a = [1, 2];
echo
add(...$a);
?>

L'exemple ci-dessus va afficher :

3
3

Vous pouvez spécifier des arguments classiques avant le mot clé .... Dans ce cas, seuls les arguments finaux qui ne correspondent pas à un argument classique seront ajoutés au tableau généré par ....

Il est également possible d'ajouter une déclaration de type avant le jeton .... Si ceci est présent, alors tous les arguments capturés par ... doivent correspondre au type de paramètre.

Exemple #13 Transtypage d'arguments variables

<?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).' jours';

// Ceci échouera, car null n'est pas un objet DateInterval.
echo total_intervals('d', null);
?>

L'exemple ci-dessus va afficher :

3 jours
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

Pour finir, vous pouvez passer des arguments variables par référence en préfixant le mot clé ... d'un ET commercial (&).

Arguments Nommés

PHP 8.0.0 introduit les arguments nommés comme extension aux paramètres positionnels existant. Les arguments nommés permettent de passer les arguments à une fonction en s'appuyant sur le nom du paramètre, au lieu de la position du paramètre. Ceci documente automatiquement la signification de l'argument, rend l'ordre des arguments indépendant et permet d'ignorer les valeurs par défaut arbitrairement.

Les arguments nommés sont passés en préfixant la valeur avec le nom du paramètre suivit d'un deux-points. Utiliser des mots-clés réservés comme nom de paramètre est autorisé. Le nom du paramètre doit être un identifiant, le spécifiant de façon dynamique n'est pas permis.

Exemple #14 Syntaxe des arguments nommés

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

// NON supporté.
function_name($variableStoringParamName: $value);
?>

Exemple #15 Arguments positionnels comparés aux arguments nommés

<?php
// Utilisant les arguments positionnels :
array_fill(0, 100, 50);

// Utilisant les arguments nommés :
array_fill(start_index: 0, count: 100, value: 50);
?>

L'ordre dans lequel les arguments nommés sont passés n'importe pas.

Exemple #16 Même exemple que ci-dessus, mais avec un ordre de paramètre différent

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

Les arguments nommés peuvent être combinés avec les arguments positionnels. Auquel cas, les arguments nommés doivent venir après les arguments positionnels. Il est aussi possible de spécifier seulement certains des arguments optionnels d'une fonction, peu importe leur ordre.

Exemple #17 Combiner les arguments nommés avec les arguments positionnels

<?php
htmlspecialchars
($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>

Passer le même paramètre plusieurs fois résulte en une Error exception.

Exemple #18 Error émise quand un même paramètre est passé plusieurs fois

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

À partir de PHP 8.1.0, il est possible d'utiliser des arguments nommés après avoir décompressé les arguments. Un argument nommé ne doit pas écraser un argument déjà déballé.

Exemple #19 Utiliser les arguments nommés après le déballage

<?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)); // Erreur fatale. Le paramètre nommé $b écrase l'argument précédent.
?>
add a note

User Contributed Notes 15 notes

up
124
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".
*/
?>
up
7
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).
up
19
LilyWhite
2 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
up
15
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
tianyiw at vip dot qq dot com
1 year 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)
// }
up
29
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
13
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
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
12
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
3
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.
up
4
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
4
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
Hayley Watson
1 month ago
The ... argument syntax will capture named arguments that don't correspond to actual function parameters. These unknown named arguments will be ignored by functions like func_get_args(), but they are available in the variadic parameter under the name they were given:

<?php

function demo($first, $second, ...$rest)
{
echo
"First:";
var_dump($first);
echo
"\n";

echo
"Second:";
var_dump($second);
echo
"\n";

echo
"Rest:";
var_dump($rest);
echo
"\n";
}

demo(1, third:3, second:2, fourth:4);
?>
up
0
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
0
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)
To Top