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".
*/
?>
Argumenty funkcji
Dane mogą być przekazywane do funkcji przez listę argumentów, która jest listą oddzielonych przecinkami wyrażeń. Argumenty są wykonywane od prawej do lewej.
PHP obsługuje podawanie argumentów jako wartości (domyślnie), przez referencję, oraz domyślne wartości argumentów. Różna ilość argumentów także jest obsługiwana.
Przykład #1 Tablica jako argument funkcji
<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>
Podawanie argumentów jako referencji
Domyślnie, argumenty funkcji podawane są jako wartości (kiedy wartość argumentu wewnątrz funkcji się zmienia, nie wpływa to na wartość zmiennej poza funkcją). Aby pozwolić funkcji na modyfikację jej jej argumentów, muszą one być podane przez referencję.
Aby argument zawsze był podawany przez referencję, poprzedź nazwę argumentu znakiem (&) w definicji funkcji:
Przykład #2 Podawanie parametrów funkcji przez referencję
<?php
function add_some_extra(&$string)
{
$string .= 'i coś ekstra.';
}
$str = 'To jest ciąg znaków, ';
add_some_extra($str);
echo $str; // wypisuje 'To jest ciąg znaków, i coś ekstra.'
?>
Domyślne wartości argumentów
Można zdefiniować domyślne wartości skalarne argumentów w stylu C++ następująco:
Przykład #3 Użycie domyślnych wartości argumentów w funkcji
<?php
function makecoffee($type = "cappuccino")
{
return "Robię filiżankę $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>
Powyższy przykład wyświetli:
Robię filiżankę cappuccino. Robię filiżankę . Robię filiżankę espresso.
PHP pozwala również na użycie tablic(array) i specjalnego typu NULL
jako domyślnych wartości, na przykład:
Przykład #4 Użycie nie-skalarnych typów jako domyślnych wartości
<?php
function makecoffee($types = array("cappuccino"), $coffeeMaker = NULL)
{
$device = is_null($coffeeMaker) ? "rąk" : $coffeeMaker;
return "Robię kubek ".join(", ", $types)." za pomocą $device.\n";
}
echo makecoffee();
echo makecoffee(array("cappuccino", "lavazza"), "teapot");
?>
Domyślna wartość musi być stałym wyrażeniem, a nie na przykład zmienną, członkiem klasy czy wywołaniem funkcji.
Zauważ, że przy użyciu domyślnych wartości, powinne one być zdefiniowane po prawej stronie nie-domyślnych argumentów; W przeciwnym wypadku, nie zadziała to jak powinno. Na przykład:
Przykład #5 Niepoprawne użycie domyślnych wartości argumentów
<?php
function jogurt($typ = "homogenizowany", $smak)
{
return "Robię $typ jogurt $smak.\n";
}
echo jogurt("malinowy"); // nie zadziała tak, jak oczekujemy
?>
Powyższy przykład wyświetli:
Warning: Missing argument 2 in call to jogurt() in /usr/local/etc/httpd/htdocs/phptest/functest.html on line 41 Robię malinowy jogurt .
Porównaj go teraz z:
Przykład #6 Poprawne użycie domyślnych wartości argumentów
<?php
function jogurt($smak, $typ = "homogenizowany")
{
return "Robię $typ jogurt $smak.\n";
}
echo makeyogurt("malinowy"); // działa zgodnie z naszymi oczekiwaniami
?>
Powyższy przykład wyświetli:
Robię homogenizowany jogurt malinowy.
Informacja: Od PHP 5 argumenty, które są przekazywane przez referencję, mogą mieć wartości domyślne.
Deklaracje typów
Informacja:
Deklaracje typów w PHP 5 były znane jako type hinting.
Dekleracje typów pozwalają funkcjom na wymaganie argumentów określonego typu podczas ich wywoływania. Jeżeli dana wartość nie jest oczekiwanego typu, generowany jest błąd: w PHP 5 był to recoverable fatal error, a PHP 7 rzuci wyjątek TypeError.
Aby określić deklarację typu, nazwa typu musi być podana przed nazwą
parametru. Można zadeklarować parametr tak, aby przyjmował wartości
typu NULL, jeżeli jego wartość domyślną ustawimy na NULL
Prawidłowe typy
| Typ | Opis | Minimalna wersja PHP |
|---|---|---|
| Nazwa klasy/interfejsu | Argument musi być instancją klasy o danej nazwie lub implementującą podany interfejs. | PHP 5.0.0 |
| self | Parametr musi być instancją tej samej klasy, w której zdefiniowano metodę. Tego typu można użyć tylko w metodach klasy lub instancji. | PHP 5.0.0 |
| array | Argument musi być tablicą (array). | PHP 5.1.0 |
| callable | Argument musi być typu callable. | PHP 5.4.0 |
| bool | Argument musi być typu logicznego (boolean). | PHP 7.0.0 |
| float | Argument musi być liczbą zmiennoprzecinkową (float). | PHP 7.0.0 |
| int | Argument musi być liczbą całkowitą (integer). | PHP 7.0.0 |
| string | Argument musi być łańcuchem znaków (string). | PHP 7.0.0 |
| iterable | Argument musi być tablicą (array) lub instanceof Traversable. | PHP 7.1.0 |
| object | Argument musi być obiektem (object). | PHP 7.2.0 |
Ostrzeżenie
Aliasy powyższych typów skalarnych nie są obsługiwane. Zostaną one w natomiast potraktowane jak nazwy klas lub interfejsów. Przykładowo, użycie boolean jako zwracanego typu lub typu argumentu będzie wymagało, aby argument lub zwracana wartość były instancją klasy lub interfejsu o nazwie boolean a nie typu bool:
<?php
function test(boolean $param) {}
test(true);
?>
Powyższy przykład wyświetli:
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
Przykłady
Przykład #7 Podstawowe deklaracje typu klasy
<?php
class C {}
class D extends C {}
// Ta klasa nie rozszerza C.
class E {}
function f(C $c) {
echo get_class($c)."\n";
}
f(new C);
f(new D);
f(new E);
?>
Powyższy przykład wyświetli:
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
Przykład #8 Podstawowa dekleracja typu interfejsu
<?php
interface I { public function f(); }
class C implements I { public function f() {} }
// Ta klasa nie implementuje interfejsu I.
class E {}
function f(I $i) {
echo get_class($i)."\n";
}
f(new C);
f(new E);
?>
Powyższy przykład wyświetli:
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
Przykład #9 Typowanie argumentów przekazywanych przez referencję
Zadeklarowane typy argumentów przekazywanych przez referencję są sprawdzane na wejściu do funkcji, ale nie gdy funkcja zwraca, więc typ argumentu może się zmienić po tym gdy funkcja zwróciła.
<?php
function array_baz(array &$param)
{
$param = 1;
}
$var = [];
array_baz($var);
var_dump($var);
array_baz($var);
?>
Powyższy przykład wyświetli coś podobnego do:
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
Przykład #10 Deklaracje typu akceptujące NULL
<?php
class C {}
function f(C $c = null) {
var_dump($c);
}
f(new C);
f(null);
?>
Powyższy przykład wyświetli:
object(C)#1 (0) {
}
NULL
Typowanie ścisłe
Domyślnie PHP wymusi zmianę nieprawidłowego typu na poprawny, o ile jest to możliwe. Przykładowo, funkcja, ktora otrzymała argument typu integer, mimo iż oczekiwała łańcucha znaków, ostatecznie otrzyma zmienną typu string.
Dla danego pliku można włączyć tryb ścisły. W trybie ścisłym zaakeptowana będzie tylko zmienna dokładnie takiego typu, w przeciwnym wypadku zostanie rzucony wyjątek TypeError. Jedynym odstępstwem od reguły jest przekazanie integera do funkcji oczekującej typu float. Wywołania funkcji z wewnątrz wbudowanych funkcji nie są dotknięte deklaracją strict_types.
Do włączenia trybu ścisłego używana jest konstrukcja declare połączona z deklaracją strict_types:
Uwaga
Włączenie trybu ścisłego ma także wpływ na deklaracje typu zwracanych wartości.
Informacja:
Ścisłe typowanie odnosi się do wywołań funkcji wewnątrz pliku z włączonym ścisłym typowaniem, nie do funkcji zadeklarowanych w tym pliku. Jeżeli plik bez włączonego ścisłego typowania wykonuje funkcję zadeklarowaną w pliku z włączonym ścisłym typowaniem, to pod uwagę wzięte zostanie ustawienie z pliku wywołującego (brak ścisłego typowania), a więc wartość będzie miała dopasowany typ.
Informacja:
Ścisłe typowanie działa tylko dla deklaracji typów skalarnych (scalar type declarations), a więc wymaga PHP 7.0.0 lub nowszego, ponieważ dopiero tam zostały one dodane.
Przykład #11 Ścisłe typowanie
<?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));
?>
Powyższy przykład wyświetli:
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
Przykład #12 Słabe typowanie
<?php
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
// Te wartości zostaną przekształcone na liczby całkowite: zwróć uwagę na wynik działania!
var_dump(sum(1.5, 2.5));
?>
Powyższy przykład wyświetli:
int(3) int(3)
Przykład #13 Łapanie wyjątku 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 'Błąd: '.$e->getMessage();
}
?>
Powyższy przykład wyświetli:
int(3) Error: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 10
Podawanie różnej ilości argumentów
PHP wspiera użycie różnej ilości argumentów dla funkcji definiowanych przez użytkownika. Jest to możliwe dzięki użyciu tokena ... w PHP 5.6 i nowszych lub dzięki funkcjom func_num_args(), func_get_arg() i func_get_args() w PHP 5.5 i wcześniejszych.
... w PHP 5.6+
W PHP 5.6 i nowszych lista argumentów może zawierać token ..., który oznacza, że funkcja akceptuje zmienną ilość argumentów. Argumenty zostaną przekazane do do podanej zmiennej jako tablica, na przykład:
Przykład #14 Użycie ... do zmiennej ilości argumentów
<?php
function suma(...$liczby) {
$wynik = 0;
foreach ($liczby as $liczba) {
$wynik += $liczba;
}
return $wynik;
}
echo suma(1, 2, 3, 4);
?>
Powyższy przykład wyświetli:
10
Możesz także użyć ... podczas wywoływania funkcji, aby rozpakować zmienną tablicową lub Traversable, albo literal do listy argumentów:
Przykład #15 Użycie ... do dostarczenia argumentów
<?php
function dodaj($a, $b) {
return $a + $b;
}
echo dodaj(...[1, 2])."\n";
$a = [1, 2];
echo dodaj(...$a);
?>
Powyższy przykład wyświetli:
3 3
Możesz określić normalne argumenty pozycyjne przed tokenem .... W tym wypadku tylko końcowe argumenty, które nie pasują do żadnego argumentu pozycyjnego, zostaną dodane do tablicy generowanej przez ....
Jest także możliwe wskazanie typu przez tokenem .... Jeżeli jest to obecne, to wszystkie argumenty pokrywane przez ... muszą być obiektami wskazanej klasy.
Przykład #16 Różna ilość argumentów z określeniem typu
<?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).' dni';
// Jest to błędem, ponieważ null nie jest obiektem klasy DateInterval.
echo total_intervals('d', null);
?>
Powyższy przykład wyświetli:
3 dni 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
W końcu, możesz podać także różną ilość argumentów przez referencję prefiksując ... znakiem ampersand (&).
Starsze wersje PHP
Do określenia, że funkcja przyjmuje zmienną ilość argumentów, nie jest wymagana specjalna składnia; jednak uzyskanie dostępu do argumentów funkcji wymaga użycia func_num_args(), func_get_arg() i func_get_args().
Pierwszy przykład podany wyżej, w wersji PHP 5.5 i starszych, zostałby zapisany następująco
Przykład #17 Dostęp do zmiennej ilości argumentów w PHP 5.5 i starszych
<?php
function suma() {
$wynik = 0;
foreach (func_get_args() as $liczba) {
$wynik += $liczba;
}
return $wynik;
}
echo sum(1, 2, 3, 4);
?>
Powyższy przykład wyświetli:
10
add a note
User Contributed Notes 15 notes
php at richardneill dot org ¶
9 years ago
gabriel at figdice dot org ¶
7 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
?>
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
?>
Sergio Santana: ssantana at tlaloc dot imta dot mx ¶
18 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.
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
?>
info at keraweb dot nl ¶
6 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"
Hayley Watson ¶
6 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.
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
Horst Schirmeier ¶
10 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; }).
Hayley Watson ¶
6 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.
rsperduta at gmail dot com ¶
3 years 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).
shaman_master at list dot ru ¶
4 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);
}
}
?>
dmitry dot balabka at gmail dot com ¶
5 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
John ¶
17 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)
igorsantos07 at gmail dot com ¶
6 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
?>
