func_get_args

maarten at ba dot be (2012-09-13 11:58:56)

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'];
}
?>

Pyetro Costa (PySafe) Brazil-SP (2012-04-26 18:17:52)

In this example, we try to show how to assign the value of the arguments for the variables dynamically and why only works this way.
We will see how to work with get_class_vars () and func_get_args (). We can see that when assign to the class variables to an array that keys of this array are of type string,
for it the array keys are the names of variables, thus we could not use a numeric index to access elements of this array. To enable access to these elements we must first transform the array keys in numeric index keys, then we can work with the use of indexes.

<?
// Creates a Class 
class foo {
  // Define varibles 
  private $a='01', $b='02', $c='03';

  // Creates the constructor with a single required argument 
  function __construct($a) {

    // Sets the argument value to variable 
    $this->a=$a;

    // Count how many arguments were passed 
    $nArgs = func_num_args();

    // Run if number of arguments is greater than one 
    if($nArgs>1) {
      // Creates an array with the class variables 
      $cVars = get_class_vars(__CLASS__);
      // The array keys are the name of class variables 
      var_dump($cVars); // array(3) { ["a"]=> string(2) "01" ["b"]=> string(2) "02" ["c"]=> string(2) "03" } 

      // Show value of array elements 
      echo '<br> => '.$cVars[0]; // => null
      echo '<br> => '.$cVars[a]; // => 01

      // Show value of class variables by reference of $this 
      echo '<br> => '.$this->{1}; // => null
      echo '<br> => '.$this->{b}; // => 02

      // Show value by reference $this with array $cVars 
      echo '<br> => '.$this->$cVars[2]; // => Show a error: "Fatal error: Cannot access empty property in C:\..." Because this array element not exist
      echo '<br> => '.$this->$cVars['a']; // => null // Because "$cvars[a]" was set to a value and not a reference to class variable

      // Changes the array, the values given the keys and the keys change to numeric index
      $cVars = array_keys($cVars);

      // Now, the array elements are a reference to the class variable and can be accessed by an index
      echo '<br><br>';
      var_dump($cVars); // array(3) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" }

      // First prints the default value of the class variables and then the value assigned by the argument
      reset($cVars);
      for($i=1; $i<$nArgs; $i++) {
          $str .= '<br> Index:'.$i.',   key ['.current($cVars).'] => '.$this->$cVars[$i].',   Arg('.$i.') == '.func_get_arg($i);
          $this->$cVars[$i]=func_get_arg($i);
          $str .= '<br> Index:'.$i.',   key['.current($cVars).'] => '.$this->$cVars[$i].',   Arg('.$i.') == '.func_get_arg($i);
        next($cVars);
      }
      echo '<br>'.nl2br($str).'<br><br>';
    }
    print_r($this);
  }
}

new foo('alpha',12345,'charlie');
?>

Now we can see below the same content over briefly.

<?
class test {
  private $a='01', $b='02', $c='03';

  function __construct($a) {
    $this->a=$a;
    $nArgs = func_num_args();
    if($nArgs>1) {
      $cVars = get_class_vars(__CLASS__);
      $cVars = array_keys($cVars);

      for($i=1; $i<$nArgs; $i++)
        $this->$cVars[$i]=func_get_arg($i);

      echo $this->a.', '.$this->b.', '.$this->c;
    }
  }
}

$foo = new test('alpha',12345,'charlie');
?>

OpenTechnologist (2011-12-30 19:54:08)

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..

red (2011-10-13 13:16:45)

I had to pass variable length arguments from one function to another. It seems the only way of doing this is to use call_user_func_array.

<?php

function query(/*query [, $arg1...$argN]*/){
    $query  = call_user_func_array('replaceAndClean', func_get_args());
    $result = mysql_query($query);
    return $result;
}

function replaceAndClean(/*query [, $arg1...$argN]*/){
   $args = func_get_args();
   if(count($args) == 1){
       return $args[0];
   }
   $query = array_shift($args);
   return vsprintf($query, array_map('mysql_real_escape_string', $args));
}

?>

Example:

<?php

// unsave call
query("SELECT FROM foo where bar='".$_POST['bar']."'");

// save call
query("SELECT FROM foo where bar='%d'", $_POST['bar']);

?>

pBakhuis at Gmail dot com (2011-10-05 05:30:13)

Please note that you can't use this for recursive functions as you can't pass the parameters to the function again as then they'll be in the form of an array.

mulllhausen (2011-04-05 19:49:06)

i use this structure a lot for debugging. i always place the call to 'debugfunc' at the start of any function which i want to debug. the square brackets in the echod output are useful to see if there is accidental whitespace within string variables passed to anyfunc. if anyone can suggest a better way of passing the names of the arguments to debugfunc i would appreciate it. as it is works fine, but its not very universal...

<?php
anyfunc('val1','val2','val3');

function anyfunc($arg1, $arg2, $arg3)
{
    debugfunc(__FUNCTION__, '$arg1, $arg2, $arg3', func_get_args());
    /*do useful non-debugging stuff*/
}
function debugfunc($name, $arg_names, $arg_vals)
{
    echo "begin function [$name]. ";
    $arg_names_array = explode(',', $arg_names);
    foreach($arg_names_array as $k => $v)
    {
        $v = trim($v);
        echo "$v: [$arg_vals[$k]] ";
    }
    echo "\n";
}

//output:
//begin function [anyfunc]. $arg1: [val1] $arg2: [val2] $arg3: [val3]
?>

mitko at edabg dot com (2009-04-06 03:48:45)

<?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>
*/

?>

marco @ vi-da (2009-03-20 13:01:38)

sanitazes vars

<?php
function mysql_safe($q) {
    $x = array_shift(func_get_args());
    return vsprintf(preg_replace('/%([1-9]):(d|s)/','%$1$$2',$q), array_map('mysql_escape_string',$x));
}
?>

example

<?php
$query = mysql_safe("select * from somewhere where mood = %2:s and some_id = %1:d order by %3:s desc", $id, 'happy', $order);
?>

Oto Brglez (2009-03-12 06:18:44)

How to create simple sum function that can sum N arguments. Like this:

<?php

function sum(){
    $s=0;
    foreach(func_get_args() as $a) $s+= is_numeric($a)?$a:0;
    return $s;
};

print sum(1,2,3,4,5,6); // will return 21
print sum(3,2,1); // will return 6
print sum(false,array(),5,5); // will return 10

?>

anderson at francotecnologia dot com (2008-08-26 23:25:58)

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

kangaroo232002 at yahoo dot co dot uk (2008-08-26 14:25:23)

Instead of having to define your arg list twice, and keeping to the good style of initialising your variables in the head of your class, you can use (PHP5):

<?php
class myclass {
     public $value = null;
    public $key = null;
    public $column = null;
    public $table = null;
    public function __construct() {
        $vars = get_class_vars();
        for($i=0; $i<func_num_args();$i++) {
            $this->${$vars[$i]}=func_get_arg($i);
        }
    }
}
?>

which should allow you to set variables while retaining their default values if they are not set (in this case, null), without having to mess around with functions to retain default values so is much neater (just don't change the order you declare your vars!)

<?php
//usage
$c = new myclass("value", "tablekey", "tablecol", "table");
echo $c->key;
//prints 'tablekey'
?>

Anonymous (2008-01-28 20:11:49)

I use the following concept for quick "plugin" of multiple argument support.

<?php

function increment($n) {
  $p = func_get_args();
  if (count($p) > 1) {
    return array_map(__FUNCTION__, $p);
  }
  $n =& $p[0];
  
  return ++$n;
}

list($two, $three, $four) = increment(1,2,3);

?>

tristan dot colombo at laposte dot net (2007-10-18 01:03:28)

In order to use the function 'func_get_args()' to instanciate differents type of objects, you must use the Reflection API.
By example, we have two different classes and we want to have an unique function (using an unfixed number of parameters) to create the objects. We create two classes 'a' and 'b' where constructors accept different numbers of arguments.
Class a (class/a.class.php):
<?php
  include_once 'a.class.php';

  class b extends a
  {
    private $param3;

    public function __construct($a, $b, $c)
    {
      $this->param1 = $a;
      $this->param2 = $b;
      $this->param3 = $c;
    }

    public function display()
    {
      echo $this->param1 . ', ' . $this->param2 . ' and ' . $this->param3 . '!<br />';
    }
  }
?>

Class b (class/b.class.php):
<?php

  class a
  {
    private $param1;
    private $param2;

    public function __construct($a, $b)
    {
      $this->param1 = $a;
      $this->param2 = $b;
    }

    public function display()
    {
      echo $this->param1 . ' and ' . $this->param2 . '<br />';
    }
  }
?>

Main program :
<?php

  function classFactory()
  {
    // Retrieve arguments list
    $_args = func_get_args();
    // Delete the first argument which is the class name
    $_className = array_shift($_args);

    // Include the requested class
    include_once 'class/' . $_className . '.class.php';

    // Create Reflection object
    // See : http://www.php.net/manual/en/language.oop5.reflection.php
    $_reflection = new ReflectionClass($_className);

    // Use the Reflection API
    return $_reflection->newInstanceArgs($_args);
  }

  $a = classFactory('a', 'hello', 'world');
  $b = classFactory('b', 'that\'s', 'all', 'folks');

  $a->display();
  $b->display();

?>

Sinured (2007-08-20 05:38:35)

It may seem obvious, but if you want your variadic function to at least require one parameter, you can do this instead of checking func_num_args() == 0, which I've seen often:

<?php
function variadic($dummy) {
    $args = func_get_args();
    foreach ($args as $arg) {
        echo "$arg<br />\n";
    }
}
?>

func_get_args() fetches ALL passed parameters, not only those that weren't copied to a local variable.

ario [a] mail [dot] utexas [dot] edu (2007-05-07 14:50:58)

"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"

jmcguire81 [at] gmail.com (2007-03-21 14:13:16)

Here is another variation on accepting a variable number of arguments. This allows for a variable number of arguments to be passed to a Class constructor, as well as a customized class version to be used dynamically. Syntax in code is:

<?php
$mail = Generator("MailClassName", $db_ref);

function Generator() {

   $numargs = func_num_args();

   $classname = func_get_arg(0);
   $argstring='';
   if ($numargs > 1) {
      $arg_list = func_get_args();

      for ($x=1; $x<$numargs; $x++) {
         $argstring .= '$arg_list['.$x.']';
         if ($x != $numargs-1) $argstring .= ',';
      }
   }

   if (class_exists("Custom{$classname}")) {
      $classname = "Custom{$classname}";
      if ($argstring) return eval("return new $classname($argstring);");
      return new $classname;
   }
   
   if ($argstring) return eval("return new $classname($argstring);");
   return new $classname;
}
?>

Hope this is of use to someone.

rafagd at gmail dot com (2007-02-13 08:53:08)

Sometimes, you may need to dynamic set and get of args...

This function merge array args, so you can dynamic set some args by sending an array arg.

<?php
  function dynamicArgs(/*$arg1, $arg2...$argN*/) {
    $args = func_get_args(); $num  = func_num_args();
    for ($i = 1; $i < $num; $i++) {
      $args[0] = array_merge((array) $args[0], (array) $args[$i]);
    }
    return $args[0];
  }
  
  var_dump(dynamicArgs('a',array('b','c'),'d',1);
?>

This should output like:

array(5) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [2]=>
  string(1) "c"
  [3]=>
  string(1) "d"
  [4]=>
  int(1)
}

bew (2006-03-31 07:55:18)

A more concise way of expressing my idea from the previous post (I'd forgotten about array_slice()):

<?php
function func_get_default_args($a) {
    $args = array_slice(func_get_args(), 1);
    return array_merge($args, array_slice($a, sizeof($args)));
}

function foo($a = 1, $b = 2, $c = 3) {
    print_r(func_get_default_args(func_get_args(), $a, $b, $c));
}

// prints: Array ( [0] => a [1] => b [2] => 3 )
foo('a', 'b');
?>

Nathan Ostgard (2005-12-06 10:14:17)

If you're using PHP5, the variable number of argument functions all return the objects by reference - and not a copy of the object, as this leads you to believe.

T.M. (2004-11-04 07:24:33)

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

volte6 at drunkduck dot com (2004-09-30 14:54:10)

For those who have a use for a C style enum() function:

<?php
//*******************************************
// void enum();
// enumerates constants for unique values guarenteed.
function enum()
{
  $i=0;
  $ARG_ARR = func_get_args();
  if (is_array($ARG_ARR))
  {
    foreach ($ARG_ARR as $CONSTANT)
    {
      define ($CONSTANT, ++$i);
    }
  }
}

// USAGE:
enum(ERR_USER_EXISTS, ERR_OLD_POST);

// etc. etc.
//*******************************************
?>


this can be used for error codes etc.
I deliberately skipped the 0 (zero) define, which could be useful for error checking.

mark at manngo dot net (2003-03-23 23:13:36)

You can also fake named arguments using eval:

<?php
function test()
{   foreach (func_get_args() as $k=>$arg) eval ("\$$arg;");
    echo "$a plus $b gives ".($a+$b);
}

test("a=3","b=4");
?>

daveNO at ovumSPAMdesign dot com (2001-09-17 23:29:10)

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

(2001-06-04 07:44:31)

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