## Paramètres et arguments de fonction

Les paramètres de la fonction sont déclarés dans la signature de la 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 de gauche à droite, et le résultat est assigné aux paramètres de la fonction, avant que la fonction ne soit effectivement 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.

> Note:

> À partir de PHP 7.3.0, il est possible d'avoir une virgule finale dans la liste d'arguments pour les appels de fonction :

>     <?php
>     $v = foo(
>         $arg_1,
>         $arg_2,
>     );

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

Exemple #1 Liste des paramètres de la fonction avec une virgule finale

    <?php
    function takes_many_args(
        $first_arg,
        $second_arg,
        $a_very_long_argument_name,
        $arg_with_default = 5,
        $again = 'a default string', // Cette virgule finale n'était pas permise 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). Pour que les fonctions puissent changer la valeur des arguments, il faut passer ces arguments par référence.

Pour qu'un argument soit toujours passé par référence, il suffit d'ajouter un '`&`' devant le paramètre dans la déclaration de la fonction :

Exemple #2 Passage des arguments de fonction 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.'

Il est incorrect de passer une expression constante comme argument à un paramètre qui attend d'être passé par référence.

### Valeurs par défaut des paramètres

Une fonction peut définir des valeurs par défaut pour les paramètres en utilisant une syntaxe similaire à celle de l'affectation d'une variable. La valeur par défaut est utilisée uniquement lorsque l'argument du paramètre n'est pas passé. Il est à noter que passer `null` ne définit pas la valeur par défaut.

Exemple #3 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 #4 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 #5 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 paramètres optionnels doivent être spécifiés après les paramètres obligatoires, sinon ils ne peuvent pas être omis dans les appels. Considérons le code suivant :

Exemple #6 Utilisation incorrecte des paramètres de fonction par défaut

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

    Deprecated: faireunyaourt(): Optional parameter $container declared before required parameter $flavour is implicitly treated as a required parameter in script on line 2

    Fatal error: Uncaught ArgumentCountError: Too few arguments to function faireunyaourt(), 1 passed in script on line 7 and exactly 2 expected in script:2
    Stack trace:
    #0 script(7): faireunyaourt('framboise')
    #1 {main}
      thrown in script on line 2

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

Exemple #7 Utilisation correcte des paramètres de fonction par défaut

    <?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és pour passer outre plusieurs paramètres optionnels.

Exemple #8 Utilisation correcte des paramètres 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 paramètres 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 paramètres de la forme `Type $param = null`, où le `null` par défaut rend le type implicitement nullable. Cet usage est déprécié à partir de PHP 8.4.0, et un type nullable explicite doit être utilisé à la place.

Exemple #9 Déclaration des paramètres optionnels après les paramètres obligatoires

    <?php
    function foo($a = [], $b) {}     // Valeur par défaut non utilisée ; déconseillée à partir de PHP 8.0.0
    function foo($a, $b) {}          // Fonctionnellement équivalent, pas d’avertissement de dépréciation

    function bar(A $a = null, $b) {} // À partir de PHP 8.1.0, $a est implicitement requis
                                     // (car il précède un paramètre requis),
                                     // mais implicitement nullable (déconseillé à partir de PHP 8.4.0),
                                     // car la valeur par défaut du paramètre est null
    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éfinies 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 #10 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 #11 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

Il est possible de spécifier des paramètres 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 #12 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
    Fatal error: Uncaught TypeError: total_intervals(): Argument #2 must be of type DateInterval, null given, called in script on line 15 and defined in script:2
    Stack trace:
    #0 script(15): total_intervals('d', NULL)
    #1 {main}
      thrown in script on line 2

Pour finir, il est possible de 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 existants. 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 suivi 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 #13 Syntaxe des arguments nommés

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

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

Exemple #14 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 #15 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 #16 Combiner les arguments nommés avec les arguments positionnels

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

Passer le même argument plusieurs fois résulte en une Error exception.

Exemple #17 Erreur déclenchée lorsqu'un argument est passé plusieurs fois au même paramètre nommé

    <?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éballé les arguments. Un argument nommé ne doit pas écraser un argument déjà déballé.

Exemple #18 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.

`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open