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".
*/
?>
İşlev değiştirgeleri
Bir işleve veri, virgül ayraçlı ifadelerden oluşan bir değiştirge listesi ile aktarılır. Değitirgeler soldan sağa doğru değerlendirilir.
PHP, değiştirgelerin değerleriyle aktarılmalarını (öntanımlı), gönderimli aktarımı ve öntanımlı değiştirge kullanımını destekler. Değiştirge sayısı değişken işlevler ve İsimli değiştirgeler de desteklenmektedir.
Örnek 1 - İşlevlere dizi aktarımı
<?php
function dizi_kabul_eder($girdi)
{
echo "$girde[0] + $girdi[1] = ", $girdi[0]+$girdi[1];
}
?>
PHP 8.0.0'dan itibaren, işlev değiştirgelerinin sonunda göz ardı edilecek bir virgül bulunabilir. Bu, özellikle değiştirge listesinin uzun olduğu veya uzun isimler içerdiği durumlarda, değiştirgeleri alt alta sıralamayı kolaylaştırır.
Örnek 2 - Virgül ile sonlanan işlev değiştirgeleri örneği
<?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 öncesinde bu virgüle izin verilmezdi.
)
{
// ...
}
?>
PHP 8.0.0'dan itibaren, zorunlu değiştirgelerin seçimlik değiştirgelerden
sonra aktarımı kullanımdan kaldırılmıştır. Bu sorun genellikle öntanımlı
değeri yazmamak suretiyle çözümlenebilir. Bunun tek istisnası null
öntanımlamasının türü örtük olarak nullable yapan Type $param =
null şeklindeki değiştirgelerdir. Bu kullanımda kalmışsa da örtük
bir nullable türü kullanılacaksa önerilir.
Örnek 3 - Zorunlu değiştirgelerin seçimliklerden sonra kullanımı
<?php
function foo($a = [], $b) {} // Önce
function foo($a, $b) {} // Sonra
function bar(A $a = null, $b) {} // Hala kullanımda
function bar(?A $a, $b) {} // Önerilen
?>
Gönderimli değiştirge kullanımı
Öntanımlı olarak, işlev değiştirgeleri değerleriyle aktarılırlar (bu durumda bir değiştirgenin değeri işlev içinde değiştirildiğinde işlevin çağrıldığı yerdeki değeri bundan etkilenmez. İşlevin çağrıldığı yerdeki değerinin de değişmesini istiyorsanız gönderimli değiştirge kullanmalısınız.
Bir işleve bir değiştirgenin daima gönderimli olarak aktarılmasını istiyorsanız, işlev tanımladığınız yerde o değiştirgenin başına & karakterini koyarak bunu sağlayabilirsiniz:
Örnek 4 - Gönderimli işlev değiştirgelerinin aktarımı
<?php
function şunu_da_ekle(&$dizge)
{
$dizge .= 've bir kaç karakter eklenmiştir.';
}
$dzg = 'Bu bir dizgedir ';
şunu_da_ekle($dzg);
echo $dzg; // 'Bu bir dizgedir ve bir kaç karakter eklenmiştir.'
// çıktısını verir.
?>
Başvuruyla iletilmesi beklenen bir değeri değiştirge olarak iletmek bir hatadır.
Öntanımlı değiştirge değerleri
Bir işlevde, sayıl değiştirgeler için C++ tarzı öntanımlı değerler aşağıdaki biçimde tanımlanabilir:
Örnek 5 - İşlev içinde öntanımlı değiştirge kullanımı
<?php
function kahveyap($hangisi = "orta şekerli")
{
return "Bir fincan $hangisi kahve yapalım.\n";
}
echo kahveyap();
echo makecoffee(null);
echo kahveyap("az şekerli");
?>
Yukarıdaki örneğin çıktısı:
Bir fincan orta şekerli kahve yapalım. Bir fincan kahve yapalım. Bir fincan az şekerli kahve yapalım.
PHP ayrıca, öntanımlı değer olarak dizilerin ve özel null türünün
kullanımına da izin verir, örneğin:
Örnek 6 - Sayıl olmayan türlerin öntanımlı değer olarak kullanımı
<?php
function kahveyap($hangi = array("orta şekerli"), $neyde = NULL)
{
$neyde = is_null($neyde) ? "ocakta" : $neyde;
return "Bir fincan ".join(" bir fincan ", $hangi)." kahve $neyde yapıldı.\n";
}
echo kahveyap();
echo kahveyap(array("çok şekerli", "az şekerli"), "mangalda");
?>
Öntanımlı değer bir değişken, bir sınıf üyesi ya da bir işlev çağrısı değil, bir sabit ifadesi olmalıdır.
Öntanımlı değiştirgeleri kullanırken, öntanımlama yapılmış tüm değiştirgelerin öntanımlama yapılmamış tüm değiştirgelerin sağında yer almasına gerektiğine dikkat edin. Aksi takdirde işler yolunda gitmeyebilir. Aşağıdaki kod parçasını inceleyin:
Örnek 7 - Öntanımlı değiştirgelerin hatalı kullanımı
<?php
function yoğurtyap($nekadar = "az", $neli)
{
return "Bir kase $nekadar $neli yoğurt yap.\n";
}
echo yoğurtyap("çilekli"); // beklendiği gibi çalışmayacaktır
?>
Yukarıdaki örneğin çıktısı:
Warning: Missing argument 2 for yoğurtyap(), called in /home/nilgun/dnm/php-dnm on line 7 and defined in /home/nilgun/dnm/php-dnm on line 2 Bir kase çilekli yoğurt yap.
Şimdi, yukarıdakini bununla karşılaştıralım:
Örnek 8 - Öntanımlı değiştirgelerin doğru kullanımı
<?php
function yoğurtyap($neli, $nekadar= "az")
{
return "Bir kase $nekadar $neli yoğurt yap.\n";
}
echo yoğurtyap("çilekli"); // beklendiği gibi çalışır
?>
Yukarıdaki örneğin çıktısı:
Bir kase az çilekli yoğurt yap.
Bilginize: Gönderimli aktarılabilen değiştirgeler öntanımlı değer içerebilir.
Değişken uzunlukta değiştirge listesi
PHP, kullanıcı tanımlı işlevlerde değiştirge listesinin sonuna
... konarak listenin uzatılmasını destekler.
Bilginize: Değişken uzunlukta değiştirge listesi func_num_args(), func_get_arg() ve func_get_args() işlevleri kullanılarak da elde edilebilir. Bu teknik
...kullanımından öncesine ait olduğundan kullanımı önerilmez.
Değiştirge listeleri, işlevin değişken sayıda değiştirge kabul ettiğini
belirtmek için ... simgesini içerebilir. Bu durumda
değiştirgeler değişkene bir dizi olarak aktarılır. Örneğin:
Örnek 9 - Değişken uzunlukta değiştirgeler için ... kullanımı
<?php
<?php
function sum(...$numbers) {
$acc = 0;
foreach ($numbers as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
Yukarıdaki örneğin çıktısı:
10
Bir diziyi, bir Traversable değişkeni veya bir
sabiti değiştirge listesi haline getirmek için işlev çağrılırken de
... kullanılabilir. Örnek:
Örnek 10 Değiştirgelere erişmek için ...
kullanımı
<?php
function add($a, $b) {
return $a + $b;
}
echo add(...[1, 2])."\n";
$a = [1, 2];
echo add(...$a);
?>
Yukarıdaki örneğin çıktısı:
3 3
... dizgeciğinden önce normal konumsal değiştirgeler
belirtilebilir. Bu durumda ... ile üretilen diziye
sadece bir konumsal değiştirge ile eşleşmeyen tokeni izleyen değiştirgeler
eklenir.
Örnek 11 Değişken değiştirgelerinde tür bildirimi
<?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).' gün';
// Bir DateInterval nesnesi olmadığından bu başarısız olur.
echo total_intervals('d', null);
?>
Yukarıdaki örneğin çıktısı:
3 gün 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
Son olarak, ... dizgeciğinin önüne bir
& ekleyerek değişken değiştirgelerini
gönderimli
olarak da aktarabilirsiniz.
Daha eski PHP sürümlerinde
Bir işlevin değişken sayıda değiştirge içerebilmesi özel bir sözdizimi gerekmez; ancak işlevin değiştirgelerine erişim için func_num_args(), func_get_arg() ve func_get_args() kullanmak gerekir.
Eski PHP sürümlerinde yukarıdaki ilk örnek şöyle gerçeklenirdi;
Örnek 12 Eski PHP sürümlerinde değişken değiştirgelerine erişim
<?php
function sum() {
$acc = 0;
foreach (func_get_args() as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
Yukarıdaki örneğin çıktısı:
10
İsimli değiştirgeler
PHP 8.0.0, var olan konumsal değitirgelerin bir uzantısı olarak isimli değiştirgeleri tanıttı. İsimli değiştirgeler, değiştirgelerin konuma göre değil değiştirge adına göre işleve iletilmesine izin verir. Bu, değiştirgenin anlamını kendi kendine belgelendirir, değiştirgeleri sıralamadan bağımsız hale getirir ve öntanımlı değerlerin keyfi olarak atlanmasına izin verir.
İsimli değiştirgeler, değerin önüne iki nokta üst üste ile değiştirge adı eklenerek iletilir. Ayrılmış anahtar sözcüklerin değiştirge adları olarak kullanılmasına izin verilir. Değiştirge adı bir tanımlayıcı olmalıdır, bir değişkenle belirtilmesine izin verilmez.
Örnek 13 - İsimli değiştirge sözdizimi
<?php
işlevim(değiştirgeAdı: $değer);
array_foobar(array: $değer);
// desteklenmiyor
işlev_adı($değişkeneSaklanmışDeğiştirgeAdı: $$değer);
?>
Örnek 14 - Konumsal ve isimli değiştirgeler
<?php
// Konumsal değiştirgeler:
array_fill(0, 100, 50);
// İsimli değiştirgeler:
array_fill(start_index: 0, count: 100, value: 50);
?>
İsimli değiştirgelerin aktarılma sırasının bir önemi yoktur.
Örnek 15 - Farklı değiştirge sırasıyla yukarıdaki örnek
<?php
array_fill(value: 50, count: 100, start_index: 0);
?>
İsimli değiştirgeler konumsal değiştirgelerle birleştirilebilir. Bu durumda, isimli değiştirgeler konumsal değiştirgelerden sonra gelmelidir. Sıralarına bakılmaksızın, bir işlevin isteğe bağlı değiştirgelerinden yalnızca bazılarını belirtmek de mümkündür.
Örnek 16 - İsimli değiştirgelerle konumsal değiştirgeleri birleştirmek
<?php
htmlspecialchars($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
?>
Aynı değiştirgeyi birden fazla kullanmak bir Error istisnasına yol açar.
Örnek 17 - Aynı değiştirgeyi birden fazla kullanırken Error istisnası
<?php
function foo($param) { ... }
foo(param: 1, param: 2);
// Hata: $param isimli değiştirgesi önceki değiştirgeyi geçersiz kılıyor
foo(1, param: 2);
// $param isimli değiştirgesi önceki değiştirgeyi geçersiz kılıyor
?>
add a note
User Contributed Notes 16 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
?>
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);
}
}
?>
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
?>
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.
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
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.
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; }).
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 ¶
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.
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)
anisgazig at gmail dot com ¶
2 years ago
VALUE PASSED DIRECTLY NOT ARGUMENT SO UNDEFINE VARIABLE WILL BE SHOWN.
SO PASSING A VALUE DIRECTLY TO A FUNCTION PLEASE GLOBAL KEYWORD MUST BE USE BEFORE VARIABLE.
function myfunc22(){
global $arr;
return $arr;
}
$arr = [10,20];
echo "<pre>";
print_r(myfunc22());
echo "</pre>";
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).
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
?>
