Comment ignorer les arguments facultatifs dans un appel de fonction?

OK, j'ai totalement oublié comment sauter les arguments en PHP.

Disons que j'ai:

function getData($name, $limit = '50', $page = '1') {
    ...
}

Comment appeler cette fonction pour que le paramètre du milieu prenne la valeur par défaut (c'est-à-dire «50»)?

getData('some name', '', '23');

Ce qui précède serait-il correct? Je n'arrive pas à faire fonctionner ça.

Votre message est correct.

Malheureusement, si vous devez utiliser un paramètre facultatif à la toute fin de la liste de paramètres, vous devez tout spécifier jusqu'à ce dernier paramètre. Généralement, si vous voulez mélanger et assortir, vous leur donnez les valeurs par défaut de ''ou null, et ne les utilisez pas dans la fonction si elles sont cette valeur par défaut.

Il n'y a aucun moyen de "sauter" un argument autre que de spécifier une valeur par défaut comme falseou null.

Comme PHP manque de sucre syntaxique à ce sujet, vous verrez souvent quelque chose comme ceci:

checkbox_field(array(
    'name' => 'some name',
    ....
));

Ce qui, comme dit éloquemment dans les commentaires, utilise des tableaux pour émuler des arguments nommés.

Cela donne une flexibilité ultime mais peut ne pas être nécessaire dans certains cas. À tout le moins, vous pouvez déplacer tout ce que vous pensez ne pas être attendu la plupart du temps à la fin de la liste des arguments.

Non, il n'est pas possible de sauter des arguments de cette façon. Vous ne pouvez omettre de transmettre des arguments que s'ils se trouvent à la fin de la liste de paramètres.

Il y avait une proposition officielle à ce sujet: https://wiki.php.net/rfc/skipparams , qui a été refusée. La page de proposition renvoie à d'autres questions SO sur ce sujet.

Rien n'a changé en ce qui concerne la possibilité de sauter des arguments facultatifs, mais pour une syntaxe correcte et pour pouvoir spécifier NULL pour les arguments que je veux ignorer, voici comment je le ferais:

define('DEFAULT_DATA_LIMIT', '50');
define('DEFAULT_DATA_PAGE', '1');

/**
 * getData
 * get a page of data 
 *
 * Parameters:
 *     name - (required) the name of data to obtain
 *     limit - (optional) send NULL to get the default limit: 50
 *     page - (optional) send NULL to get the default page: 1
 * Returns:
 *     a page of data as an array
 */

function getData($name, $limit = NULL, $page = NULL) {
    $limit = ($limit===NULL) ? DEFAULT_DATA_LIMIT : $limit;
    $page = ($page===NULL) ? DEFAULT_DATA_PAGE : $page;
    ...
}

Cela peut être appelé ainsi: getData('some name',NULL,'23');et quiconque appellera la fonction à l'avenir n'a pas besoin de se souvenir des valeurs par défaut à chaque fois ou de la constante déclarée pour eux.

La réponse simple est non . Mais pourquoi sauter lors de la réorganisation des arguments permet d'atteindre cet objectif?

Le vôtre est une " utilisation incorrecte des arguments de fonction par défaut " et ne fonctionnera pas comme vous le souhaitez.

Une note latérale de la documentation PHP:

Lorsque vous utilisez des arguments par défaut, tous les paramètres par défaut doivent être sur le côté droit de tous les arguments autres que ceux par défaut; sinon, les choses ne fonctionneront pas comme prévu.

Considérer ce qui suit:

function getData($name, $limit = '50', $page = '1') {
    return "Select * FROM books WHERE name = $name AND page = $page limit $limit";
}

echo getData('some name', '', '23');   // won't work as expected

La sortie sera:

"Select * FROM books WHERE name = some name AND page = 23 limit"

L'utilisation correcte des arguments de fonction par défaut devrait être comme ceci:

function getData($name, $page = '1', $limit = '50') {
    return "Select * FROM books WHERE name = $name AND page = $page limit $limit";
}

echo getData('some name', '23');  // works as expected

La sortie sera:

"Select * FROM books WHERE name = some name AND page = 23 limit 50"

Mettre la valeur par défaut à votre droite après les non-valeurs par défaut garantit qu'il sera toujours réexécuté la valeur par défaut pour cette variable si elle n'est pas définie / donnée Voici un lien pour référence et d'où viennent ces exemples.

Edit: le définir nullcomme d'autres le suggèrent peut fonctionner et est une autre alternative, mais peut ne pas convenir à ce que vous voulez. Il définira toujours la valeur par défaut sur null s'il n'est pas défini.

Pour tout paramètre ignoré (vous devez), utilisez le paramètre par défaut, pour être du bon côté.

(Le règlement de null où le paramètre par défaut est `` ou similaire ou vice versa vous posera des problèmes ...)

Comme mentionné ci-dessus, vous ne pourrez pas ignorer les paramètres. J'ai écrit cette réponse pour fournir un addendum, qui était trop volumineux pour être placé dans un commentaire.

@Frank Nocke propose d'appeler la fonction avec ses paramètres par défaut, donc par exemple avoir

function a($b=0, $c=NULL, $d=''){ //...

Tu devrais utiliser

$var = a(0, NULL, 'ddd'); 

ce qui revient fonctionnellement à omettre les deux premiers paramètres ( $bet $c).

On ne sait pas lesquels sont les valeurs par défaut (est 0 tapé pour fournir la valeur par défaut, ou est-ce important?).

Il existe également un risque que le problème des valeurs par défaut soit lié à une fonction externe (ou intégrée), lorsque les valeurs par défaut pourraient être modifiées par l'auteur de la fonction (ou de la méthode). Donc, si vous ne changez pas votre appel dans le programme, vous pourriez involontairement changer son comportement.

Une solution de contournement pourrait être de définir des constantes globales, comme DEFAULT_A_Bce serait «valeur par défaut du paramètre B de la fonction A» et «omettre» les paramètres de cette façon:

$var = a(DEFAULT_A_B, DEFAULT_A_C, 'ddd');

Pour les classes, il est plus facile et plus élégant de définir des constantes de classe, car elles font partie de la portée globale, par exemple.

class MyObjectClass {
  const DEFAULT_A_B = 0;

  function a($b = self::DEFAULT_A_B){
    // method body
  }
} 
$obj = new MyObjectClass();
$var = $obj->a(MyObjectClass::DEFAULT_A_B); //etc.

Notez que cette constante par défaut est définie exactement une fois dans tout le code (il n'y a pas de valeur même dans la déclaration de méthode), donc en cas de changements inattendus, vous fournirez toujours la fonction / méthode avec la valeur par défaut correcte.

La clarté de cette solution est bien sûr meilleure que de fournir des valeurs brutes par défaut (comme NULL, 0etc.) qui ne disent rien au lecteur.

(Je suis d'accord qu'appeler comme $var = a(,,'ddd');serait la meilleure option)

Vous ne pouvez pas ignorer les arguments, mais vous pouvez utiliser des paramètres de tableau et vous ne devez définir qu'un seul paramètre, qui est un tableau de paramètres.

function myfunction($array_param)
{
    echo $array_param['name'];
    echo $array_param['age'];
    .............
}

Et vous pouvez ajouter autant de paramètres dont vous avez besoin, vous n'avez pas besoin de les définir. Lorsque vous appelez la fonction, vous mettez vos paramètres comme ceci:

myfunction(array("name" => "Bob","age" => "18", .........));

Eh bien, comme tout le monde l'a déjà dit, ce que vous voulez ne sera pas possible en PHP sans ajouter de lignes de code dans la fonction.

Mais vous pouvez placer ce morceau de code en haut d'une fonction pour obtenir vos fonctionnalités:

foreach((new ReflectionFunction(debug_backtrace()[0]["function"]))->getParameters() as $param) {
    if(empty(${$param->getName()}) && $param->isOptional())
        ${$param->getName()} = $param->getDefaultValue();
}

Donc, fondamentalement, debug_backtrace()j'obtiens le nom de la fonction dans laquelle ce code est placé, pour ensuite créer un nouveauReflectionFunction objet et une boucle à travers tous les arguments de la fonction.

Dans la boucle, je vérifie simplement si l'argument de la fonction est empty()ET que l'argument est "optionnel" (signifie qu'il a une valeur par défaut). Si oui, j'attribue simplement la valeur par défaut à l'argument.

Demo

Définissez la limite sur null

function getData($name, $limit = null, $page = '1') {
    ...
}

et appel à cette fonction

getData('some name', null, '23');

si vous souhaitez définir la limite, vous pouvez passer en argument

getData('some name', 50, '23');

Comme indiqué précédemment , rien n'a changé. Attention, cependant, trop de paramètres (en particulier ceux optionnels) sont un indicateur fort de l'odeur du code.

Peut-être que votre fonction en fait trop:

// first build context
$dataFetcher->setPage(1);
// $dataFetcher->setPageSize(50); // not used here
// then do the job
$dataFetcher->getData('some name');

Certains paramètres peuvent être regroupés de manière logique:

$pagination = new Pagination(1 /*, 50*/);
getData('some name', $pagination);
// Java coders will probably be familiar with this form:
getData('some name', new Pagination(1));

En dernier recours, vous pouvez toujours introduire un objet paramètre ad-hoc :

$param = new GetDataParameter();
$param->setPage(1);
// $param->setPageSize(50); // not used here
getData($param);

(qui est juste une version glorifiée de la technique de tableau de paramètres moins formelle )

Parfois, la raison même pour laquelle un paramètre est optionnel est fausse. Dans cet exemple, est-ce $pagevraiment censé être facultatif? L'enregistrement de quelques personnages fait-il vraiment une différence?

// dubious
// it is not obvious at first sight that a parameterless call to "getData()"
// returns only one page of data
function getData($page = 1);

// this makes more sense
function log($message, $timestamp = null /* current time by default */);

Cet extrait:

    function getData ($ name, $ options) {
       $ default = tableau (
            'limite' => 50,
            'page' => 2,
        );
        $ args = array_merge ($ default, $ options);
        print_r ($ args);
    }

    getData ('toto', tableau ());
    getData ('toto', tableau ('limite' => 2));
    getData ('foo', array ('limit' => 10, 'page' => 10));

La réponse est:

     Tableau
    (
        [limite] => 50
        [page] => 2
    )
    Tableau
    (
        [limite] => 2
        [page] => 2
    )
    Tableau
    (
        [limite] => 10
        [page] => 10
    )

Voici ce que je ferais:

<?php

    function getData($name, $limit = '', $page = '1') {
            $limit = (EMPTY($limit)) ? 50 : $limit;
            $output = "name=$name&limit=$limit&page=$page";
            return $output;
    }

     echo getData('table');

    /* output name=table&limit=50&page=1 */

     echo getData('table',20);

    /* name=table&limit=20&page=1 */

    echo getData('table','',5);

    /* output name=table&limit=50&page=5 */

    function getData2($name, $limit = NULL, $page = '1') {
            $limit = (ISSET($limit)) ? $limit : 50;
            $output = "name=$name&limit=$limit&page=$page";
            return $output;
    }

    echo getData2('table');

    // /* output name=table&limit=50&page=1 */

    echo getData2('table',20);

    /* output name=table&limit=20&page=1 */

    echo getData2('table',NULL,3);

    /* output name=table&limit=50&page=3 */

?>

J'espère que cela aidera quelqu'un

C'est une sorte de vieille question avec un certain nombre de réponses techniquement compétentes, mais elle réclame l'un des modèles de conception modernes de PHP: la programmation orientée objet. Au lieu d'injecter une collection de types de données scalaires primitifs, envisagez d'utiliser un "objet injecté" qui contient toutes les données nécessaires à la fonction. http://php.net/manual/en/language.types.intro.php

L'objet injecté peut avoir des routines de validation de propriété, etc. avec des données potentiellement incomplètes.

Nous pouvons saisir l'objet injecté pour détecter les erreurs avant le déploiement. Certaines des idées sont résumées dans cet article d'il y a quelques années.

https://www.experts-exchange.com/articles/18409/Using-Named-Parameters-in-PHP-Function-Calls.html

J'ai dû créer une usine avec des paramètres optionnels, ma solution de contournement était d'utiliser l'opérateur de fusion nul:

public static function make(
    string $first_name = null,
    string $last_name = null,
    string $email = null,
    string $subject = null,
    string $message = null
) {
    $first_name = $first_name ?? 'First';
    $last_name  = $last_name ?? 'Last';
    $email      = $email ?? 'foo@bar.com';
    $subject    = $subject ?? 'Some subject';
    $message    = $message ?? 'Some message';
}

Usage:

$factory1 = Factory::make('First Name Override');
$factory2 = Factory::make(null, 'Last Name Override');
$factory3 = Factory::make(null, null, null, null 'Message Override');

Ce n'est pas la chose la plus jolie, mais pourrait être un bon modèle à utiliser dans les usines pour les tests.

Essaye ça.

function getData($name, $limit = NULL, $page = '1') {
               if (!$limit){
                 $limit = 50;
               }
}

getData('some name', '', '23');

Vous ne pouvez pas ignorer le paramètre du milieu dans votre appel de fonction. Mais, vous pouvez contourner ceci:

function_call('1', '2', '3'); // Pass with parameter.
function_call('1', null, '3'); // Pass without parameter.

Fonction:

function function_call($a, $b='50', $c){
    if(isset($b)){
        echo $b;
    }
    else{
        echo '50';
    }
}

Comme l'a souligné @IbrahimLawal. Il est préférable de les définir simplement sur des nullvaleurs. Vérifiez simplement si la valeur passée est celle nulldans laquelle vous utilisez vos valeurs par défaut définies.

<?php
define('DEFAULT_LIMIT', 50);
define('DEFAULT_PAGE', 1);

function getData($name, $limit = null, $page = null) {
    $limit = is_null($limit) ? DEFAULT_LIMIT : $limit;
    $page = is_null($page) ? DEFAULT_PAGE : $page;
    ...
}
?>

J'espère que cela t'aides.

getData('some name');

ne les transmettez pas et la valeur par défaut sera acceptée