func_get_args

(PHP 4, PHP 5, PHP 7)

func_get_args — Returns an array comprising a function's argument list

설명

array func_get_args ( void )

Gets an array of the function's argument list.

This function may be used in conjunction with func_get_arg() and func_num_args() to allow user-defined functions to accept variable-length argument lists.

반환값

Returns an array in which each element is a copy of the corresponding member of the current user-defined function's argument list.

변경점

버전	설명
5.3.0	This function can now be used in parameter lists.
5.3.0	If this function is called from the outermost scope of a file which has been included by calling include or require from within a function in the calling file, it now generates a warning and returns `FALSE`.

오류/예외

Generates a warning if called from outside of a user-defined function.

예제

Example #1 func_get_args() example


<?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);
?>

위 예제의 출력:

Number of arguments: 3 
Second argument is: 2
Argument 0 is: 1
Argument 1 is: 2
Argument 2 is: 3

Example #2 func_get_args() example before and after PHP 5.3


test.php
<?php
function foo() {
    include './fga.inc';
}

foo('First arg', 'Second arg');
?>

fga.inc
<?php

$args = func_get_args();
var_export($args);

?>

Output previous to PHP 5.3:

array (
  0 => 'First arg',
  1 => 'Second arg',
)

Output in PHP 5.3 and later:

Warning: func_get_args():  Called from the global scope - no function
context in /home/torben/Desktop/code/ml/fga.inc on line 3
false

Example #3 func_get_args() example of byref and byval arguments


<?php
function byVal($arg) {
    echo 'As passed     : ', var_export(func_get_args()), PHP_EOL;
    $arg = 'baz';
    echo 'After change  : ', var_export(func_get_args()), PHP_EOL;
}

function byRef(&$arg) {
    echo 'As passed     : ', var_export(func_get_args()), PHP_EOL;
    $arg = 'baz';
    echo 'After change  : ', var_export(func_get_args()), PHP_EOL;
}

$arg = 'bar';
byVal($arg);
byRef($arg);
?>

Output of the above example in PHP 7:

As passed : array (
0 => 'bar',
)
After change : array (
0 => 'baz',
)
As passed : array (
0 => 'bar',
)
After change : array (
0 => 'baz',
)

Output of the above example in PHP 5:

As passed : array (
0 => 'bar',
)
After change : array (
0 => 'bar',
)
As passed : array (
0 => 'bar',
)
After change : array (
0 => 'baz',
)

주의

Note:
이 함수는 인수를 현재 영역(scope)에 의존하기 때문에, 함수의 인수로 사용할 수 없습니다. 이 값을 함수에 넘겨야 한다면, 결과값을 변수에 할당하여 그 변수로 넘겨야 합니다.

Note:
인수가 참조로 전달되면, 인수에 대한 변화는 이 함수가 반환하는 값에 영향을 줍니다.

Note: This function returns a copy of the passed arguments only, and does not account for default (non-passed) arguments.

참고

add a note

User Contributed Notes 12 notes

down

T.M. ¶

20 years ago


Simple function to calculate average value using dynamic arguments:
<?php
function average(){
    return array_sum(func_get_args())/func_num_args();
}
print average(10, 15, 20, 25); // 17.5
?>

down

cobrattila at gmail dot com ¶

5 years ago


If you want to get the arguments by reference, instead of func_get_args() you can simply use

<?php
function args_byref(&...$args) {
    // Modify the $args array here
}
?>

Credits should go to Markus Malkusch for pointing this out on Stackoverflow.
https://stackoverflow.com/a/29181826/1426064

down

anderson at francotecnologia dot com ¶

16 years ago


How to create a polymorphic/"overloaded" function

<?php
function select()
{
    $t = '';
    $args = func_get_args();
    foreach ($args as &$a) {
        $t .= gettype($a) . '|';
        $a = mysql_real_escape_string($a);
    }
    if ($t != '') {
        $t = substr($t, 0, - 1);
    }
    $sql = '';
    switch ($t) {
        case 'integer':
            // search by ID
            $sql = "id = {$args[0]}";
            break;
        case 'string':
            // search by name
            $sql = "name LIKE '%{$args[0]}%'";
            break;
        case 'string|integer':
            // search by name AND status
            $sql = "name LIKE '%{$args[0]}%' AND status = {$args[1]}";
            break;
        case 'string|integer|integer':
            // search by name with limit
            $sql = "name LIKE '%{$args[0]}%' LIMIT {$args[1]},{$args[2]}";
            break;
        default:
            // :P
            $sql = '1 = 2';
    }
    return mysql_query('SELECT * FROM table WHERE ' . $sql);
}
$res = select(29); // by ID
$res = select('Anderson'); // by name
$res = select('Anderson', 1); // by name and status
$res = select('Anderson', 0, 5); // by name with limit
?>

down

foxkeys at gmail dot com ¶

8 years ago


Merge func_get_args() with function defaults
<?php
class utils {
  /**
   * @param mixed[] $args
   * @param ReflectionMethod $reflectionMethod
   *
   * @return array
   */
  public static function mergeArgsWithDefaults( $args, \ReflectionMethod $reflectionMethod ) {
    foreach ( array_slice( $reflectionMethod->getParameters(), count( $args ) ) as $param ) {
      /**
       * @var ReflectionParameter $param
       */
      $args[] = $param->getDefaultValue();
    }
    return $args;
  }
}

class  sampleParent {
  const USER_FILE_TYPE_FILE = 'FILE';
  public function select( $idUserFile = null, $idUserFileType = self::USER_FILE_TYPE_FILE ) {
    echo '[$idUserFile=>' . $idUserFile . ', $idUserFileType=>' . $idUserFileType, ']<br/>' . PHP_EOL;
  }
}

class sample extends sampleParent {
  const USER_FILE_TYPE_IMG = 'IMG';
  public function select( $idUserFile = null, $idUserFileType = self::USER_FILE_TYPE_IMG ) {
    return call_user_func_array( 'parent::select', \utils::mergeArgsWithDefaults( func_get_args(), new ReflectionMethod( __CLASS__, __FUNCTION__ ) ) );
  }
}

$sample1 = new sampleParent();
$sample1->select();//Prints "" / self::USER_FILE_TYPE_FILE
$sample1->select(1);//Prints 1 / self::USER_FILE_TYPE_FILE
$sample1->select(2, 'test 1');//Prints 2 / "test 1"
echo '<br/>' . PHP_EOL;
$sample2 = new sample();
$sample2->select();//Prints "" / self::USER_FILE_TYPE_IMG
$sample2->select(3);//Prints 3 / self::USER_FILE_TYPE_IMG
$sample2->select(4, 'test 2');//Prints 4 / "test 2"
?>

down

OpenTechnologist ¶

12 years ago


please note that optional parameters are not seen/passed by func_get_args(), as well as func_get_arg().



ex:



<?php

function testfunc($optional = 'this argument is optional..') {

    $args = func_get_args();

    var_dump($args);

    echo $optional;

}

?>



test case #1:

testfunc('argument no longer optional..');



result for #1:

array(1) {

    [0]=>  string(20) "argument no longer optional.."

}

argument no longer optional..



test case #2:

testfunc('argument no longer optional..','this is an extra argument');



result for #2:

array(2) {

    [0]=>  string(29) "argument no longer optional.."

    [1]=>  string(25) "this is an extra argument"

}

argument no longer optional..



test case #3: -- RESULTS IN AN EMPTY ARRAY

testfunc();



result for #3:

array(0) {

}

this argument is optional..

down

daveNO at ovumSPAMdesign dot com ¶

23 years ago


<?php

// How to simulate named parameters in PHP.

// By Dave Benjamin <dave@ovumdesign.com>



// Turns the array returned by func_get_args() into an array of name/value

// pairs that can be processed by extract().

function varargs($args) {

    $count = count($args);

    for ($i = 0; $i < $count; $i += 2) {

        $result[$args[$i]] = $args[$i + 1];

    }

    

    return $result;

}



// Example

function test(&$ref1, &$ref2) {

    // Default arguments go here.

    $foo = "oof";

    

    // Do some magic.

    extract(varargs(func_get_args()));



    echo nl2br("\n\$var1 = $var1");

    echo nl2br("\n\$var2 = $var2");

    echo nl2br("\n\$foo = $foo\n\n");

    

    // Modify some variables that were passed by reference.

    // Note that func_get_args() doesn't pass references, so they

    // need to be explicitly declared in the function definition.

    $ref1 = 42;

    $ref2 = 84;

}



$a = 5;

$b = 6;



echo nl2br("Before calling test(): \$a = $a\n");

echo nl2br("Before calling test(): \$b = $b\n");



// Try removing the 'foo, "bar"' from the following line.

test($a, $b, var1, "abc", var2, "def", foo, "bar");



echo nl2br("After calling test(): \$a = $a\n");

echo nl2br("After calling test(): \$b = $b\n");

?>

down

mitko at edabg dot com ¶

15 years ago


<?php
/*
This example demonstrate how to use unknown variable arguments by reference.
func_get_args() don't return arguments by reference, but 
debug_backtrace() "args" is by reference.
In PHP 5 this have no particular sense, because calling with arguments by reference
is depreciated and produce warning.
*/

class foo {

    var $bar = "default bar";
    
    function foo(/*variable arguments*/) {
// func_get_args returns copy of arguments
//        $args = func_get_args();
// debug_backtrace returns arguments by reference            
        $stack = debug_backtrace();
        $args = array();
        if (isset($stack[0]["args"]))
            for($i=0; $i < count($stack[0]["args"]); $i++)
                $args[$i] = & $stack[0]["args"][$i];
        call_user_func_array(array(&$this, 'bar'), $args);
    }
    

    function bar($bar = NULL) {
        if (isset($bar))
            $this->bar = & $bar; 
    }
}

$global_bar = "bar global";
$foo = & new foo();
echo "foo->bar:    ".$foo->bar."</br>\n";
$foo->bar = "new bar";
echo "global_bar:  ".$global_bar."</br>\n";
/*
Result:
foo->bar:    default bar</br>
global_bar:  bar global</br>
*/

$foo = & new foo(&$global_bar);
echo "foo->bar:    ".$foo->bar."</br>\n";
$foo->bar = "new bar";
echo "global_bar:  ".$global_bar."</br>\n";
/*
Result:
foo->bar:    bar global</br>
global_bar:  new bar</br>
*/

?>

down

hans at loltek dot net ¶

1 year ago


I wanted an associative list of arguments, in case some else does too, I'm leaving it here.

I hope PHP gets native support for this, because a core implementation would be faster than this userland backtrace+reflection implementation:
<?php

/**
 * Get function arguments as associative array
 * (same as func_get_args() but with keys)
 * 
 * @param bool $populateMissingArgumentsWithDefaults whether to populate the array with default values for missing arguments
 * 
 * @return array
 */
function func_get_args_associative(bool $populateMissingArgumentsWithDefaults = false): array
{
    $trace = debug_backtrace(0, 2)[1];
    $reflection = null;
    if (isset($trace['class'])) {
        $reflection = new \ReflectionMethod($trace['class'], $trace['function']);
    } else {
        $reflection = new \ReflectionFunction($trace['function']);
    }
    $ret = [];
    foreach ($reflection->getParameters() as $param) {
        if (array_key_exists($param->getPosition(), $trace['args'])) {
            $ret[$param->name] = $trace['args'][$param->getPosition()];
        } elseif ($populateMissingArgumentsWithDefaults) {
            // because of the "required arguments declared after an optional argument are implicitly required" rule:
            assert($param->isDefaultValueAvailable(), "i think all params are either in trace[args] or have default values");
            $ret[$param->name] = $param->getDefaultValue();
        }
    }
    return $ret;
}
?>

down

art at geigel dot com ¶

1 year ago


The size of the array resulting from func_get_args(), for instance using count(), does not take into account parameters that have been assigned default values in the function definition.

Example:

function foo($bar=true) {
     echo count(func_get_args());
}

foo(); 
// echoes 0

foo("bar"); 
// echoes 1

A useful condition to test for when a function needs to return default behavior (whatever that might be) when no value is present and the value of $bar could be true, false, null, etc.

down

maarten at ba dot be ¶

12 years ago


it seems that this function only returns a copy and loses it's byref information, use this dirty non-efficient workaround instead:

at the moment of writing it currently returns all of them as references, instead of only the ones who are passed that way...

<?php
function func_get_args_byref() {
        $trace = debug_backtrace();
        return $trace[1]['args'];
}
?>

down

ario [a] mail [dot] utexas [dot] edu ¶

17 years ago


"Because this function depends on the current scope to determine parameter details, it cannot be used as a function parameter. If you must pass this value, assign the results to a variable, and pass the variable."

This means that the following code generates an error:

<?php

function foo($list)
{
  echo implode(', ', $list);
}

function foo2()
{
  foo(func_get_args());
}

foo2(1, 2, 3);

?>

However, you can easily get around this by doing the following:

<?php

function foo($list)
{
  echo implode(', ', $list);
}

function foo2()
{
  foo($args = func_get_args());
}

foo2(1, 2, 3);

?>

This captures the context from foo2(), making this legal.  You get the expected output:

"1, 2, 3"

down

Anonymous ¶

23 years ago


You can pass a variable number of arguments to a function whilst keeping references intact by using an array. The disadvantage of course, is that the called function needs to be aware that it's arguments are in an array.



<?php

// Prints "hello mutated world"

function mutator($args=null) {

$n=count($args);

while($i<$n) $args[$i++] = "mutated";

}

$a = "hello";

$b = "strange";

$c = "world";

mutator(array($a, &$b, $c));

echo "$a $b $c";

?>

add a note