Fonction PHP avec paramètres optionnels

Ce que j'ai fait dans ce cas 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 Rabbot dit (bien que cela puisse devenir une douleur à documenter/maintenir si utilisé excessivement). Ou utilisez simplement le traditionnel args optionnel.

//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 - plus souvent qu'autrement c'est une odeur de code, et peut être recalculé/abstracté dans 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');

Remarque: c'est un vieux post, mais peut aider quelqu'un, maintenant ou dans l'avenir.

vous pouvez y parvenir en utilisant l'une de ces 2 méthodes:

• utilisant les fonctions func_num_args () et func_get_arg () ;
• à l'aide de valeurs par défaut des arguments;

comment utiliser

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

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

je préfère la deuxième méthode parce que c'est propre et facile à comprendre, mais parfois vous avez peut-être besoin de la première méthode.

en PHP 5.6 et plus tard, 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 comme un tableau; par exemple:

Exemple D'Utilisation ... 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 affichera:

10

de longueur Variable listes des arguments de la Documentation PHP

je pense, vous pouvez utiliser des objets comme des params-transportes, aussi.

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

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

De cource, vous devez définir les valeurs par défaut pour "optParam8" et "optParam2" dans cette fonction, dans d'autres cas, vous obtiendrez "notice: Undefined property: 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 optionnels et fournir des setters pour eux (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 au besoin à travers le setter.

Lire la suite

• Martin Fowler sur Constructeur vs Injection par Mutateur et
• de l'injection de Dépendances par les constructeurs ou les accesseurs de propriété?

je sais que c'est un vieux post, mais j'ai eu un problème comme l'OP et c'est ce que je suis venu avec.

exemple de tableau que vous pouvez passer. Vous pouvez le commander de nouveau si une commande particulière est nécessaire, mais pour cette question cela fera ce qui est demandé.

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

c'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 encore éviter une réécriture massive. J'ai utilisé les touches entières correspondent à la question originale de L'OP, mais les touches string peuvent être utilisées aussi facilement. En fait pour la lisibilité je le conseillerais.

coller ceci dans un fichier externe pour faciliter

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;
}

placer au début du fichier.

$argument_set = array(); 

il suffit de les utiliser pour assigner la prochaine pièce de données utiliser la numérotation/appellation selon l'origine des données.

$argument_set[1][] = $some_variable; 

et enfin passe le tableau

unknown_number_arguments($argument_set);

vous pouvez simplement définir la valeur par défaut à null.

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

si vous êtes généralement juste en train de passer dans la 8ème valeur, vous pouvez réordonner vos paramètres ainsi il est premier. Vous n'avez qu'à spécifier les paramètres jusqu'au dernier que vous voulez configurer.

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

L'un serait de créer un ensemble de fonctions d'enrubannage qui prennent différents paramètres et fixent les valeurs par défaut sur les autres. Cela est utile si vous utilisez seulement quelques combinaisons, mais peut devenir très salissant rapidement.

L'autre option est de passer un tableau dont les clés sont les noms des paramètres. Vous pouvez alors juste vérifier s'il y a une valeur dans le tableau avec une clé, et si vous n'utilisez pas la valeur par défaut. Mais encore une fois, cela peut être gênant et ajouter beaucoup de code supplémentaire si vous avez beaucoup de paramètres.

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