Fonction PHP avec paramètres facultatifs

J'ai écrit une fonction PHP qui peut accepter 10 paramètres, mais seulement 2 sont nécessaires. Parfois, je veux définir le huitième paramètre, mais je ne veux pas taper des chaînes vides pour chacun des paramètres jusqu'à ce que j'atteigne le huitième.

Une idée que j'ai eue était de passer une fonction abstraite avec un tableau de paramètres qui la transmet à la fonction réelle.

Existe-t-il une meilleure façon de configurer la fonction afin que je puisse transmettre uniquement les paramètres que je veux?

Faites en sorte que la fonction prenne un paramètre: un tableau. Transmettez les paramètres réels en tant que valeurs dans le tableau.

Edit: le lien dans le commentaire de Pekka résume à peu près tout.

Ce que j'ai fait dans ce cas, c'est de passer un tableau, où la clé est le nom du paramètre et la valeur est la valeur.

$optional = array(
  "param" => $param1,
  "param2" => $param2
);

function func($required, $requiredTwo, $optional) {
  if(isset($optional["param2"])) {
    doWork();
  }
}

Pour accomplir ce que vous voulez, utilisez un tableau comme l'a dit Rabbot (bien que cela puisse devenir difficile à documenter / maintenir s'il est utilisé de manière excessive). Ou utilisez simplement les arguments optionnels traditionnels.

//My function with tons of optional params
function my_func($req_a, $req_b, $opt_a = NULL, $opt_b = NULL, $opt_c = NULL)
{
  //Do stuff
}
my_func('Hi', 'World', null, null, 'Red');

Cependant, je trouve généralement que lorsque je commence à écrire une fonction / méthode avec autant d'arguments - le plus souvent, c'est une odeur de code, et peut être re-factorisée / abstraite en quelque chose de beaucoup plus propre.

//Specialization of my_func - assuming my_func itself cannot be refactored
function my_color_func($reg_a, $reg_b, $opt = 'Red')
{
  return my_func($reg_a, $reg_b, null, null, $opt);
}
my_color_func('Hi', 'World');
my_color_func('Hello', 'Universe', 'Green');

Dans PHP 5.6 et versions ultérieures, les listes d'arguments peuvent inclure le jeton ... pour indiquer que la fonction accepte un nombre variable d'arguments. Les arguments seront passés dans la variable donnée sous forme de tableau; par exemple:

Exemple d'utilisation de ... pour accéder aux arguments de variable

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

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

L'exemple ci-dessus affichera:

10

Liste d'arguments de longueur variable Documentation PHP

Vous pouvez simplement définir la valeur par défaut sur null.

<?php
function functionName($value, $value2 = null) {
// do stuff
}

REMARQUE: Ceci est une ancienne réponse, pour PHP 5.5 et inférieur. PHP 5.6+ prend en charge les arguments par défaut

En PHP 5.5 et inférieur, vous pouvez y parvenir en utilisant l'une de ces 2 méthodes:

• en utilisant func_num_args () et func_get_arg () ;
• en utilisant des arguments NULL;

Comment utiliser

function method_1()
{
  $arg1 = (func_num_args() >= 1)? func_get_arg(0): "default_value_for_arg1";
  $arg2 = (func_num_args() >= 2)? func_get_arg(1): "default_value_for_arg2";
}

function method_2($arg1 = null, $arg2 = null)
{
  $arg1 = $arg1? $arg1: "default_value_for_arg1";
  $arg2 = $arg2? $arg2: "default_value_for_arg2";
}

Je préfère la deuxième méthode car elle est propre et facile à comprendre, mais parfois vous aurez besoin de la première méthode.

Je pense que vous pouvez également utiliser des objets comme paramètres de transport.

$myParam = new stdClass();
$myParam->optParam2 = 'something';
$myParam->optParam8 = 3;
theFunction($myParam);

function theFunction($fparam){      
  return "I got ".$fparam->optParam8." of ".$fparam->optParam2." received!";
}

Bien sûr, vous devez définir les valeurs par défaut pour "optParam8" et "optParam2" dans cette fonction, dans les autres cas, vous obtiendrez "Remarque: propriété non définie: stdClass :: $ optParam2"

Si vous utilisez des tableaux comme paramètres de fonction, j'aime cette façon de définir les valeurs par défaut:

function theFunction($fparam){
   $default = array(
      'opt1' => 'nothing',
      'opt2' => 1
   );
   if(is_array($fparam)){
      $fparam = array_merge($default, $fparam);
   }else{
      $fparam = $default;
   }
   //now, the default values are overwritten by these passed by $fparam
   return "I received ".$fparam['opt1']." and ".$fparam['opt2']."!";
}

Si seulement deux valeurs sont nécessaires pour créer l'objet avec un état valide, vous pouvez simplement supprimer tous les autres arguments facultatifs et leur fournir des setters (sauf si vous ne voulez pas qu'ils soient modifiés à l'exécution). Ensuite, instanciez simplement l'objet avec les deux arguments requis et définissez les autres selon les besoins via le setter.

Lectures complémentaires

• Martin Fowler sur l'injection constructeur vs poseur et
• Injection de dépendances via les constructeurs ou les setters de propriété?

Je sais que c'est un ancien message, mais j'avais un problème comme l'OP et c'est ce que j'ai proposé.

Exemple de tableau que vous pourriez passer. Vous pouvez le commander à nouveau si une commande particulière était requise, mais pour cette question, cela fera ce qui est demandé.

$argument_set = array (8 => 'lots', 5 => 'of', 1 => 'data', 2 => 'here');

Ceci est gérable, facile à lire et les points d'extraction de données peuvent être ajoutés et supprimés à un moment donné n'importe où dans le codage et évitent toujours une réécriture massive. J'ai utilisé des clés entières pour correspondre à la question originale OP, mais les clés de chaîne pourraient être utilisées tout aussi facilement. En fait pour la lisibilité je le conseillerais.

Collez-le dans un fichier externe pour plus de facilité

function unknown_number_arguments($argument_set) {

    foreach ($argument_set as $key => $value) {

        # create a switch with all the cases you need. as you loop the array 
        # keys only your submitted $keys values will be found with the switch. 
        switch ($key) {
            case 1:
                # do stuff with $value
                break;
            case 2:
                # do stuff with $value;
                break;
            case 3:
                # key 3 omitted, this wont execute 
                break;
            case 5:
                # do stuff with $value;
                break;
            case 8:
                # do stuff with $value;
                break;
            default:
                # no match from the array, do error logging?
                break;
        }
    }
return;
}

mettez ceci au début si le fichier.

$argument_set = array(); 

Utilisez-les simplement pour attribuer le prochain élément de données, utilisez la numérotation / la dénomination en fonction de la provenance des données.

$argument_set[1][] = $some_variable; 

Et enfin passer le tableau

unknown_number_arguments($argument_set);

function yourFunction($var1, $var2, $optional = Null){
   ... code
}

Vous pouvez créer une fonction régulière, puis ajouter vos variables facultatives en leur donnant une valeur Null par défaut.

Un Null est toujours une valeur, si vous n'appelez pas la fonction avec une valeur pour cette variable, elle ne sera pas vide donc pas d'erreur.

Si vous ne passez généralement que la 8ème valeur, vous pouvez réorganiser vos paramètres afin que ce soit le premier. Il vous suffit de spécifier les paramètres jusqu'au dernier que vous souhaitez définir.

Si vous utilisez des valeurs différentes, vous avez 2 options.

La première consisterait à créer un ensemble de fonctions wrapper qui prennent différents paramètres et définissent les valeurs par défaut sur les autres. Ceci est utile si vous n'utilisez que quelques combinaisons, mais peut rapidement devenir très compliqué.

L'autre option est de passer un tableau où les clés sont les noms des paramètres. Vous pouvez alors simplement vérifier s'il y a une valeur dans le tableau avec une clé, et sinon utiliser la valeur par défaut. Mais encore une fois, cela peut devenir compliqué et ajouter beaucoup de code supplémentaire si vous avez beaucoup de paramètres.

PHP autorise les arguments par défaut ( lien ). Dans votre cas, vous pouvez définir tous les paramètres de 3 à 8 comme NULL ou comme une chaîne vide "" en fonction de votre code de fonction. De cette manière, vous pouvez appeler la fonction uniquement en utilisant les deux premiers paramètres.

Par exemple:

<?php
  function yourFunction($arg1, $arg2, $arg3=NULL, $arg4=NULL, $arg5=NULL, $arg6=NULL, $arg7=NULL, $arg8=NULL){
echo $arg1;
echo $arg2;
if(isset($arg3)){echo $arg3;}
# other similar statements for $arg4, ...., $arg5
if(isset($arg8)){echo $arg8;}
}

Définissez simplement Null pour ignorer les paramètres que vous ne souhaitez pas utiliser, puis définissez le paramètre nécessaire en fonction de la position.

 function myFunc($p1,$p2,$p3=Null,$p4=Null,$p5=Null,$p6=Null,$p7=Null,$p8=Null){
    for ($i=1; $i<9; $i++){
        $varName = "p$i";
        if (isset($$varName)){
            echo $varName." = ".$$varName."<br>\n";
        }
    }
}   

myFunc( "1", "2", Null, Null, Null, Null, Null, "eight" );

func( "1", "2", default, default, default, default, default, "eight" );