PHP 8.0.0 Released!

Funktionsparameter

Mit einer Parameterliste kann man Informationen an eine Funktion übergeben. Die Parameterliste ist eine durch Kommas getrennte Liste von Ausdrücken. Die Parameter werden von links nach rechts ausgewertet.

PHP unterstützt die Weitergabe von Parametern als Werte (das ist der Standard), als Verweise und als Vorgabewerte. Eine variable Anzahl von Parametern wird ebenfalls unterstützt.

Beispiel #1 Arrays an Funktionen übergeben

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

Parameter als Verweise übergeben

Normalerweise werden den Funktionen Werte als Parameter übermittelt. Wenn man den Wert dieses Parameters innerhalb der Funktion ändert, bleibt der Parameter außerhalb der Funktion unverändert. Wollen Sie aber erreichen, dass die Änderung auch außerhalb der Funktion sichtbar wird, müssen Sie die Parameter als Verweise (Referenzen) übergeben.

Wenn eine Funktion einen Parameter generell als Verweis behandeln soll, setzt man in der Funktionsdefinition ein kaufmännisches Und (&) vor den Parameternamen:

Beispiel #2 Übergeben von Funktionsparametern als Verweis

<?php
function fuege_etwas_an(&$string)
{
    
$string .= 'und etwas mehr.';
}
$str 'Dies ist ein String, ';
fuege_etwas_an($str);
echo 
$str// Ausgabe: 'Dies ist ein String, und etwas mehr.'
?>

Vorgabewerte für Parameter

Eine Funktion kann C++-artige Vorgabewerte für skalare Parameter wie folgt definieren:

Beispiel #3 Einsatz von Vorgabeparametern in Funktionen

<?php
function machkaffee($typ "Cappuccino")
{
    return 
"Ich mache eine Tasse $typ.\n";
}
echo 
machkaffee();
echo 
machkaffee(null);
echo 
machkaffee("Espresso");
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Ich mache eine Tasse Cappuccino.
Ich mache eine Tasse .
Ich mache eine Tasse Espresso.

PHP gestattet es, Arrays und den speziellen Typ NULL als Vorgabewert zu nutzen, zum Beispiel:

Beispiel #4 Nichtskalare Typen als Vorgabewert

<?php
function makecoffee($types = array("cappuccino"), $coffeeMaker NULL)
{
    
$device is_null($coffeeMaker) ? "hands" $coffeeMaker;
    return 
"Ich mache eine Tasse ".join(", "$types)." mit $device.\n";
}
echo 
makecoffee();
echo 
makecoffee(array("cappuccino""lavazza"), "teapot");
?>

Der Vorgabewert muss ein konstanter Ausdruck sein, darf also zum Beispiel keine Variable, Eigenschaft einer Klasse oder ein Funktionsaufruf sein.

Bitte beachten Sie, dass alle Parameter mit Vorgabewert rechts von den Parametern ohne Vorgabewert stehen müssen - sonst wird es nicht funktionieren. Betrachten Sie folgendes Beispiel:

Beispiel #5 Ungültige Anwendung von Vorgabewerten

<?php
function mach_joghurt($typ "rechtsdrehendes"$geschmack)
{
    return 
"Mache einen Becher $typ $geschmack-joghurt.\n";
}

echo 
mach_joghurt("Brombeer");   // arbeitet nicht wie erwartet
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Warning: Missing argument 2 in call to mach_joghurt() in
/usr/local/etc/httpd/htdocs/phptest/functest.html on line 41
Mache einen Becher Brombeer -joghurt.

Nun vergleichen Sie bitte obiges Beispiel mit folgendem:

Beispiel #6 Richtiger Einsatz von Vorgabewerten

<?php
function mach_joghurt($geschmack$typ "rechtsdrehendes")
{
    return 
"Mache einen Becher $typ $geschmack-Joghurt.\n";
}

echo 
mach_joghurt("Brombeer");   // arbeitet wie erwartet.
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Mache einen Becher rechtsdrehendes Brombeer-Joghurt.

Hinweis: Das Setzen von Standardwerten für Argumente, die als Referenz übergeben werden ("passed by reference") wird seit PHP 5 unterstützt.

Typdeklarationen

Hinweis:

Typdeklarationen waren unter PHP 5 ebenfalls unter dem Namen Type-Hints bekannt.

Typdeklarationen erlauben es, dass Funktionsparameter zur Aufrufzeit von einem bestimmten Typ sind. Ist der gegebene Wert von einem falschen Typ, dann wird ein Fehler generiert: in PHP 5 ist es ein recoverable fatal error, während PHP 7 eine TypeError-Exception auslöst.

Um eine Typdeklaration zu spezifizieren, sollte der Typname vor dem Parameternamen hinzugefügt werden. Wird der Vorgabewert des Parameters als NULL definiert, akzeptiert die Funktion die Übergabe von NULL.

Gültige Typen

Typ Beschreibung Minimale PHP-Version
Klassen/Interface-Name Der Parameter muss ein Exemplar (instanceof) der gegebenen Klasse oder des Interface sein. PHP 5.0.0
self Der Parameter muss ein Exemplar (instanceof) der selben Klasse sein für die die Methode definiert ist. Dies kann nur für Klassen- und Objektmethoden verwendet werden. PHP 5.0.0
array Der Parameter muss ein Array sein. PHP 5.1.0
callable Der Parameter muss ein gültiges Callable sein. PHP 5.4.0
bool Der Parameter muss ein Boolescher Wert (boolean) sein. PHP 7.0.0
float Der Parameter muss eine Gleitkommazahl (float) sein. PHP 7.0.0
int Der Parameter muss eine Ganzzahl (integer) sein. PHP 7.0.0
string Der Parameter muss ein String sein. PHP 7.0.0
iterable Der Parameter muss entweder ein Array oder ein instanceof Traversable sein. PHP 7.1.0
object Der Parameter muss ein Object sein. PHP 7.2.0
Warnung

Aliase der oben genannten skalaren Typen werden nicht unterstützt. Statt dessen werden sie als Klassen- oder Schnittstellennamen angesehen. Zum Beispiel erfordert die Verwendung von boolean als Parameter oder Rückgabetyp ein Argument oder einen Rückgabewert, der ein Exemplar (instanceof) der Klasse oder Schnittstelle boolean ist, anstatt vom Typ bool:

<?php
 
function test(boolean $param) {}
 
test(true);
 
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

 Fatal error: Uncaught TypeError: Argument 1 passed to test() must be an instance of boolean, boolean given, called in - on line 1 and defined in -:1
 

Beispiele

Beispiel #7 Grundlegende Klassen-Typdeklaration

<?php
class {}
class 
extends {}

// Dies erweitert C nicht.
class {}

function 
f(C $c) {
    echo 
get_class($c)."\n";
}

f(new C);
f(new D);
f(new E);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

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

Beispiel #8 Grundlegende Interface-Typdeklaration

<?php
interface { public function f(); }
class 
implements { public function f() {} }

// Dies implementiert I nicht.
class {}

function 
f(I $i) {
    echo 
get_class($i)."\n";
}

f(new C);
f(new E);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

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

Beispiel #9 Typisierte Referenzparameter

Deklarierte Typen von Referenzparametern werden nur beim Betreten der Funktion geprüft, nicht aber beim Verlassen derselben, so dass sich der Typ des Arguments nach dem Verlassen geändert haben kann.

<?php
function array_baz(array &$param)
{
    
$param 1;
}
$var = [];
array_baz($var);
var_dump($var);
array_baz($var);
?>

Das oben gezeigte Beispiel erzeugt eine ähnliche Ausgabe wie:

int(1)

Fatal error: Uncaught TypeError: Argument 1 passed to array_baz() must be of the type array, int given, called in %s on line %d

Beispiel #10 Nullable Typdeklaration

<?php
class {}

function 
f(C $c null) {
    
var_dump($c);
}

f(new C);
f(null);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

object(C)#1 (0) {
}
NULL

Strenge Typisierung

Standardmäßig erzwingt PHP die Umwandlung von Werten des falschen Typs in den erwarteten skalaren Typ, falls möglich. Zum Beispiel erhält eine Funktion, der ein Integer für einen Parameter, der einen String erwartet, übergeben wurde, eine Variable vom Typ String.

Es ist möglich die strenge Typisierung für einzelne Dateien zu aktivieren. Im strengen Typisierungsmodus werden nur Variablen von genau dem Typ der Typdeklaration akzeptiert, oder ein TypeError wird ausgelöst. Die einzige Ausnahme dieser Regel ist, dass ein Integer an eine Funktion, die ein Float erwartet, übergeben werden darf. Funktionsaufrufe innerhalb von internen Funktionen sind nicht von der strict_types-Deklaration betroffen.

Um die strenge Typisierung zu aktivieren, wird die declare-Anweisung mit der strict_types-Deklaration verwendet:

Achtung

Das Aktivieren der strengen Typisierung betrifft ebenfalls Rückgabe-Typdeklarationen.

Hinweis:

Strenge Typisierung gilt für Funktionsaufrufe, die innerhalb einer Datei im strengen Typisierungsmodus durchgeführt werden, nicht für Funktionen, die innerhalb dieser Datei deklariert wurden. Ruft eine Datei, für die strenge Typisierung nicht aktiviert ist, eine Funktion, die in einer Datei im strengen Typisierungsmodus definiert wurde, auf, wird die Präferenz des Aufrufers (schwache Typisierung) beachtet, und die Konvertierung des Werts wird erzwungen.

Hinweis:

Strenge Typisierung ist nur für skalare Typdeklarationen gültig, und erfodert folglich PHP 7.0.0 oder höher, da skalare Typdeklarationen erst in dieser Version hinzugefügt wurden.

Beispiel #11 Strenge Typisierung

<?php
declare(strict_types=1);

function 
sum(int $aint $b) {
    return 
$a $b;
}

var_dump(sum(12));
var_dump(sum(1.52.5));
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

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

Beispiel #12 Schwache Typisierung

<?php
function sum(int $aint $b) {
    return 
$a $b;
}

var_dump(sum(12));

// Die Konvertierung nach Integer wird erzwungen: beachten Sie die Ausgabe weiter unten!
var_dump(sum(1.52.5));
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

int(3)
int(3)

Beispiel #13 Abfangen von TypeError

<?php
declare(strict_types=1);

function 
sum(int $aint $b) {
    return 
$a $b;
}

try {
    
var_dump(sum(12));
    
var_dump(sum(1.52.5));
} catch (
TypeError $e) {
    echo 
'Fehler: '.$e->getMessage();
}
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

int(3)
Fehler: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 10

Variable Anzahl von Parametern

PHP unterstützt eine variable Anzahl an Parametern für benutzerdefinierte Funktionen. Dies wird seit PHP 5.6 durch das Token ... umgesetzt. Für ältere Versionen von PHP stehen die Funktionen func_num_args(), func_get_arg(), und func_get_args() bereit.

... in PHP 5.6+

Ab PHP 5.6 kann eine Liste von Parametern das Token ... enthalten, um anzugeben, dass die Funktion eine variable Anzahl von Parametern akzeptiert. Die zusätzlichen Werte werden als Array an die entsprechende Variable übergeben. Zum Beispiel:

Beispiel #14 Verwendung von ... für den Zugriff auf variable Parameter

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

echo 
sum(1234);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

10

Das Token ... kann ebenfalls dazu verwendet werden, um ein Array oder Traversable-Objekt als Liste von Parametern zu übergeben:

Beispiel #15 Verwendung von ... zur Übergabe einer Parameterliste

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

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

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

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

3
3

Die Definition von regulären, positionierten Parametern vor dem ... ist natürlich weiterhin möglich. In einem solchen Fall werden dann nur die zusätzlichen Werte, die zu keinem positionierten Parameter gehören, in das durch ... erzeugte Array übernommen.

Es ist zudem ebenfalls möglich dem ... Token eine Typangabe voran zu stellen. Ist dies der Fall, müssen alle Werte, die für ... relevant sind, vom entsprechenden Typ sein.

Beispiel #16 Variable Parameter mit Vorgabe des Typs

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

// Dieser Aufruf wird scheitern, da null keine Instanz von DateInterval ist
echo total_intervals('d'null);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

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

Durch ein voran gestelltes & ist auch die Übergabe von variablen Parametern als Referenz möglich.

Ältere Versionen von PHP

Eine spezielle Syntax ist zur Definition von variablen Parametern nicht notwendig. Um auf die übergebenen Werte zugreifen zu können, stehen die Funktionen func_num_args(), func_get_arg() und func_get_args() bereit.

Das erste Beispiel von weiter oben würde in PHP 5.5 und davor so umgesetzt werden können:

Beispiel #17 Zugriff auf variable Parameter in PHP 5.5 und davor

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

echo 
sum(1234);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

10

add a note add a note

User Contributed Notes 14 notes

up
96
php at richardneill dot org
5 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
32
gabriel at figdice dot org
4 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
16
jcaplan at bogus dot amazon dot com
14 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
7
info at keraweb dot nl
3 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
16
Sergio Santana: ssantana at tlaloc dot imta dot mx
15 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
7
boan dot web at outlook dot com
2 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
6
Hayley Watson
3 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
8
Horst Schirmeier
6 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
4
catman at esteticas dot se
4 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
2
dmitry dot balabka at gmail dot com
2 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
Hayley Watson
3 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
igorsantos07 at gmail dot com
2 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
5
John
14 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
2
shaman_master at list dot ru
1 year 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