Hướng dẫn default argument in php
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). Show PHP supports passing arguments by value (the default), passing by reference, and default argument values. Variable-length argument lists and Named Arguments are also supported. Example #1 Passing arrays to functions
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
Passing arguments by referenceBy 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
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 Example #4 Use of default parameters in functions
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 Example #5 Using non-scalar types as default values
Example #6 Using objects as default values (as of PHP 8.1.0)
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
makeyogurt("raspberry"); // "raspberry" is $container, not $flavour 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
makeyogurt("raspberry"); // "raspberry" is $flavour The above example will output: Making a bowl of raspberry yogurt. As of PHP 8.0.0, named arguments can be used to skip over multiple optional parameters. Example #9 Correct usage of default function arguments
makeyogurt(style: "natural"); 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 Example #10 Declaring optional arguments after mandatory arguments
Variable-length argument lists PHP has support for variable-length argument lists in user-defined functions by using the
Argument lists may include the Example #11 Using
sum(1, 2, 3, 4); The above example will output: Example #12 Using
add(...[1, 2])."\n";$a = [1, 2]; The above example will output: You may specify normal positional arguments before the It is also possible to add a type
declaration before the Example #13 Type declared variable arguments
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 reference by
prefixing the Older versions of PHPNo 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
sum(1, 2, 3, 4); The above example will output: Named ArgumentsPHP 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
Example #16 Positional arguments versus named arguments
The order in which the named arguments are passed does not matter. Example #17 Same example as above with a different order of parameters
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
Passing the same parameter multiple times results in an Error exception. Example #19 Error thrown when passing the same parameter multiple times
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. Example #20 Use named arguments after unpacking
php at richardneill dot org ¶ 7 years ago
?>
LilyWhite ¶ 11 months ago
run($add, 1, 2), "\n"; gabriel at figdice dot org ¶ 6 years ago
f ( $o ) // Notice the absence of & boan dot web at outlook dot com ¶ 4 years ago
Hayley Watson ¶ 5 years ago
= [[1],[2],[3]]; Sergio Santana: ssantana at tlaloc dot imta dot mx ¶ 16 years ago
catman at esteticas dot se ¶ 6 years ago
jcaplan at bogus dot amazon dot com ¶ 16 years ago
g( $x = null ) { f( $x ); f( $x ); }f(); // prints 4 info at keraweb dot nl ¶ 4 years ago
Hayley Watson ¶ 5 years ago
Horst Schirmeier ¶ 8 years ago
tesdy14 at gmail dot com ¶ 9 months ago
TwystO ¶ 4 months ago
__construct($firstname, $lastname) { Simmo at 9000 dot 000 ¶ 5 months ago
($a, ...$b) ?> rsperduta at gmail dot com ¶ 1 year ago
igorsantos07 at gmail dot com ¶ 4 years ago
John ¶ 15 years ago
dmitry dot balabka at gmail dot com ¶ 3 years ago
ParentClass shaman_master at list dot ru ¶ 2 years ago
|