Authentication Services
Command Line Specific Extensions
Compression and Archive Extensions
Cryptography Extensions
Database Extensions
Date and Time Related Extensions
File System Related Extensions
Human Language and Character Encoding Support
Image Processing and Generation
Mail Related Extensions
Mathematical Extensions
Non-Text MIME Output
Process Control Extensions
Other Basic Extensions
Other Services
Search Engine Extensions
Server Specific Extensions
Session Extensions
Text Processing
Variable and Type Related Extensions
Web Services
Windows Only Extensions
XML Manipulation
GUI Extensions
Keyboard Shortcuts
?
This help
Next menu item
Previous menu item
Previous man page
Next man page
Scroll to bottom
Scroll to top
Goto homepage
Goto search
(current page)
Focus search box
<?php
function
makecoffee
(
$types
= array(
"cappuccino"
),
$coffeeMaker
=
NULL
)
{
$device
=
is_null
(
$coffeeMaker
) ?
"hands"
:
$coffeeMaker
;
return
"Making a cup of "
.
join
(
", "
,
$types
).
" with
$device
.\n"
;
}
echo
makecoffee
();
echo
makecoffee
(array(
"cappuccino"
,
"lavazza"
),
"teapot"
);
?>
<?php
class
DefaultCoffeeMaker
{
public function
brew
() {
return
'Making coffee.'
;
}
}
class
FancyCoffeeMaker
{
public function
brew
() {
return
'Crafting a beautiful coffee just for you.'
;
}
}
function
makecoffee
(
$coffeeMaker
= new
DefaultCoffeeMaker
)
{
return
$coffeeMaker
->
brew
();
}
echo
makecoffee
();
echo
makecoffee
(new
FancyCoffeeMaker
);
?>
自 PHP 8.0.0 起，
弃用
在可选参数之后声明强制参数。这通常可以通过删除默认值来解决，因为它永远不会被使用。唯一的例外是
Type $param = null
类型的参数，其中默认
null
使得该类型可以隐式为
null。这种做法依然允许，但是推荐使用显式
可为 null 类型
代替。
示例 #10 强制参数后声明可选参数
<?php
function
foo
(
$a
= [],
$b
) {}
// 默认不使用；自 PHP 8.0.0 起弃用
function
foo
(
$a
,
$b
) {}
// 功能相同，无弃用通知
function
bar
(
A $a
=
null
,
$b
) {}
// 仍然允许；但 $a 强制但可以为 null
function
bar
(?
A $a
,
$b
) {}
// 推荐
?>
<?php
function
total_intervals
(
$unit
,
DateInterval
...
$intervals
) {
$time
=
0
;
foreach (
$intervals
as
$interval
) {
$time
+=
$interval
->
$unit
;
}
return
$time
;
}
$a
= new
DateInterval
(
'P1D'
);
$b
= new
DateInterval
(
'P2D'
);
echo
total_intervals
(
'd'
,
$a
,
$b
).
' days'
;
// 这将会失败，因为 null 不是 DateInterval 对象。
echo
total_intervals
(
'd'
,
null
);
?>
To experiment on performance of pass-by-reference and pass-by-value, I used this script. Conclusions are below.
#!/usr/bin/php
<?php
function
sum
(
$array
,
$max
){
$sum
=
0
;
for (
$i
=
0
;
$i
<
2
;
$i
++){
$sum
+=
$array
[
$i
];
}
return (
$sum
);
}
$max
=
1E7
$data
=
range
(
0
,
$max
,
1
);
$start
=
microtime
(
true
);
for (
$x
=
0
;
$x
<
100
;
$x
++){
$sum
=
sum
(
$data
,
$max
);
}
$end
=
microtime
(
true
);
echo
"Time: "
.(
$end
-
$start
).
" s\n"
;
?>
It is worth noting that you can use functions as function arguments
<?php
function
run
(
$op
,
$a
,
$b
) {
return
$op
(
$a
,
$b
);
}
$add
= function(
$a
,
$b
) {
return
$a
+
$b
;
};
$mul
= function(
$a
,
$b
) {
return
$a
*
$b
;
};
echo
run
(
$add
,
1
,
2
),
"\n"
;
echo
run
(
$mul
,
1
,
2
);
?>
Output:
3
2
A function's argument that is an object, will have its properties modified by the function although you don't need to pass it by reference.
<?php
$x
= new
stdClass
();
$x
->
prop
=
1
;
function
f
(
$o
)
{
$o
->
prop
++;
}
f
(
$x
);
echo
$x
->
prop
;
?>
This is different for arrays:
<?php
$y
= [
'prop'
=>
1
];
function
g
(
$a
)
{
$a
[
'prop'
] ++;
echo
$a
[
'prop'
];
}
g
(
$y
);
echo
$y
[
'prop'
];
?>
function my_fonction(string $value) {
echo $value . PHP_EOL;
}
my_fonction(['foo' => 'ko', 'bar' => 'not', 'goodValue' => 'Oh Yeah']['goodValue']);
// return 'Oh Yeah'
// This may sound strange, anyway it's very useful in a foreach (or other conditional structure).
$expectedStatusCodes = [404, 403];
function getValueFromArray(string $value): string
{
return $value . PHP_EOL;
}
foreach ($expectedStatusCodes as $code) {
echo $currentUserReference = getValueFromArray(
[
404 => "Doesn't exist",
403 => 'Forbidden',
200 => "you're welcome"
][$code]
);
}
There are fewer restrictions on using ... to supply multiple arguments to a function call than there are on using it to declare a variadic parameter in the function declaration. In particular, it can be used more than once to unpack arguments, provided that all such uses come after any positional arguments.
<?php
$array1
= [[
1
],[
2
],[
3
]];
$array2
= [
4
];
$array3
= [[
5
],[
6
],[
7
]];
$result
=
array_merge
(...
$array1
);
$result
=
array_merge
(
$array2
, ...
$array1
);
$result
=
array_merge
(...
$array1
,
$array2
);
$result
=
array_merge
(...
$array1
, ...
$array3
);
?>
The Right Thing for the error case above would be for $result==[1,2,3,4], but this isn't yet (v7.1.8) supported.
In function calls, PHP clearly distinguishes between missing arguments and present but empty arguments. Thus:
<?php
function
f
(
$x
=
4
) { echo
$x
.
"\\n"
; }
f
();
f
(
null
);
f
(
$y
);
?>
The utility of the optional argument feature is thus somewhat diminished. Suppose you want to call the function f many times from function g, allowing the caller of g to specify if f should be called with a specific value or with its default value:
<?php
function
f
(
$x
=
4
) {echo
$x
.
"\\n"
; }
function
g
(
$x
=
4
) {
f
(
$x
);
f
(
$x
); }
function
g
(
$x
=
null
) { if ( !isset(
$x
) ) {
f
();
f
() } else {
f
(
$x
);
f
(
$x
); } }
?>
Both options suck.
The best approach, it seems to me, is to always use a sentinel like null as the default value of an optional argument. This way, callers like g and g's clients have many options, and furthermore, callers always know how to omit arguments so they can omit one in the middle of the parameter list.
<?php
function
f
(
$x
=
null
) { if ( !isset(
$x
) )
$x
=
4
; echo
$x
.
"\\n"
; }
function
g
(
$x
=
null
) {
f
(
$x
);
f
(
$x
); }
f
();
f
(
null
);
f
(
$y
);
g
();
g
(
null
);
g
(
5
);
?>
PASSING A "VARIABLE-LENGTH ARGUMENT LIST OF REFERENCES" TO A FUNCTION
As of PHP 5, Call-time pass-by-reference has been deprecated, this represents no problem in most cases, since instead of calling a function like this:
myfunction($arg1, &$arg2, &$arg3);
you can call it
myfunction($arg1, $arg2, $arg3);
provided you have defined your function as
function myfuncion($a1, &$a2, &$a3) { // so &$a2 and &$a3 are
// declared to be refs.
... <function-code>
}
However, what happens if you wanted to pass an undefined number of references, i.e., something like:
myfunction(&$arg1, &$arg2, ..., &$arg-n);?
This doesn't work in PHP 5 anymore.
In the following code I tried to amend this by using the
array() language-construct as the actual argument in the
call to the function.
<?php
function
aa
(
$A
) {
foreach (
$A
as &
$x
) {
$x
+=
2
;
}
}
$x
=
1
;
$y
=
2
;
$z
=
3
;
aa
(array(&
$x
, &
$y
, &
$z
));
echo
"--
$x
--
$y
--
$z
--\n"
;
?>
I hope this is useful.
Sergio.
I wondered if variable length argument lists and references works together, and what the syntax might be. It is not mentioned explicitly yet in the php manual as far as I can find. But other sources mention the following syntax "&...$variable" that works in php 5.6.16.
<?php
function
foo
(&...
$args
)
{
$i
=
0
;
foreach (
$args
as &
$arg
) {
$arg
= ++
$i
;
}
}
foo
(
$a
,
$b
,
$c
);
echo
'a = '
,
$a
,
', b = '
,
$b
,
', c = '
,
$c
;
?>
Gives
a = 1, b = 2, c = 3
If you use ... in a function's parameter list, you can use it only once for obvious reasons. Less obvious is that it has to be on the LAST parameter; as the manual puts it: "You may specify normal positional arguments BEFORE the ... token. (emphasis mine).
<?php
function
variadic
(
$first
, ...
$most
,
$last
)
{
}
variadic
(
1
,
2
,
3
,
4
,
5
);
?>
results in a fatal error, even though it looks like the Thing To Do™ would be to set $first to 1, $most to [2, 3, 4], and $last to 5.
For anyone just getting started with php or searching, for an understanding, on what this page describes as a "... token" in Variable-length arguments:
https://www.php.net/manual/en/functions.arguments.php#functions.variable-arg-list
<?php
func
(
$a
, ...
$b
)
?>
The 3 dots, or elipsis, or "...", or dot dot dot is sometimes called the "spread operator" in other languages.
As this is only used in function arguments, it is probably not technically an true operator in PHP. (As of 8.1 at least?).
(With having an difficult to search for name like "... token", I hope this note helps someone).
As stated in the documentation, the ... token can be used to pass an array of parameters to a function.
But it also works for class constructors as you can see below :
<?php
class
Courtesy
{
public
string $firstname
;
public
string $lastname
;
public function
__construct
(
$firstname
,
$lastname
) {
$this
->
firstname
=
$firstname
;
$this
->
lastname
=
$lastname
;
}
public function
hello
() {
return
'Hello '
.
$this
->
firstname
.
' '
.
$this
->
lastname
.
'!'
;
}
}
$params
= [
'John'
,
'Doe'
];
$courtesy
= new
Courtesy
(...
$params
);
echo
$courtesy
->
hello
();
?>
Editor's note: what is expected here by the parser is a non-evaluated expression. An operand and two constants requires evaluation, which is not done by the parser. However, this feature is included as of PHP 5.6.0. See this page for more information:
http://php.net/migration56.new-features#migration56.new-features.const-scalar-exprs
--------
"The default value must be a constant expression" is misleading (or even wrong). PHP 5.4.4 fails to parse this function definition:
function htmlspecialchars_latin1($s, $flags = ENT_COMPAT | ENT_HTML401) {}
This yields a " PHP Parse error: syntax error, unexpected '|', expecting ')' " although ENT_COMPAT|ENT_HTML401 is certainly what a compiler-affine person would call a "constant expression".
The obvious workaround is to use a single special value ($flags = NULL) as the default, and to set it to the desired value in the function's body (if ($flags === NULL) { $flags = ENT_COMPAT | ENT_HTML401; }).
<?php
function
arr
(
mixed
...
$values
): array
{
return
$values
;
}
$arr
=
arr
(
name
:
'php'
,
mobile
:
123456
,
);
var_dump
(
$arr
);
There is a possibility to use parent keyword as type hint which is not mentioned in the documentation.
Following code snippet will be executed w/o errors on PHP version 7. In this example, parent keyword is referencing on ParentClass instead of ClassTrait.
<?php
namespace
TestTypeHints
;
class
ParentClass
{
public function
someMethod
()
{
echo
'Some method called'
. \
PHP_EOL
;
}
}
trait
ClassTrait
{
private
$original
;
public function
__construct
(
parent $original
)
{
$this
->
original
=
$original
;
}
protected function
getOriginal
():
parent
{
return
$this
->
original
;
}
}
class
Implementation
extends
ParentClass
{
use
ClassTrait
;
public function
callSomeMethod
()
{
$this
->
getOriginal
()->
someMethod
();
}
}
$obj
= new
Implementation
(new
ParentClass
());
$obj
->
callSomeMethod
();
?>
Outputs:
Some method called
This might be documented somewhere OR obvious to most, but when passing an argument by reference (as of PHP 5.04) you can assign a value to an argument variable in the function call. For example:
function my_function($arg1, &$arg2) {
if ($arg1 == true) {
$arg2 = true;
}
}
my_function(true, $arg2 = false);
echo $arg2;
outputs 1 (true)
my_function(false, $arg2 = false);
echo $arg2;
outputs 0 (false)
PHP 7+ does type coercion if strict typing is not enabled, but there's a small gotcha: it won't convert null values into anything.
You must explicitly set your default argument value to be null (as explained in this page) so your function can also receive nulls.
For instance, if you type an argument as "string", but pass a null variable into it, you might expect to receive an empty string, but actually, PHP will yell at you a TypeError.
<?php
function
null_string_wrong
(
string $str
) {
var_dump
(
$str
);
}
function
null_string_correct
(
string $str
=
null
) {
var_dump
(
$str
);
}
$null
=
null
;
null_string_wrong
(
'a'
);
null_string_correct
(
'a'
);
null_string_correct
();
null_string_correct
(
$null
);
null_string_wrong
(
$null
);
?>
About example #2: That little comma down at the end and often obscured by a line comment is easily over looked. I think it's worth considering putting it at the head of the next line to make clear what it's relationship is to the surrounding lines. Consider how much clearer it's continuation as a list of parameters:
<?php
function
takes_many_args
(
$first_arg
,
$second_arg
,
$a_very_long_argument_name
=
something
(
$complicated
)
,
$arg_with_default
=
5
,
$again
=
'a default string'
,
) {
}
?>
This principle can be applied equally to complicated boolean expressions of an "if" statement (or the parts of a for statement).
When using named arguments and adding default values only to some of the arguments, the arguments with default values must be specified at the end or otherwise PHP throws an error:
<?php
function
test1
(
$a
,
$c
,
$b
=
2
)
{
return
$a
+
$b
+
$c
;
}
function
test2
(
$a
,
$b
=
2
,
$c
)
{
return
$a
+
$b
+
$c
;
}
echo
test1
(
a
:
1
,
c
:
3
).
"\n"
;
echo
test2
(
a
:
1
,
c
:
3
).
"\n"
;
?>
I assume that this happens because internally PHP rewrites the calls to something like test1(1, 3) and test2(1, , 3). The first call is valid, but the second obviously isn't.
You can use the class/interface as a type even if the class/interface is not defined yet or the class/interface implements current class/interface.
<?php
interface
RouteInterface
{
public function
getGroup
(): ?
RouteGroupInterface
;
}
interface
RouteGroupInterface
extends
RouteInterface
{
public function
set
(
RouteInterface $item
);
}
?>
'self' type - alias to current class/interface, it's not changed in implementations. This code looks right but throw error:
<?php
class
Route
{
protected
$name
;
public function
setName
(
string $name
):
self
{
$this
->
name
=
$name
;
return
$this
;
}
}
class
RouteGroup
extends
Route
{
public function
setName
(
string $name
):
self
{
$name
.=
' group'
;
return
parent
::
setName
(
$name
);
}
}
?>
