Übergeben einer variablen Anzahl von Argumenten an eine PHP-Funktion

Ich habe eine PHP-Funktion, die eine variable Anzahl von Argumenten (mit func_num_args()und func_get_args()) akzeptiert , aber die Anzahl der Argumente, die ich an die Funktion übergeben möchte, hängt von der Länge eines Arrays ab. Gibt es eine Möglichkeit, eine PHP-Funktion mit einer variablen Anzahl von Argumenten aufzurufen ?

Wenn Sie Ihre Argumente in einem Array haben, könnte Sie die call_user_func_arrayFunktion interessieren .

Wenn die Anzahl der Argumente, die Sie übergeben möchten, von der Länge eines Arrays abhängt, bedeutet dies wahrscheinlich, dass Sie sie selbst in ein Array packen können - und dieses für den zweiten Parameter von verwenden können call_user_func_array.

Elemente dieses Arrays, die Sie übergeben, werden dann von Ihrer Funktion als eindeutige Parameter empfangen.

Zum Beispiel, wenn Sie diese Funktion haben:

function test() {
  var_dump(func_num_args());
  var_dump(func_get_args());
}

Sie können Ihre Parameter wie folgt in ein Array packen:

$params = array(
  10,
  'glop',
  'test',
);

Rufen Sie dann die Funktion auf:

call_user_func_array('test', $params);

Dieser Code gibt die Ausgabe aus:

int 3

array
  0 => int 10
  1 => string 'glop' (length=4)
  2 => string 'test' (length=4)

dh 3 Parameter; genau wie die Funktion wurde so genannt:

test(10, 'glop', 'test');

Dies ist jetzt mit PHP 5.6.x unter Verwendung des Operators ... möglich (in einigen Sprachen auch als Splat-Operator bezeichnet):

Beispiel:

function addDateIntervalsToDateTime( DateTime $dt, DateInterval ...$intervals )
{
    foreach ( $intervals as $interval ) {
        $dt->add( $interval );
    }
    return $dt;
}

addDateIntervaslToDateTime( new DateTime, new DateInterval( 'P1D' ), 
        new DateInterval( 'P4D' ), new DateInterval( 'P10D' ) );

In einem neuen Php 5.6 können Sie ... operatoranstelle von verwenden func_get_args().

Auf diese Weise können Sie alle Parameter abrufen, die Sie übergeben:

function manyVars(...$params) {
   var_dump($params);
}

Seit PHP 5.6 kann mit dem ...Operator eine variable Argumentliste angegeben werden.

function do_something($first, ...$all_the_others)
{
    var_dump($first);
    var_dump($all_the_others);
}

do_something('this goes in first', 2, 3, 4, 5);

#> string(18) "this goes in first"
#>
#> array(4) {
#>   [0]=>
#>   int(2)
#>   [1]=>
#>   int(3)
#>   [2]=>
#>   int(4)
#>   [3]=>
#>   int(5)
#> }

Wie Sie sehen können, ...sammelt der Operator die variable Liste der Argumente in einem Array.

Wenn Sie die Variablenargumente an eine andere Funktion übergeben müssen, ...kann Ihnen das trotzdem helfen.

function do_something($first, ...$all_the_others)
{
    do_something_else($first, ...$all_the_others);
    // Which is translated to:
    // do_something_else('this goes in first', 2, 3, 4, 5);
}

Seit PHP 7 kann die variable Liste von Argumenten gezwungen werden , sein alle vom gleichen Typ zu.

function do_something($first, int ...$all_the_others) { /**/ }

Für diejenigen, die nach einer Möglichkeit suchen, dies zu tun mit $object->method:

call_user_func_array(array($object, 'method_name'), $array);

Dies gelang mir in einer Konstruktfunktion, die eine Variable method_name mit variablen Parametern aufruft.

Sie können es einfach nennen.

function test(){        
     print_r(func_get_args());
}

test("blah");
test("blah","blah");

Ausgabe:

Array ([0] => bla) Array ([0] => bla [1] => bla)

Ich bin überrascht, dass niemand hier erwähnt hat, einfach ein Array zu übergeben und zu extrahieren . Z.B:

function add($arr){
    extract($arr, EXTR_REFS);
    return $one+$two;
}
$one = 1;
$two = 2;
echo add(compact('one', 'two')); // 3

Dies bietet natürlich keine Argumentvalidierung . Dafür kann jeder meine Erwartungsfunktion verwenden: https://gist.github.com/iautomation/8063fc78e9508ed427d5

Eine alte Frage, ich weiß, aber keine der Antworten hier ist wirklich gut darin, einfach die Frage zu beantworten.

Ich habe gerade mit PHP herumgespielt und die Lösung sieht so aus:

function myFunction($requiredArgument, $optionalArgument = "default"){
   echo $requiredArgument . $optionalArgument;
}

Diese Funktion kann zwei Dinge tun:

Wenn es nur mit dem erforderlichen Parameter aufgerufen wird: myFunction("Hi") Es wird "Hi default" ausgegeben.

Aber wenn es mit dem optionalen Parameter aufgerufen wird: myFunction("Hi","me") Es wird "Hi me" ausgegeben;

Ich hoffe, das hilft jedem, der dies später sucht.

Hier ist eine Lösung mit der magischen Methode __invoke

(Verfügbar seit PHP 5.3)

class Foo {
    public function __invoke($method=null, $args=[]){
        if($method){
            return call_user_func_array([$this, $method], $args);
        }
        return false;
    }

    public function methodName($arg1, $arg2, $arg3){

    }
}

Aus derselben Klasse:

$this('methodName', ['arg1', 'arg2', 'arg3']);

Aus einer Instanz eines Objekts:

$obj = new Foo;
$obj('methodName', ['arg1', 'arg2', 'arg3'])