func_get_args

(PHP 4, PHP 5, PHP 7, PHP 8)

func_get_args — İşleve aktarılan bağımsız değişkenlerin listesini dizi olarak döndürür

Açıklama

func_get_args(): array

İşlevin bağımsız değişken listesini bir dizi olarak döndürür.

Bu işlev kullanıcı tanımlı işlevlerin değişken sayıda bağımsız değişken kabul edebilmesini sağlamak için func_get_arg() ve func_num_args() ile birlikte kullanılabilir.

Bağımsız Değişkenler

Bu işlevin bağımsız değişkeni yoktur.

Dönen Değerler

Her elemanı, mevcut kullanıcı tanımlı işlevin bağımsız değişken listesinin birer kopyası olan bir dizi döndürür.

Hatalar/İstisnalar

Eğer kullanıcı tanımlı işlevin dışından çağrılırsa uyarı oluşturur.

Örnekler

Örnek 1 - func_get_args() örneği

<?php
function işlev()
{
    $dğşsayısı = func_num_args();
    echo "Bağımsız değişken sayısı: $dğşsayısı\n";
    if ($dğşsayısı >= 2) {
        echo "İkinci bağımsız değişken: " . func_get_arg(1) . "\n";
    }
    $dğş_listesi = func_get_args();
    for ($i = 0; $i < $dğşsayısı; $i++) {
        echo "$i. bağımsız değişken: " . $dğş_listesi[$i] . "\n";
    }
}

işlev(1, 2, 3);
?>

Yukarıdaki örneğin çıktısı:

Bağımsız değişken sayısı: 3
İkinci bağımsız değişken: 2
0. bağımsız değişken: 1
1. bağımsız değişken: 2
2. bağımsız değişken: 3

Örnek 2 - byref ve byval bağımsız değişkenli func_get_args()

<?php
function byVal($arg) {
    echo 'Aktarılan  : ', var_export(func_get_args()), PHP_EOL;
    $arg = 'baz';
    echo 'Değişen    : ', var_export(func_get_args()), PHP_EOL;
}

function byRef(&$arg) {
    echo 'Aktarılan  : ', var_export(func_get_args()), PHP_EOL;
    $arg = 'baz';
    echo 'Değişen    : ', var_export(func_get_args()), PHP_EOL;
}

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

Yukarıdaki örneğin çıktısı:

Aktarılan : array (
0 => 'bar',
)
Değişen : array (
0 => 'baz',
)
Aktarılan : array (
0 => 'bar',
)
Değişen : array (
0 => 'baz',
)

Notlar

Bilginize:
PHP 8.0.0 itibariyle, func_*() işlev ailesindeki işlevlerin tüm bağımsız değişkenlerinin konumsal olarak iletiliyormuş gibi ele alınması ve eksik bağımsız değişkenlerin öntanımlıları ile değiştirilmesi yoluyla, isimli bağımsız değişkenler açısından çoğunlukla şeffaf olması amaçlanmıştır. Bu işlev, değişken sayıda bağımsız değişken aktarımında ismi bilinmeyen isimli bağımsız değişkenlerin tümünü yok sayar. Toplanan bilinmeyen isimli bağımsız değişkenlere yalnızca variadic bağımsız değişkeni aracılığıyla erişilebilir.

Bilginize:
Bağımsız değişkenlerin gönderime göre aktarılması halinde, bağımsız değişkenlerdeki değişiklikler bu işlevin döndürdüğü değerlere yansıtılır. PHP 7 ve sonrasında, bağımsız değişkenler değerleriyle aktarılmışsa ayrıca geçerli değerler de döndürülür.

Bilginize: Bu işlev sadece işleve aktarılan bağımsız değişkenleri döndürür ve öntanımlı (aktarılmayan) bağımsız değişkenleri hesaba katmaz.

Ayrıca Bakınız

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