Utilisation d'arguments par défaut dans une fonction

Je ne comprends pas les valeurs par défaut des fonctions PHP. Disons que j'ai une fonction comme celle-ci:

function foo($blah, $x = "some value", $y = "some other value") {
    // code here!
}

Que faire si je veux utiliser l'argument par défaut pour $ x et définir un argument différent pour $ y?

J'ai expérimenté différentes manières et je suis de plus en plus confus. Par exemple, j'ai essayé ces deux:

foo("blah", null, "test");
foo("blah", "", "test");

Mais les deux n'aboutissent pas à un argument par défaut approprié pour $ x. J'ai également essayé de le définir par nom de variable.

foo("blah", $x, $y = "test");   

Je m'attendais vraiment à ce que quelque chose comme ça fonctionne. Mais cela ne fonctionne pas du tout comme je m'y attendais. Il semble que peu importe ce que je fais, je vais quand même devoir taper les arguments par défaut, chaque fois que j'invoque la fonction. Et je dois manquer quelque chose d'évident.

Je proposerais de changer la déclaration de fonction comme suit afin que vous puissiez faire ce que vous voulez:

function foo($blah, $x = null, $y = null) {
    if (null === $x) {
        $x = "some value";
    }

    if (null === $y) {
        $y = "some other value";
    }

    code here!

}

De cette façon, vous pouvez passer un appel comme foo('blah', null, 'non-default y value');et le faire fonctionner comme vous le souhaitez, où le deuxième paramètre $xobtient toujours sa valeur par défaut.

Avec cette méthode, passer une valeur nulle signifie que vous voulez la valeur par défaut pour un paramètre lorsque vous souhaitez remplacer la valeur par défaut pour un paramètre qui vient après.

Comme indiqué dans d'autres réponses,

les paramètres par défaut ne fonctionnent que comme derniers arguments de la fonction. Si vous souhaitez déclarer les valeurs par défaut dans la définition de fonction, il n'y a aucun moyen d'omettre un paramètre et d'en remplacer un qui le suit.

Si j'ai une méthode qui peut accepter un nombre variable de paramètres et des paramètres de types différents, je déclare souvent la fonction similaire à la réponse donnée par Ryan P.

Voici un autre exemple (cela ne répond pas à votre question, mais il est espérons-le informatif:

public function __construct($params = null)
{
    if ($params instanceof SOMETHING) {
        // single parameter, of object type SOMETHING
    } else if (is_string($params)) {
        // single argument given as string
    } else if (is_array($params)) {
        // params could be an array of properties like array('x' => 'x1', 'y' => 'y1')
    } else if (func_num_args() == 3) {
        $args = func_get_args();

        // 3 parameters passed
    } else if (func_num_args() == 5) {
        $args = func_get_args();
        // 5 parameters passed
    } else {
        throw new InvalidArgumentException("Could not figure out parameters!");
    }
}

Les arguments facultatifs ne fonctionnent qu'à la fin d'un appel de fonction. Il n'y a aucun moyen de spécifier une valeur pour $ y dans votre fonction sans spécifier également $ x. Certains langages le prennent en charge via des paramètres nommés (VB / C # par exemple), mais pas PHP.

Vous pouvez émuler cela si vous utilisez un tableau associatif pour les paramètres au lieu des arguments - c.-à-d.

function foo(array $args = array()) {
    $x = !isset($args['x']) ? 'default x value' : $args['x'];
    $y = !isset($args['y']) ? 'default y value' : $args['y'];

    ...
}

Appelez ensuite la fonction comme ceci:

foo(array('y' => 'my value'));

C'est effectivement possible:

foo( 'blah', (new ReflectionFunction('foo'))->getParameters()[1]->getDefaultValue(), 'test');

Que vous vouliez le faire est une autre histoire :)

METTRE À JOUR:

Les raisons d'éviter cette solution sont:

• c'est (sans doute) moche
• il a une surcharge évidente.
• comme la preuve des autres réponses, il existe des alternatives

Mais cela peut en fait être utile dans les situations où:

• vous ne voulez pas / ne pouvez pas changer la fonction d'origine.

• vous pouvez changer la fonction mais:

  • using null(ou équivalent) n'est pas une option (voir le commentaire de DiegoDD )
  • vous ne voulez aller ni avec un associatif ni avec func_num_args()
  • votre vie dépend de la sauvegarde de quelques LOC

À propos des performances, un test très simple montre que l'utilisation de l'API Reflection pour obtenir les paramètres par défaut rend l'appel de fonction 25 fois plus lent , alors que cela prend toujours moins d'une microseconde . Vous devriez savoir si vous pouvez vivre avec ça.

Bien sûr, si vous voulez l'utiliser dans une boucle, vous devriez obtenir la valeur par défaut au préalable.

function image(array $img)
{
    $defaults = array(
        'src'    => 'cow.png',
        'alt'    => 'milk factory',
        'height' => 100,
        'width'  => 50
    );

    $img = array_merge($defaults, $img);
    /* ... */
}

La seule façon que je connaisse de le faire est d'omettre le paramètre. La seule façon d'omettre le paramètre est de réorganiser la liste des paramètres de sorte que celui que vous souhaitez omettre soit après les paramètres que vous DEVEZ définir. Par exemple:

function foo($blah, $y = "some other value", $x = "some value")

Ensuite, vous pouvez appeler foo comme:

foo("blah", "test");

Cela se traduira par:

$blah = "blah";
$y = "test";
$x = "some value";

J'ai récemment eu ce problème et j'ai trouvé cette question et ces réponses. Bien que les questions ci-dessus fonctionnent, le problème est qu'elles ne montrent pas les valeurs par défaut aux IDE qui les prennent en charge (comme PHPStorm).

si vous utilisez, nullvous ne saurez pas quelle serait la valeur si vous le laissez vide.

La solution que je préfère est de mettre également la valeur par défaut dans la définition de la fonction:

protected function baseItemQuery(BoolQuery $boolQuery, $limit=1000, $sort = [], $offset = 0, $remove_dead=true)
{
    if ($limit===null) $limit =1000;
    if ($sort===null) $sort = [];
    if ($offset===null) $offset = 0;
    ...

La seule différence est que je dois m'assurer qu'ils sont identiques - mais je pense que c'est un petit prix à payer pour la clarté supplémentaire.

Vous ne pouvez pas faire cela directement, mais un peu de bidouillage de code permet d'émuler.

function foo($blah, $x = false, $y = false) {
  if (!$x) $x = "some value";
  if (!$y) $y = "some other value";

  // code
}

<?php
function info($name="George",$age=18) {
echo "$name is $age years old.<br>";
}
info();     // prints default values(number of values = 2)
info("Nick");   // changes first default argument from George to Nick
info("Mark",17);    // changes both default arguments' values

?>

Mes 2 cents avec opérateur de fusion nul ?? (depuis PHP 7)

function foo($blah, $x = null, $y = null) {
    $varX = $x ?? 'Default value X';
    $varY = $y ?? 'Default value Y';
    // ...
}

Vous pouvez consulter plus d'exemples sur mon repl.it

C'est le cas, lorsque l'objet est meilleur - parce que vous pouvez configurer votre objet pour qu'il contienne x et y, configurer les valeurs par défaut, etc.

L'approche avec tableau est proche de créer un objet (en fait, l'objet est un tas de paramètres et de fonctions qui fonctionneront sur l'objet, et le tableau de prise de fonction fonctionnera sur certains paramètres)

Cerainly vous pouvez toujours faire quelques astuces pour définir null ou quelque chose comme ça par défaut

Vous pouvez également vérifier si vous avez une chaîne vide comme argument afin de pouvoir appeler comme:

foo('blah', "", 'non-default y value', null);

En dessous de la fonction:

function foo($blah, $x = null, $y = null, $z = null) {
    if (null === $x || "" === $x) {
        $x = "some value";
    }

    if (null === $y || "" === $y) {
        $y = "some other value";
    }

    if (null === $z || "" === $z) {
        $z = "some other value";
    }

    code here!

}

Peu importe que vous remplissiez nullou "", vous obtiendrez toujours le même résultat.

Passez un tableau à la fonction, au lieu de paramètres individuels et utilisez l'opérateur de fusion nul (PHP 7+).

Ci-dessous, je passe un tableau avec 2 éléments. À l'intérieur de la fonction, je vérifie si la valeur de l'élément1 est définie, si elle n'est pas attribuée au coffre par défaut.

$args = ['item2' => 'item2',
        'item3' => 'value3'];

    function function_name ($args) {
        isset($args['item1']) ? $args['item1'] : 'default value';
    }