Which of the following PHP functions accepts any number of parameters

Question

If you are using PHP 7 and func_num_args is in your base class which you extended, you can pass your arguments with the 'spat' operator.

Table of Contents Show

Passing arguments by reference
Default argument values
Variable-length argument lists
Named Arguments
Which PHP function accepts any number of parameters?
What is PHP function with parameters?
Which PHP function is used to find number of parameters passed to the function?
Which functions used for variable parameters in PHP?

class Sql {

public function doGetWhere(...$args) {

$num_args = func_num_args(); $args_list = func_get_args();

echo '

';
      var_dump($args_list);
      echo '';
  }
}class Member extends Sql {
public function getWhere(...$args) {
   $this->doGetWhere(...$args);
      }
}
$member = new Member();
$member->getWhere('first_name','last_name','userlevel','email','where','email','=',$sub_email);However, take note that if you 'new up' the 'Sql' class in your 'Member' class above, instead of extending it, you will not need to pass your arguments as a variable. Just my two cents. -Bruce tong
 Information may be passed to functions via the argument list, which is a comma-delimited list of expressions. The arguments are evaluated from left to right, before the function is actually called (eager evaluation).
PHP supports passing arguments by value (the default), , and .  and  are also supported.
Example #1 Passing arrays to functions
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>
As of PHP 8.0.0, the list of function arguments may include a trailing comma, which will be ignored. That is particularly useful in cases where the list of arguments is long or contains long variable names, making it convenient to list arguments vertically.
Example #2 Function Argument List with trailing Comma
function takes_many_args(
$first_arg,
$second_arg,
$a_very_long_argument_name,
$arg_with_default = 5,
$again = 'a default string', // This trailing comma was not permitted before 8.0.0.
)
{
// ...
}
?>
Passing arguments by reference
By default, function arguments are passed by value (so that if the value of the argument within the function is changed, it does not get changed outside of the function). To allow a function to modify its arguments, they must be passed by reference.
To have an argument to a function always passed by reference, prepend an ampersand (&) to the argument name in the function definition:
Example #3 Passing function parameters by reference
function add_some_extra(&$string)
{
$string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str; // outputs 'This is a string, and something extra.'
?>
It is an error to pass a value as argument which is supposed to be passed by reference.
Default argument values
A function may define default values for arguments using syntax similar to assigning a variable. The default is used only when the parameter is not specified; in particular, note that passing null does not assign the default value.
Example #4 Use of default parameters in functions



function makecoffee($type = "cappuccino")
{
return "Making a cup of $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>
The above example will output:
Making a cup of cappuccino.
Making a cup of .
Making a cup of espresso.
Default parameter values may be scalar values, arrays, the special type null, and as of PHP 8.1.0, objects using the  syntax.
Example #5 Using non-scalar types as default values
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
1
Example #6 Using objects as default values (as of PHP 8.1.0)
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
2
The default value must be a constant expression, not (for example) a variable, a class member or a function call.
Note that any optional arguments should be specified after any required arguments, otherwise they cannot be omitted from calls. Consider the following example:
Example #7 Incorrect usage of default function arguments
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
3
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
4
The above example will output:
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
Now, compare the above with this:
Example #8 Correct usage of default function arguments
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
5
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
6



The above example will output:
Making a bowl of raspberry yogurt.
As of PHP 8.0.0,  can be used to skip over multiple optional parameters.
Example #9 Correct usage of default function arguments
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
7
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
8
The above example will output:
Making a bowl of raspberry natural yogurt.
As of PHP 8.0.0, declaring mandatory arguments after optional arguments is deprecated. This can generally be resolved by dropping the default value, since it will never be used. One exception to this rule are arguments of the form 
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42
9, where the null default makes the type implicitly nullable. This usage remains allowed, though it is recommended to use an explicit  instead.
Example #10 Declaring optional arguments after mandatory arguments
Making a bowl of raspberry yogurt.
1
Making a bowl of raspberry yogurt.
2
Note: As of PHP 7.1.0, omitting a parameter which does not specify a default throws an ArgumentCountError; in previous versions it raised a Warning.
Note: Arguments that are passed by reference may have a default value.
Variable-length argument lists
PHP has support for variable-length argument lists in user-defined functions by using the 
Making a bowl of raspberry yogurt.
3 token.
Note: It is also possible to achieve variable-length arguments by using func_num_args(), func_get_arg(), and func_get_args() functions. This technique is not recommended as it was used prior to the introduction of the 
Making a bowl of raspberry yogurt.
3 token.
Argument lists may include the 
Making a bowl of raspberry yogurt.
3 token to denote that the function accepts a variable number of arguments. The arguments will be passed into the given variable as an array:
Example #11 Using 
Making a bowl of raspberry yogurt.
3 to access variable arguments
Making a bowl of raspberry yogurt.
7
Making a bowl of raspberry yogurt.
8
The above example will output:
Making a bowl of raspberry yogurt.
3 can also be used when calling functions to unpack an array or Traversable variable or literal into the argument list:
Example #12 Using 
Making a bowl of raspberry yogurt.
3 to provide arguments
Making a bowl of raspberry natural yogurt.
1
Making a bowl of raspberry natural yogurt.
2
Making a bowl of raspberry natural yogurt.
3
The above example will output:
You may specify normal positional arguments before the 
Making a bowl of raspberry yogurt.
3 token. In this case, only the trailing arguments that don't match a positional argument will be added to the array generated by Making a bowl of raspberry yogurt.
3.
It is also possible to add a type declaration before the 
Making a bowl of raspberry yogurt.
3 token. If this is present, then all arguments captured by Making a bowl of raspberry yogurt.
3 must match that parameter type.
Example #13 Type declared variable arguments
Making a bowl of raspberry natural yogurt.
8
Making a bowl of raspberry natural yogurt.
9
3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
0
The above example will output:
3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
Finally, variable arguments can also be passed  by prefixing the 
Making a bowl of raspberry yogurt.
3 with an ampersand (3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
2).
Older versions of PHP
No special syntax is required to note that a function is variadic; however access to the function's arguments must use func_num_args(), func_get_arg() and func_get_args().
The first example above would be implemented as follows in old versions of PHP:
Example #14 Accessing variable arguments in old PHP versions
3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
3
Making a bowl of raspberry yogurt.
8
The above example will output:
Named Arguments
PHP 8.0.0 introduced named arguments as an extension of the existing positional parameters. Named arguments allow passing arguments to a function based on the parameter name, rather than the parameter position. This makes the meaning of the argument self-documenting, makes the arguments order-independent and allows skipping default values arbitrarily.
Named arguments are passed by prefixing the value with the parameter name followed by a colon. Using reserved keywords as parameter names is allowed. The parameter name must be an identifier, specifying dynamically is not allowed.
Example #15 Named argument syntax
3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
5
3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
6
Example #16 Positional arguments versus named arguments
3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
7
3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
8
The order in which the named arguments are passed does not matter.
Example #17 Same example as above with a different order of parameters
3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
9
Named arguments can be combined with positional arguments. In this case, the named arguments must come after the positional arguments. It is also possible to specify only some of the optional arguments of a function, regardless of their order.
Example #18 Combining named arguments with positional arguments
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>0
Passing the same parameter multiple times results in an Error exception.
Example #19 Error thrown when passing the same parameter multiple times
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>1
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>2
As of PHP 8.1.0, it is possible to use named arguments after unpacking the arguments. A named argument must not override an already unpacked arguments.
 
			Which PHP function accepts any number of parameters?
			Which of the following PHP functions accepts any number of parameters? Explanation: func_get_args() returns an array of arguments provided. One can use func_get_args() inside the function to parse any number of passed parameters.
		
			What is PHP function with parameters?
			PHP Parameterized functions are the functions with parameters. You can pass any number of parameters inside a function. These passed parameters act as variables inside your function. They are specified inside the parentheses, after the function name.
		
			Which PHP function is used to find number of parameters passed to the function?
			PHP provides three functions you can use in the function to retrieve the parameters passed to it. func_get_args( ) returns an array of all parameters provided to the function, func_num_args( ) returns the number of parameters provided to the function, and func_get_arg( ) returns a specific argument from the parameters.
		
			Which functions used for variable parameters in PHP?
			PHP supports variable length argument function. It means you can pass 0, 1 or n number of arguments in function. To do so, you need to use 3 ellipses (dots) before the argument name. The 3 dot concept is implemented for variable length argument since PHP 5.6.