Fonction PHP avec un nombre illimité de paramètres

Comment puis-je écrire une fonction qui peut accepter un nombre illimité de paramètres?

Ce que suis en train de faire est de créer une fonction dans une classe qui encapsule le suivant:

$stmt->bind_param('sssd', $code, $language, $official, $percent);

vous ne pouvez pas le faire sans plus déplaisantes efforts. Je vous suggère soit de créer une requête de manière habituelle, ou de passer à PDO si vous voulez natif des déclarations préparées à tout prix. Ils ont bindValue, vous l'esprit
Merci pour l'info. Malheureusement AOP semble être exagéré, avec encore plus d'effort et passe-partout, comparativement à écrire mes propres choses simples.
Pour les choses simples que vous pouvez utiliser une lib de mon userinfo. C'est très simple.

OriginalL'auteur Ageis | 2009-10-16

arguments php

4

Ci-dessus suggère sont tous bons, mais je ne pense pas qu'elles seront adaptées à votre situation.
```
$stmt->bind_param('sssd', $code, $language, $official, $percent);
```
Si vous souhaitez envelopper cette fonction, vous aurez besoin de passer références à l'origine de l'argument des variables à l'bind_param fonction. Je ne pense pas que func_get_args() vous offre tout cela, il vous donne les valeurs de la place. Ainsi, il ne sera pas possible de les utiliser pour passer à la fonction parente. Je me suis bien battu avec un problème similaire lors de la tentative d'étendre mysqli_stmt et n'a jamais de solution satisfaisante.

Ce n'est pas vraiment une réponse à votre question, j'ai peur, juste un avertissement que d'autres arguments peuvent ne pas fonctionner dans votre application particulière de nombre arbitraire d'arguments.

En effet. La dernière fois que j'ai vérifié (1+ an), il n'y avait aucun moyen pour envelopper/étendre bind_param() parce que func_get_args() ne retournera pas les références.

OriginalL'auteur Rob Tuley
23

Avez-vous pris un coup d'oeil à func_get_args, func_get_arg et func_num_args

Ainsi, par exemple:
```
function foo(){
    if ( func_num_args() > 0 ){
        var_dump(func_get_args());
    }
}
```
ou:
```
function bind_param(){
    if ( func_num_args() <= 1 ){
        return false; //not enough args
    }
    $format = func_get_arg(0)
    $args = array_slice(func_get_args(), 1)

    //etc
}
```
MODIFIER

Concernant Ewan Todds commentaire:

Je n'ai pas de connaissances de l'API de base de la création de l'emballage, mais une autre solution peut être de faire quelque chose avec le chaînage des fonctions de votre interface obtenue ressemble à quelque chose comme:
```
$var->bind()->bindString($code)
            ->bindString($language)
            ->bindString($official)
            ->bindDecimal($percent);
```
Que je préfère sur l'utilisation de func_get_args que le code est probablement plus lisible et plus important encore moins susceptible de provoquer des erreurs dues à l'absence d'une variable de format.

J'utilise func_get_args de temps à autre. Il souffre de ce qui rend difficile de voir en un coup d'oeil ce que la méthode entrées sont. De Plus, il introduit un bloc de cul moche syntaxe dans votre code. Je recommande cette approche que comme un dernier recours. Préférez le Paramètre Objet d'un refactoring.
Je suis d'accord avec vous que c'est une mauvaise façon de faire de variable d'arguments. J'ai ajouté une alternative idée de ma réponse
J'aime bien le "chaînage fonctions" proposition de mieux que de func_get_args. Je sais que cette conception d'une interface FLUIDE. Il est accompli en ayant bindString(), bindDecimal (), etc. faire "return $this;" comme de leur dernière ligne. L'interface FLUIDE est une excellente option pour certains types d'usine.

OriginalL'auteur Yacoby
11

Précédemment, vous devriez avoir utilisé func_get_args(), mais dans le php 5.6, vous pouvez utiliser ... opérateur.

Ainsi, par exemple, vous pouvez écrire une fonction qui retourne une somme de tous les nombres, envoyés à la fonction:
```
function bind_param(...$params){
   var_dump($params);
}
```
Votre params est en fait un tableau de tous les éléments.

OriginalL'auteur Salvador Dali
5

Utilisation func_get_args():
```
function my_func() {
  $args = func_get_args();
  foreach ($args as $arg) {
    echo "Arg: $arg\n";
  }
}
```
Cela ne fonctionne pas si les paramètres ne sont pas définis, et sont ensuite passés par référence, être mis à l'intérieur de la fonction. func_get_args tente d'accéder à la fonction unset variable qui renvoie une erreur.

OriginalL'auteur cletus

Si vous utilisez PHP 5.6 ou version ultérieure, des listes d'arguments peuvent inclure la ... jeton pour indiquer que la fonction accepte un nombre variable d'arguments. Les arguments sera passé dans la variable donnée comme un tableau; tout Simplement à l'Aide de ... vous pouvez bénéficier d'un accès illimité variable d'arguments.

par exemple:

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

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

Si vous utilisez la version de PHP <= 5.5 ensuite, vous pouvez bénéficier d'un accès illimité parameterusing la func_num_args(), func_get_arg(), et func_get_args() fonctions.

Par exemple:

<?php
function foo()
{
    $numargs = func_num_args();
    echo "Number of arguments: $numargs \n";
    if ($numargs >= 2) {
        echo "Second argument is: " . func_get_arg(1) . "\n";
    }
    $arg_list = func_get_args();
    for ($i = 0; $i < $numargs; $i++) {
        echo "Argument $i is: " . $arg_list[$i] . "\n";
    }
}

foo(1, 2, 3);
?>

OriginalL'auteur Faisal

2

À 5 paramètres, cette conception est de commencer à exposer les AntiPattern "Trop De Paramètres". Ceci suggère que le refactoring appelé Paramètre De L'Objet, un objet ou de la structure de données des membres représentant les arguments passés. Toutefois, éviter d'en faire un La Magie Conteneur.

Voir aussi Introduire Le Paramètre De L'Objet refactoring à refactoring.com.

OriginalL'auteur Ewan Todd

Il y a une fonction appelée func_get_args() qui est un tableau de tous les arguments passés à la fonction.

Exemple de PHP.net

function foo()
{
    $numargs = func_num_args();
    echo "Number of arguments: $numargs<br />\n";
    if ($numargs >= 2) {
        echo "Second argument is: " . func_get_arg(1) . "<br />\n";
    }
    $arg_list = func_get_args();
    for ($i = 0; $i < $numargs; $i++) {
        echo "Argument $i is: " . $arg_list[$i] . "<br />\n";
    }
}

foo(1, 2, 3);

L'exemple ci-dessus va afficher:

Nombre d'arguments: 3

Deuxième argument: 2

L'Argument 0 est: 1

L'Argument 1 est: 2

Argument 2: 3

OriginalL'auteur Ólafur Waage

0

Les réponses avec func_get_args() fonctionnera très bien pour les non-paramètres de référence.
Cependant, il y a une astuce pour se passer-par-des paramètres de référence pour le travail.
Aussi, il n'est pas techniquement une fonction qui accepte illimité paramètres, mais simplement d'un nombre arbitrairement grand, disons une centaine de.

Ce que vous pouvez faire est de définir une fonction qui prend un grand nombre d'arguments, et de les avoir par défaut à null.
Puis, à l'intérieur de cette fonction, ajoutez chaque non-nulle référence à un tableau, qui pourrait ensuite être utilisé pour appeler *bind_param()* aide *call_user_func_array()*.
```
function my_bind_param(&$stmt, $types, &$arg1, &$arg2 = null, &$arg3 = null, ...)
{
    $vars = array($types);
    $vars[] = $arg1;

    if ($arg2 != null)
        $vars[] = &$arg2;
    if ($arg3 != null)
        $vars[] = &$arg3;
    ...

    if (!call_user_func_array(array($stmt, "bind_param"), $vars))
    {
        if ($stmt->errno == 0)
            return array(-1, "Unknown error binding parameters.");
        else
            return array(-1, "Binding parameters failed: (" . $stmt->errno . ") " . $stmt->error);
    }

    return array(0, "");
}
```
Le vrai truc, c'est que vous ne voulez pas écrire cette chose à la main.
Juste faire un autre script qui affichera le corps de cette fonction (tout ce qui est entre le squiggle entre parenthèses) *my_bind_param_body.php*.
Ensuite, il suffit de définir l'en-tête de la fonction dans votre fichier principal, et de les inclure dans le corps que la définition de la fonction.
c'est à dire
```
function my_bind_param(&$stmt, $types, &$arg1, &$arg2 = null, &$arg3 = null, ...)
{
    return include "my_bind_param_wrapper_body.php";
}
```
OriginalL'auteur E.T.

Vous devez vous connecter pour publier un commentaire.