関数の引数

引数のリストにより関数へ情報を渡すことができます。 このリストは、カンマで区切られた式のリストです。 引数の評価は、関数が実際にコールされる前に、 左から右の順番で行われます(先行評価)。

PHP は、値渡し(デフォルト)、 リファレンス渡しデフォルト引数値 をサポートしています。また、 可変長引数リスト や、 名前付き引数 もサポートしています。

例1 関数に配列を渡す

<?php
function takes_array($input)
{
    echo 
"$input[0] + $input[1] = "$input[0]+$input[1];
}
?>

PHP 8.0.0 以降では、引数リストの最後にカンマを付けることができます。 このカンマは無視されます。 これは、引数リストや変数名が長かったりした場合に、 引数を縦に並べるのに便利です。

例2 関数の引数リストの最後にカンマを付ける

<?php
function takes_many_args(
    
$first_arg,
    
$second_arg,
    
$a_very_long_argument_name,
    
$arg_with_default 5,
    
$again 'a default string'// この最後のカンマは、8.0.0 より前では許されません。
)
{
    
// ...
}
?>

引数のリファレンス渡し

デフォルトで、関数の引数は値で渡されます。(このため、関数の内部で 引数の値を変更しても関数の外側では値は変化しません。)関数がその引 数を修正できるようにするには、その引数をリファレンス渡しとする必要があり ます。

関数の引数を常にリファレンス渡しとしたい場合には、関数定義において アンパサンド(&) を引数名の前に付加することができます。

例3 関数のパラメータのリファレンス渡し

<?php
function add_some_extra(&$string)
{
    
$string .= 'and something extra.';
}
$str 'This is a string, ';
add_some_extra($str);
echo 
$str;    // 出力は 'This is a string, and something extra.' となります
?>

リファレンス渡しが想定されているところに、値渡しを行うとエラーになります。

デフォルト引数値

関数は、変数に代入する記法に似たやり方で、 デフォルト値を引数に定義することができます。 デフォルト値は引数が指定されなかった場合に使われますが、 null を渡した場合はデフォルト値を代入 しない ことに特に注意して下さい。

例4 関数におけるデフォルト引数の使用法

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

デフォルト引数の値には、スカラー値、 配列、および特殊な型 null を指定できます。 PHP 8.1.0 以降では、 new ClassName() 記法を使ってオブジェクトも指定できます。

例5 スカラー型以外をデフォルト値として使用する

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

例6 オブジェクトをデフォルト値として使用する(PHP 8.1.0 以降)

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

デフォルト値は、定数式である必要があり、 (例えば) 変数やクラスのメンバーであってはなりません。

デフォルト値を有する引数は、 デフォルト値がない引数の右側に全てある必要があることに注意して下さい。 そうでない場合、デフォルト値を指定していても、 呼び出し時に省略できません。 次の簡単なコードを見てみましょう。

例7 関数の引数のデフォルト値の 間違った使用法

<?php
function makeyogurt($container "bowl"$flavour)
{
    return 
"Making a $container of $flavour yogurt.\n";
}
 
echo 
makeyogurt("raspberry"); // $container に "raspberry" を指定します。$flavour ではありません。
?>

上の例の出力は以下となります。

Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42

ここで、上の例を次のコードと比べてみましょう。

例8 関数の引数のデフォルト値の 正しい使用法

<?php
function makeyogurt($flavour$container "bowl")
{
    return 
"Making a $container of $flavour yogurt.\n";
}
 
echo 
makeyogurt("raspberry"); // $flavour に "raspberry" を指定します。
?>

上の例の出力は以下となります。

Making a bowl of raspberry yogurt.

PHP 8.0.0 以降では、 デフォルト値を指定した引数を複数スキップするために、 名前付き引数 が使えます。

例9 関数の引数のデフォルト値の 正しい使用法

<?php
function makeyogurt($container "bowl"$flavour "raspberry"$style "Greek")
{
    return 
"Making a $container of $flavour $style yogurt.\n";
}

echo 
makeyogurt(style"natural");
?>

上の例の出力は以下となります。

Making a bowl of raspberry natural yogurt.

PHP 8.0.0 以降では、 デフォルト値を指定した引数の後に、 必須の引数を宣言することは 推奨されません。 なぜなら、そのデフォルト値は絶対に使われないからです。 これは、デフォルト値を削除することで解決できます。 このルールの唯一の例外は、 Type $param = null と書かれた引数です。 null をデフォルトにすることは、 型が暗黙のうちに nullable であることを示しています。 この書き方はまだ許可されていますが、 以下のようにして 明示的に nullable 型 を使うことを推奨します:

例10 デフォルト値を指定した引数は、必須の引数の後に宣言する

<?php
 
function foo($a = [], $b) {} // デフォルト値が使われないため、PHP 8.0.0 以降は推奨されません
 
function foo($a$b) {}      // 上のコードと機能的には同じですが、推奨されない警告は発生しません。

 
function bar(A $a null$b) {} // まだ許可されています。$a は必須ですが、nullable です。
 
function bar(?A $a$b) {}       // 推奨される書き方です。
 
?>

注意: PHP 7.1.0 以降では、 デフォルト値を指定しないで引数を省略すると、 ArgumentCountError がスローされるようになりました。 これより前のバージョンでは、警告が発生していました。

注意: リファレンス渡しの引数にもデフォルト値を指定できます。

可変長引数リスト

PHP は ... を使った可変長引数をユーザー定義関数でサポートしています。

注意: func_num_args(), func_get_arg(), func_get_args() 関数を使えば、可変長引数を実現できますが、 このテクニックは推奨されません。 なぜなら、... トークンが実装される前に使われていたものだからです。

引数リストに ... トークンを含めることで、 その関数が可変長の引数を受け取ることを示せます。 引数は、指定した変数に配列として渡されます。次の例を参照ください。

例11 ... を使った、可変長引数へのアクセス

<?php
function sum(...$numbers) {
    
$acc 0;
    foreach (
$numbers as $n) {
        
$acc += $n;
    }
    return 
$acc;
}

echo 
sum(1234);
?>

上の例の出力は以下となります。

10

関数を呼び出すときに ... を使うと、 配列や Traversable を実装した変数やリテラルを引数リストに展開することができます。

例12 引数での ... の使用例

<?php
function add($a$b) {
    return 
$a $b;
}

echo 
add(...[12])."\n";

$a = [12];
echo 
add(...$a);
?>

上の例の出力は以下となります。

3
3

通常の引数を、... の前に指定することもできます。 この場合は、通常の引数リストにマッチしなかったのこりの引数が ... による配列に追加されます。

... トークンの前に、 型宣言 を付加することもできます。 型宣言がある場合、... が取り込むすべての引数はその型に一致していなければいけません。

例13 型宣言つきの可変長引数

<?php
function total_intervals($unitDateInterval ...$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);
?>

上の例の出力は以下となります。

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 で実装すると、以下のようになります。

例14 可変長引数へのアクセス (古いバージョンのPHP)

<?php
function sum() {
    
$acc 0;
    foreach (
func_get_args() as $n) {
        
$acc += $n;
    }
    return 
$acc;
}

echo 
sum(1234);
?>

上の例の出力は以下となります。

10

名前付き引数

既にある、位置を指定した引数を拡張する形で、PHP 8.0.0 から名前付き引数が導入されました。 名前付き引数は、位置ではなく、名前ベースで引数を渡すことを可能にします。 これによって、引数の意味が自己文書化(self-documenting)され、 引数を任意の順番で渡せるようになり、任意のデフォルト値を持つ引数をスキップできるようになります。

名前付き引数は、引数の名前の後にコロンを付けたものを、値の前に付けることで指定します。 引数の名前に予約語を使うことも許されています。 引数の名前は識別子でなければならず、動的に指定することは出来ません。

例15 名前付き引数の文法

<?php
myFunction
(paramName$value);
array_foobar(array: $value);

// 以下の書き方はサポートされていません
function_name($variableStoringParamName$value);
?>

例16 位置を指定した引数と、名前付き引数

<?php
// 位置を指定した引数の場合:
array_fill(010050);

// 名前付き引数の場合:
array_fill(start_index0count100value50);
?>

名前付き引数は、渡す順番は関係ありません。

例17 上と同じ例を、引数の順番を変えて渡す

<?php
array_fill
(value50count100start_index0);
?>

名前付き引数は、位置を指定した引数と組み合わせることが出来ます。 そうした場合、名前付き引数は、位置を指定した引数の後に置かなければいけません。 オプションの引数だけをいくつか、指定することもできます。 その場合も、名前付き引数の順番は関係ありません。

例18 位置を指定した引数と、名前付き引数を組み合わせる

<?php
htmlspecialchars
($stringdouble_encodefalse);
// 上記は、以下と同等です。
htmlspecialchars($stringENT_QUOTES ENT_SUBSTITUTE ENT_HTML401'UTF-8'false);
?>

同じ引数を複数回渡すと、Error 例外が発生します。

例19 同じ引数を複数回渡すと、Error がスローされる

<?php
function foo($param) { ... }

foo(param1param2);
// Error: Named parameter $param overwrites previous argument
foo(1param2);
// Error: Named parameter $param overwrites previous argument
?>

PHP 8.1.0 以降では、 引数を ... で展開した後に 名前付き引数を指定することができます。 名前付き引数は、展開済みの引数を上書きしては いけません

例20 引数を展開した後に、名前付き引数を使う

<?php
function foo($a$b$c 3$d 4) {
  return 
$a $b $c $d;
}

var_dump(foo(...[12], d40)); // 46
var_dump(foo(...['b' => 2'a' => 1], d40)); // 46

var_dump(foo(...[12], b20)); // Fatal error. Named parameter $b overwrites previous argument
?>
add a note

User Contributed Notes 20 notes

up
110
php at richardneill dot org
7 years ago
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".
*/
?>
up
5
LilyWhite
11 months 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
up
35
gabriel at figdice dot org
6 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
?>
up
12
boan dot web at outlook dot com
4 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
?>
up
8
Hayley Watson
5 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.
up
13
Sergio Santana: ssantana at tlaloc dot imta dot mx
16 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.
up
6
catman at esteticas dot se
6 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
up
11
jcaplan at bogus dot amazon dot com
16 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

?>
up
5
info at keraweb dot nl
5 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"
up
2
Hayley Watson
5 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.
up
3
Horst Schirmeier
8 years ago
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; }).
up
2
tesdy14 at gmail dot com
10 months ago
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]
    );
}
up
1
TwystO
4 months ago
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();

?>
up
1
Simmo at 9000 dot 000
6 months 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).
up
0
tianyiw at vip dot qq dot com
11 days 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)
// }
up
0
rsperduta at gmail dot com
1 year ago
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 // some description
   
, $second_arg // another comment
   
, $a_very_long_argument_name = something($complicated) // IDK
   
, $arg_with_default = 5
   
, $again = 'a default string', // IMHO this trailing comma encourages illegible code and not being permitted seemed  a good idea lost with 8.0.0.
) {
   
// ...
}
?>

This principle can be applied equally to complicated boolean expressions of an "if" statement (or the parts of a for statement).
up
-1
igorsantos07 at gmail dot com
4 years ago
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');     //string(1) "a"
null_string_correct('a');   //string(1) "a"
null_string_correct();      //NULL
null_string_correct($null); //NULL
null_string_wrong($null);   //TypeError thrown
?>
up
-1
John
15 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)
up
-1
dmitry dot balabka at gmail dot com
3 years ago
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
up
-4
shaman_master at list dot ru
2 years ago
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;
    
// method must return Route object
   
public function setName(string $name): self
   
{
        
$this->name = $name;
         return
$this;
    }
}
class
RouteGroup extends Route
{
   
// method STILL must return only Route object
   
public function setName(string $name): self
   
{
        
$name .= ' group';
         return
parent::setName($name);
    }
}
?>
To Top