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){ //For Reference, use: "&$array"
$sum=0;
for ($i=0; $i<2; $i++){
#$array[$i]++; //Uncomment this line to modify the array within the function.
$sum += $array[$i];
}
return ($sum);
}
$max = 1E7 //10 M data points.
$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";
/* Run times:
# PASS BY MODIFIED? Time
- ------- --------- ----
1 value no 56 us
2 reference no 58 us
3 valuue yes 129 s
4 reference yes 66 us
Conclusions:
1. PHP is already smart about zero-copy / copy-on-write. A function call does NOT copy the data unless it needs to; the data is
only copied on write. That's why #1 and #2 take similar times, whereas #3 takes 2 million times longer than #4.
[You never need to use &$array to ask the compiler to do a zero-copy optimisation; it can work that out for itself.]
2. You do use &$array to tell the compiler "it is OK for the function to over-write my argument in place, I don't need the original
any more." This can make a huge difference to performance when we have large amounts of memory to copy.
(This is the only way it is done in C, arrays are always passed as pointers)
3. The other use of & is as a way to specify where data should be *returned*. (e.g. as used by exec() ).
(This is a C-like way of passing pointers for outputs, whereas PHP functions normally return complex types, or multiple answers
in an array)
4. It's unhelpful that only the function definition has &. The caller should have it, at least as syntactic sugar. Otherwise
it leads to unreadable code: because the person reading the function call doesn't expect it to pass by reference. At the moment,
it's necessary to write a by-reference function call with a comment, thus:
$sum = sum($data,$max); //warning, $data passed by reference, and may be modified.
5. Sometimes, pass by reference could be at the choice of the caller, NOT the function definitition. PHP doesn't allow it, but it
would be meaningful for the caller to decide to pass data in as a reference. i.e. "I'm done with the variable, it's OK to stomp
on it in memory".
*/
?>
함수 인수
함수 인수를 통해서 함수에 정보를 넘겨줄수 있다. 이런 함수 인수는 콤마(,)로 구별되는 표현 목록이다.
PHP는 값에 의한 인수 전달(passing by value) (기본값), 참조에 의한 전달, 인수 기본값 기능을 지원합니다. 가변 길이 인수 목록도 지원하며, 자세한 정보는 func_num_args(), func_get_arg(), func_get_args() 함수 레퍼런스를 참고하십시오.
Example #1 함수에 배열 넘겨주기
<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>
참조에 의한 인수 전달하기
기본적으로, 함수 인수는 값에 의해 전달됩니다. (그래서 함수내의 인수 변수값을 변경해도 함수 밖에서는 바뀌지 않습니다) 함수가 그 인수를 바꾸게 하려면, 참조로 넘겨줘야 합니다.
항상 함수의 인수를 참조로 넘기게 하려면, 함수 정의에서 엠퍼샌드(&)를 인수 이름 앞에 붙이면 됩니다:
Example #2 참조에 의해 함수 인수 전달하기
<?php
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.'
?>
기본 인수 값
함수는 다음과 같이 스칼라 인수에 대해 C++스타일 기본값으로 지정할수있다:
Example #3 함수에 기본 인수 사용하기
<?php
function makecoffee($type = "cappuccino")
{
return "Making a cup of $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>
위 예제의 출력:
Making a cup of cappuccino. Making a cup of . Making a cup of espresso.
PHP는 array와 특별형 NULL을 기본값으로 사용할 수 있습니다.
예를 들면:
Example #4 스칼라 형이 아닌 기본값 사용하기
<?php
function makecoffee($types = array("카푸치노"), $coffeeMaker = NULL)
{
$device = is_null($coffeeMaker) ? "손" : $coffeeMaker;
return "$device(으)로 ".join(", ", $types)."를 만듭니다.\n";
}
echo makecoffee();
echo makecoffee(array("카푸치노", "라바짜"), "찻주전자");
?>
기본값은 상수 표현식이 될수 있으나 (예를 들면) 변수나 클래스 멤버가 될수는 없다.
기본 인수를 사용할때에는 모든 기본값은 기본값을 쓰지 않는 인수의 오른쪽으로 가야 한다; 그렇지 않으면, 기대하던대로 작동하지 않을것이다. 다음 예제 코드를 참고:
Example #5 기본 함수 인수가 잘못 사용된 예
<?php
function makeyogurt($type = "acidophilus", $flavour)
{
return "Making a bowl of $type $flavour.\n";
}
echo makeyogurt("raspberry"); // won't work as expected
?>
위 예제의 출력:
Warning: Missing argument 2 in call to makeyogurt() in /usr/local/etc/httpd/htdocs/phptest/functest.html on line 41 Making a bowl of raspberry .
위 코드를 아래 코드와 비교하라:
Example #6 기본 함수 인수의 정확한 사용예
<?php
function makeyogurt($flavour, $type = "acidophilus")
{
return "Making a bowl of $type $flavour.\n";
}
echo makeyogurt("raspberry"); // works as expected
?>
위 예제의 출력:
Making a bowl of acidophilus raspberry.
Note: PHP 5부터, 기본값을 참조로 넘길 수 있습니다.
Type declarations
Note:
Type declarations were also known as type hints in PHP 5.
Type declarations allow functions to require that parameters are of a certain type at call time. If the given value is of the incorrect type, then an error is generated: in PHP 5, this will be a recoverable fatal error, while PHP 7 will throw a TypeError exception.
To specify a type declaration, the type name should be added before the
parameter name. The declaration can be made to accept NULL values if
the default value of the parameter is set to NULL.
Valid types
| Type | Description | Minimum PHP version |
|---|---|---|
| Class/interface name | The parameter must be an instanceof the given class or interface name. | PHP 5.0.0 |
| self | The parameter must be an instanceof the same class as the one the method is defined on. This can only be used on class and instance methods. | PHP 5.0.0 |
| array | The parameter must be an array. | PHP 5.1.0 |
| callable | The parameter must be a valid callable. | PHP 5.4.0 |
| bool | The parameter must be a boolean value. | PHP 7.0.0 |
| float | The parameter must be a floating point number. | PHP 7.0.0 |
| int | The parameter must be an integer. | PHP 7.0.0 |
| string | The parameter must be a string. | PHP 7.0.0 |
예제
Example #7 Basic class type declaration
<?php
class C {}
class D extends C {}
// This doesn't extend C.
class E {}
function f(C $c) {
echo get_class($c)."\n";
}
f(new C);
f(new D);
f(new E);
?>
위 예제의 출력:
C
D
Fatal error: Uncaught TypeError: Argument 1 passed to f() must be an instance of C, instance of E given, called in - on line 14 and defined in -:8
Stack trace:
#0 -(14): f(Object(E))
#1 {main}
thrown in - on line 8
Example #8 Basic interface type declaration
<?php
interface I { public function f(); }
class C implements I { public function f() {} }
// This doesn't implement I.
class E {}
function f(I $i) {
echo get_class($i)."\n";
}
f(new C);
f(new E);
?>
위 예제의 출력:
C
Fatal error: Uncaught TypeError: Argument 1 passed to f() must implement interface I, instance of E given, called in - on line 13 and defined in -:8
Stack trace:
#0 -(13): f(Object(E))
#1 {main}
thrown in - on line 8
Example #9 Nullable type declaration
<?php
class C {}
function f(C $c = null) {
var_dump($c);
}
f(new C);
f(null);
?>
위 예제의 출력:
object(C)#1 (0) {
}
NULL
Strict typing
By default, PHP will coerce values of the wrong type into the expected scalar type if possible. For example, a function that is given an integer for a parameter that expects a string will get a variable of type string.
It is possible to enable strict mode on a per-file basis. In strict mode, only a variable of exact type of the type declaration will be accepted, or a TypeError will be thrown. The only exception to this rule is that an integer may be given to a function expecting a float.
To enable strict mode, the declare statement is used with the strict_types declaration:
Caution
Enabling strict mode will also affect return type declarations.
Note:
Strict typing applies to function calls made from within the file with strict typing enabled, not to the functions declared within that file. If a file without strict typing enabled makes a call to a function that was defined in a file with strict typing, the caller's preference (weak typing) will be respected, and the value will be coerced.
Note:
Strict typing is only defined for scalar type declarations, and as such, requires PHP 7.0.0 or later, as scalar type declarations were added in that version.
Example #10 Strict typing
<?php
declare(strict_types=1);
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
?>
위 예제의 출력:
int(3)
Fatal error: Uncaught TypeError: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 9 and defined in -:4
Stack trace:
#0 -(9): sum(1.5, 2.5)
#1 {main}
thrown in - on line 4
Example #11 Weak typing
<?php
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
// These will be coerced to integers: note the output below!
var_dump(sum(1.5, 2.5));
?>
위 예제의 출력:
int(3) int(3)
Example #12 Catching TypeError
<?php
declare(strict_types=1);
function sum(int $a, int $b) {
return $a + $b;
}
try {
var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
} catch (TypeError $e) {
echo 'Error: '.$e->getMessage();
}
?>
위 예제의 출력:
int(3) Error: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 10
가변 길이 인수 목록
PHP는 사용자 선언 함수에서 가변 길이 인수 목록을 지원합니다. PHP 5.6 이상에서는 ... 토큰을 사용하고, PHP 5.5 이하에서는 func_num_args(), func_get_arg(), func_get_args() 함수를 사용합니다.
PHP 5.6+에서 ...
PHP 5.6 이상에서, 인수 목록은 ... 토큰을 포함하여 함수가 가변 수의 인수를 받을 수 있다고 표시할 수 있습니다. 인수는 배열로 주어진 변수에 전달됩니다; 예제:
Example #13 가변 인수에 접근하기 위한 ... 사용하기
<?php
function sum(...$numbers) {
$acc = 0;
foreach ($numbers as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
위 예제의 출력:
10
또한 함수를 호출할 때 ...을 사용하여 array, Traversable 변수, 또는 literal을 인수 목록에 포함할 수 있습니다. literal into the argument list:
Example #14 인수 제공을 위한 ... 사용하기
<?php
function add($a, $b) {
return $a + $b;
}
echo add(...[1, 2])."\n";
$a = [1, 2];
echo add(...$a);
?>
위 예제의 출력:
3 3
보통의 위치 인수를 ... 앞에 지정할 수 있습니다. 이 경우, 위치 인수에 어울리지 않는 인수만이 ...로 생성되는 배열에 추가됩니다.
... 토큰 앞에 type hint를 추가할 수 있습니다. 이 정보가 존재할 경우, ...에 들어가는 모든 인수는 해당 클래스의 객체여야 합니다.
Example #15 Type hinted variable arguments
<?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';
// This will fail, since null isn't a DateInterval object.
echo total_intervals('d', null);
?>
위 예제의 출력:
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
마지막으로, ... 앞에 앰퍼샌드를 붙여서(&) 가변 인수를 참조로 전달할 수 있습니다.
PHP 구 버전
가변 인수로 만들기 위한 특별한 문법은 필요하지 않습니다; 하지만 함수의 인수에 접근하려면 func_num_args(), func_get_arg(), func_get_args() 함수를 사용해야 합니다.
위 예제 중 첫번째를 PHP 5.5 이전에서는 다음과 같이 사용합니다:
Example #16 PHP 5.5 이전의 가변 길이 인수 접근하기
<?php
function sum() {
$acc = 0;
foreach (func_get_args() as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
위 예제의 출력:
10
add a note
User Contributed Notes 14 notes
php at richardneill dot org ¶
9 years ago
Simmo at 9000 dot 000 ¶
2 years ago
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).
LilyWhite ¶
3 years ago
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
tianyiw at vip dot qq dot com ¶
2 years ago
<?php
/**
* Create an array using Named Parameters.
*
* @param mixed ...$values
* @return array
*/
function arr(mixed ...$values): array
{
return $values;
}
$arr = arr(
name: 'php',
mobile: 123456,
);
var_dump($arr);
// array(2) {
// ["name"]=>
// string(3) "php"
// ["mobile"]=>
// int(123456)
// }
gabriel at figdice dot org ¶
8 years ago
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 ) // Notice the absence of &
{
$o->prop ++;
}
f($x);
echo $x->prop; // shows: 2
?>
This is different for arrays:
<?php
$y = [ 'prop' => 1 ];
function g( $a )
{
$a['prop'] ++;
echo $a['prop']; // shows: 2
}
g($y);
echo $y['prop']; // shows: 1
?>
Hayley Watson ¶
7 years ago
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); // Legal, of course: $result == [1,2,3];
$result = array_merge($array2, ...$array1); // $result == [4,1,2,3]
$result = array_merge(...$array1, $array2); // Fatal error: Cannot use positional argument after argument unpacking.
$result = array_merge(...$array1, ...$array3); // Legal! $result == [1,2,3,5,6,7]
?>
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.
boan dot web at outlook dot com ¶
6 years ago
Quote:
"The declaration can be made to accept NULL values if the default value of the parameter is set to NULL."
But you can do this (PHP 7.1+):
<?php
function foo(?string $bar) {
//...
}
foo(); // Fatal error
foo(null); // Okay
foo('Hello world'); // Okay
?>
Luna ¶
2 years ago
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"; // Works
echo test2(a: 1, c: 3)."\n"; // ArgumentCountError: Argument #2 ($b) not passed
?>
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.
Sergio Santana: ssantana at tlaloc dot imta dot mx ¶
19 years ago
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) {
// This function increments each
// "pseudo-argument" by 2s
foreach ($A as &$x) {
$x += 2;
}
}
$x = 1; $y = 2; $z = 3;
aa(array(&$x, &$y, &$z));
echo "--$x--$y--$z--\n";
// This will output:
// --3--4--5--
?>
I hope this is useful.
Sergio.
jcaplan at bogus dot amazon dot com ¶
18 years ago
In function calls, PHP clearly distinguishes between missing arguments and present but empty arguments. Thus:
<?php
function f( $x = 4 ) { echo $x . "\\n"; }
f(); // prints 4
f( null ); // prints blank line
f( $y ); // $y undefined, prints blank line
?>
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"; }
// option 1: cut and paste the default value from f's interface into g's
function g( $x = 4 ) { f( $x ); f( $x ); }
// option 2: branch based on input to g
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(); // prints 4
f( null ); // prints 4
f( $y ); // $y undefined, prints 4
g(); // prints 4 twice
g( null ); // prints 4 twice
g( 5 ); // prints 5 twice
?>
catman at esteticas dot se ¶
8 years ago
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
Hayley Watson ¶
7 years ago
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)
{/*etc.*/}
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.
info at keraweb dot nl ¶
7 years ago
You can use a class constant as a default parameter.
<?php
class A {
const FOO = 'default';
function bar( $val = self::FOO ) {
echo $val;
}
}
$a = new A();
$a->bar(); // Will echo "default"
John ¶
18 years ago
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)
