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 bağımsız değişkenleri
Bir işleve veri, virgül ayraçlı ifadelerden oluşan bir bağımsız değişken listesi ile aktarılır. İşlev çalıştırılmadan önce bağımsız değişkenler soldan sağa doğru değerlendirilir (hevesli değerlendirme).
PHP, bağımsız değişkenlerin değerleriyle aktarılmalarını (öntanımlı), gönderimli aktarımı ve öntanımlı bağımsız değişken kullanımını destekler. Bağımsız değişken sayısı değişken işlevler ve İsimli bağımsız değişkenler de desteklenmektedir.
Örnek 1 - İşlevlere dizi aktarımı
<?php
function dizi_kabul_eder($girdi)
{
echo "$girdi[0] + $girdi[1] = ", $girdi[0]+$girdi[1];
}
?>PHP 8.0.0'dan itibaren, işlev bağımsız değişkenlerinin sonunda göz ardı edilecek bir virgül bulunabilir. Bu, özellikle bağımsız değişken listesinin uzun olduğu veya uzun isimler içerdiği durumlarda, bağımsız değişkenleri alt alta sıralamayı kolaylaştırır.
Örnek 2 - Virgül ile sonlanan işlev bağımsız değişkenleri ö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.
)
{
// ...
}
?>Gönderimli bağımsız değişken kullanımı
Öntanımlı olarak, işlev bağımsız değişkenleri değerleriyle aktarılırlar (bu durumda bir bağımsız değişkenin 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 bağımsız değişken kullanmalısınız.
Bir işleve bir bağımsız değişkenin daima gönderimli olarak aktarılmasını istiyorsanız, işlev bildiriminde o bağımsız değişkenin başına & karakterini koyarak bunu sağlayabilirsiniz:
Örnek 3 - Gönderimli işlev bağımsız değişkenlerinin 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.
?>Gönderimli aktarılması beklenen bir değeri değişkeniyle değil değeriyle aktarmak bir hatadır.
Öntanımlı bağımsız değişken değerleri
Bir işlevde, bağımsız değişkenler için öntanımlı değerler, değişken ataması
biçiminde tanımlanabilir. Öntanımlı değer sadece işlev çağrısı
sırasında bağımsız değişken belirtilmemişse kullanılır. Şuna özellikle
dikkat edilmelidir: null değer öntanımlı değer olarak tanımlanamaz.
Örnek 4 - İşlev içinde öntanımlı bağımsız değişken 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.
Öntanımlı değer olarak, diziler, özel null türü ve PHP 8.1.0 itibariyle
new SınıfAdı() sözdizimi ile
nesneler kullanılabilir.
Örnek 5 - 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");
?>
Örnek 6 - Öntanımlı değer olarak nesne kullanımı (PHP 8.1.0 ve sonrası)
<?php
class ÖntanımlıDemleyici {
public function demle() {
return 'Çay demleniyor.';
}
}
class PorselenDemleyici {
public function demle() {
return 'Özel çayınız demleniyor.';
}
}
function çayyap($demleyici = new ÖntanımlıDemleyici)
{
return $demleyici->demle();
}
echo çayyap();
echo çayyap(new PorselenDemleyici);
?>Ö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ı bağımsız değişkenleri kullanırken, öntanımlama yapılmış tüm bağımsız değişkenlerin öntanımlama yapılmamış tüm bağımsız değişkenlerden sonra yer alması gerektiğine dikkat edin. Aksi takdirde çağrı sırasında bunlar atlanamaz. Aşağıdaki örneği inceleyin:
Örnek 7 - Öntanımlı bağımsız değişkenlerin hatalı kullanımı
<?php
function yoğurtyap($miktar = "az", $katkı)
{
return "Bir kase $miktar $katkı içeren yoğurt yapılıyor.\n";
}
echo yoğurtyap("çilek"); // "çilek" $miktar olarak işleme alınır ve
// tek bağımsız değişken aktarımı hataya yol açar.
?>Yukarıdaki örneğin çıktısı:
Fatal error: Uncaught ArgumentCountError: Too few arguments to function yoğurtyap(), 1 passed in dnm.php on line 7 and exactly 2 expected in dnm.php:2
Stack trace:
#0 dnm.php(7): yoğurtyap('\xC3\xA7ilekli')
#1 {main}
thrown in dnm.php on line 2
Şimdi, yukarıdakini bununla karşılaştıralım:
Örnek 8 - Öntanımlı bağımsız değişkenlerin doğru kullanımı
<?php
function yoğurtyap($katkı, $miktar = "az")
{
return "Bir kase $miktar $katkı içeren yoğurt yapılıyor.\n";
}
echo yoğurtyap("çilek"); // "çilek" $katkı olarak işleme alınır
?>Yukarıdaki örneğin çıktısı:
Bir kase az çilek içeren yoğurt yapılıyor.
PHP 8.0.0 ve sonrasında, çok sayıda seçimlik bağımsız değişkeni atlamak için isimli bağımsız değişkenler kullanılabilir.
Örnek 9 - Öntanımlı işlev bağımsız değişkenlerinin doğru kullanımı
<?php
function yoğurtyap($katkı = "şeker", $miktar = "az", $tarz = "doğal")
{
return "Bir kase $miktar $katkı içeren $tarz yoğurt yapılıyor.\n";
}
echo makeyogurt($tarz: "süzme");
?>Yukarıdaki örneğin çıktısı:
Bir kase az çilek içeren süzme yoğurt yapılıyor.
PHP 8.0.0 ve sonrasında, işlev çağrısında zorunlu bağımsız değişkenlerin
seçimliklerden sonra tanımlanması kullanımdan
kaldırılmıştır. Bu genellikle, kullanılmayacak olan öntanımlı
değer atlanarak çözümlenir. Bunun tek istisnası, türü örtük olarak null
yapan Tür $param = null biçimindeki bağımsız değişkenlerdir. Bunun
kullanımına hala izin verilmekteyse de bunun yerine,
null olabilen
tür kullanımı önerilmektedir.
Örnek 10 - Seçimliklerin zorunlu bağımsız değişkenlerden sonra bildirimi
<?php
function foo($a = [], $b) {} // Öntanımlı bağımsız değişken böyle kullanılamaz;
// PHP 8.0.0 ve sonrasında kullanımda değil
function foo($a, $b) {} // İşlevsel olarak aynı, bir uyarı verilmez
function bar(A $a = null, $b) {} // Hala izin veriliyor; $a null olabiliyor
function bar(?A $a, $b) {} // Önerilen kullanım
?>Bilginize: PHP 7.1.0 ve sonrasında, öntanımlı değer belirtilmemiş bir bağımsız değişkenin atlanması ArgumentCountError yavrulanmasına yol açmaktadır; önceki sürümlerde sadece bir uyarı çıktılanırdı.
Bilginize: Gönderimli aktarılabilen bağımsız değişkenler öntanımlı değer içerebilir.
Değişken uzunlukta bağımsız değişken listesi
PHP, kullanıcı tanımlı işlevlerde bağımsız değişken listesinin sonuna
... konarak listenin uzatılmasını destekler.
Bağımsız değişken listeleri, işlevin değişken sayıda bağımsız değişken kabul ettiğini
belirtmek için ... simgesini içerebilir. Bu durumda
bağımsız değişkenler değişkene bir dizi olarak aktarılır:
Örnek 11 - Değişken uzunlukta bağımsız değişkenler 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 bağımsız değişken listesi haline getirmek için işlev çağrılırken de
... kullanılabilir. Örnek:
Örnek 12 -Bağımsız değişkenlere 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 bağımsız değişkenler
belirtilebilir. Bu durumda ... ile üretilen diziye
sadece konumsal bağımsız değişkenlerle eşleşen sonuncu bağımsız değişkeni izleyen
eşleşmeyen bağımsız değişkenler eklenir.
... dizgeciğinin önüne tür bildirimi de
eklenebilir. Bu durumda ... kapsamındaki tüm
bağımsız değişkenlerin bu tür bildirimi ile eşleşmesi gerekir.
Örnek 13 Değişken bağımsız değişkenlerde 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 bağımsız değişkenleri
gönderimli
olarak da aktarabilirsiniz.
İsimli bağımsız değişkenler
PHP 8.0.0, var olan konumsal bağımsız değişkenlerin bir uzantısı olarak isimli bağımsız değişkenleri tanıttı. İsimli bağımsız değişkenler, bağımsız değişkenlerin konuma göre değil bağımsız değişken adına göre işleve iletilmesine izin verir. Bu, bağımsız değişkeni kendini belgelendiren bağımsız değişken haline, bağımsız değişkenleri de sıralamadan bağımsız hale getirir ve öntanımlı değerlerin keyfi olarak atlanmasına izin verir.
İsimli bağımsız değişkenler, değerin önüne iki nokta üst üste ile bağımsız değişken adı eklenerek iletilir. Ayrılmış anahtar sözcüklerin bağımsız değişken adları olarak kullanılmasına izin verilir. Bağımsız değişken adı bir tanımlayıcı olmalıdır, bir değişkenle belirtilmesine izin verilmez.
Örnek 14 - İsimli bağımsız değişken sözdizimi
<?php
işlevim(değişkenAdı: $değer);
array_foobar(array: $değer);
// desteklenmiyor
işlev_adı($değişkeneSaklanmışBağımsızDeğişkenAdı: $$değer);
?>Örnek 15 - Konumsal ve isimli bağımsız değişkenler
<?php
// Konumsal bağımsız değişkenler:
array_fill(0, 100, 50);
// İsimli bağımsız değişkenler:
array_fill(start_index: 0, count: 100, value: 50);
?>İsimli bağımsız değişkenlerin aktarılma sırasının bir önemi yoktur.
Örnek 16 - Farklı bağımsız değişken sırasıyla yukarıdaki örnek
<?php
array_fill(value: 50, count: 100, start_index: 0);
?>İsimli bağımsız değişkenler konumsal bağımsız değişkenlerle birleştirilebilir. Bu durumda, isimli bağımsız değişkenler konumsal bağımsız değişkenlerden sonra gelmelidir. Sıralarına bakılmaksızın, bir işlevin isteğe bağlı bağımsız değişkenlerinden yalnızca bazılarını belirtmek de mümkündür.
Örnek 17 - İsimli bağımsız değişkenlerle konumsal bağımsız değişkenleri birleştirmek
<?php
htmlspecialchars($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>Aynı bağımsız değişkeni birden fazla kullanmak bir Error istisnasına yol açar.
Örnek 18 - Aynı bağımsız değişkenin birden fazla kullanımında Error yavrulanması
<?php
function foo($param) { ... }
foo(param: 1, param: 2);
// Hata: $param isimli bağımsız değişkeni önceki bağımsız değişkeni geçersiz kılıyor
foo(1, param: 2);
// Hata: $param isimli bağımsız değişkeni önceki bağımsız değişkeni geçersiz kılıyor
?>PHP 8.1.0 itibariyle, bağımsız değişken genişletmesinden sonra isimli bağımsız değişken kullanımına izin verilmektedir ancak, isimli bağımsız değişkenin genişletmedeki bağımsız değişkeni geçersiz kılmaması gerekir.
Örnek 19 - Genişletme sonrası isimli bağımsız değişken kullanımı
<?php
function foo($a, $b, $c = 3, $d = 4) {
return $a + $b + $c + $d;
}
var_dump(foo(...[1, 2], d: 40)); // 46
var_dump(foo(...['b' => 2, 'a' => 1], d: 40)); // 46
var_dump(foo(...[1, 2], b: 20)); // Ölümcül hata. İsimli bağımsız değişken $b, genişletmedekini geçersiz kılıyor
?>
add a note
User Contributed Notes 14 notes
php at richardneill dot org ¶
9 years ago
Simmo at 9000 dot 000 ¶
2 years ago
For anyone just getting started with php or searching, for an understanding, on what this page describes as a "... token" in Variable-length arguments:
https://www.php.net/manual/en/functions.arguments.php#functions.variable-arg-list
<?php
func($a, ...$b)
?>
The 3 dots, or elipsis, or "...", or dot dot dot is sometimes called the "spread operator" in other languages.
As this is only used in function arguments, it is probably not technically an true operator in PHP. (As of 8.1 at least?).
(With having an difficult to search for name like "... token", I hope this note helps someone).
LilyWhite ¶
3 years ago
It is worth noting that you can use functions as function arguments
<?php
function run($op, $a, $b) {
return $op($a, $b);
}
$add = function($a, $b) {
return $a + $b;
};
$mul = function($a, $b) {
return $a * $b;
};
echo run($add, 1, 2), "\n";
echo run($mul, 1, 2);
?>
Output:
3
2
tianyiw at vip dot qq dot com ¶
2 years ago
<?php
/**
* Create an array using Named Parameters.
*
* @param mixed ...$values
* @return array
*/
function arr(mixed ...$values): array
{
return $values;
}
$arr = arr(
name: 'php',
mobile: 123456,
);
var_dump($arr);
// array(2) {
// ["name"]=>
// string(3) "php"
// ["mobile"]=>
// int(123456)
// }
gabriel at figdice dot org ¶
8 years ago
A function's argument that is an object, will have its properties modified by the function although you don't need to pass it by reference.
<?php
$x = new stdClass();
$x->prop = 1;
function f ( $o ) // Notice the absence of &
{
$o->prop ++;
}
f($x);
echo $x->prop; // shows: 2
?>
This is different for arrays:
<?php
$y = [ 'prop' => 1 ];
function g( $a )
{
$a['prop'] ++;
echo $a['prop']; // shows: 2
}
g($y);
echo $y['prop']; // shows: 1
?>
Hayley Watson ¶
7 years ago
There are fewer restrictions on using ... to supply multiple arguments to a function call than there are on using it to declare a variadic parameter in the function declaration. In particular, it can be used more than once to unpack arguments, provided that all such uses come after any positional arguments.
<?php
$array1 = [[1],[2],[3]];
$array2 = [4];
$array3 = [[5],[6],[7]];
$result = array_merge(...$array1); // Legal, of course: $result == [1,2,3];
$result = array_merge($array2, ...$array1); // $result == [4,1,2,3]
$result = array_merge(...$array1, $array2); // Fatal error: Cannot use positional argument after argument unpacking.
$result = array_merge(...$array1, ...$array3); // Legal! $result == [1,2,3,5,6,7]
?>
The Right Thing for the error case above would be for $result==[1,2,3,4], but this isn't yet (v7.1.8) supported.
boan dot web at outlook dot com ¶
6 years ago
Quote:
"The declaration can be made to accept NULL values if the default value of the parameter is set to NULL."
But you can do this (PHP 7.1+):
<?php
function foo(?string $bar) {
//...
}
foo(); // Fatal error
foo(null); // Okay
foo('Hello world'); // Okay
?>
Luna ¶
1 year ago
When using named arguments and adding default values only to some of the arguments, the arguments with default values must be specified at the end or otherwise PHP throws an error:
<?php
function test1($a, $c, $b = 2)
{
return $a + $b + $c;
}
function test2($a, $b = 2, $c)
{
return $a + $b + $c;
}
echo test1(a: 1, c: 3)."\n"; // Works
echo test2(a: 1, c: 3)."\n"; // ArgumentCountError: Argument #2 ($b) not passed
?>
I assume that this happens because internally PHP rewrites the calls to something like test1(1, 3) and test2(1, , 3). The first call is valid, but the second obviously isn't.
Sergio Santana: ssantana at tlaloc dot imta dot mx ¶
19 years ago
PASSING A "VARIABLE-LENGTH ARGUMENT LIST OF REFERENCES" TO A FUNCTION
As of PHP 5, Call-time pass-by-reference has been deprecated, this represents no problem in most cases, since instead of calling a function like this:
myfunction($arg1, &$arg2, &$arg3);
you can call it
myfunction($arg1, $arg2, $arg3);
provided you have defined your function as
function myfuncion($a1, &$a2, &$a3) { // so &$a2 and &$a3 are
// declared to be refs.
... <function-code>
}
However, what happens if you wanted to pass an undefined number of references, i.e., something like:
myfunction(&$arg1, &$arg2, ..., &$arg-n);?
This doesn't work in PHP 5 anymore.
In the following code I tried to amend this by using the
array() language-construct as the actual argument in the
call to the function.
<?php
function aa ($A) {
// This function increments each
// "pseudo-argument" by 2s
foreach ($A as &$x) {
$x += 2;
}
}
$x = 1; $y = 2; $z = 3;
aa(array(&$x, &$y, &$z));
echo "--$x--$y--$z--\n";
// This will output:
// --3--4--5--
?>
I hope this is useful.
Sergio.
jcaplan at bogus dot amazon dot com ¶
18 years ago
In function calls, PHP clearly distinguishes between missing arguments and present but empty arguments. Thus:
<?php
function f( $x = 4 ) { echo $x . "\\n"; }
f(); // prints 4
f( null ); // prints blank line
f( $y ); // $y undefined, prints blank line
?>
The utility of the optional argument feature is thus somewhat diminished. Suppose you want to call the function f many times from function g, allowing the caller of g to specify if f should be called with a specific value or with its default value:
<?php
function f( $x = 4 ) {echo $x . "\\n"; }
// option 1: cut and paste the default value from f's interface into g's
function g( $x = 4 ) { f( $x ); f( $x ); }
// option 2: branch based on input to g
function g( $x = null ) { if ( !isset( $x ) ) { f(); f() } else { f( $x ); f( $x ); } }
?>
Both options suck.
The best approach, it seems to me, is to always use a sentinel like null as the default value of an optional argument. This way, callers like g and g's clients have many options, and furthermore, callers always know how to omit arguments so they can omit one in the middle of the parameter list.
<?php
function f( $x = null ) { if ( !isset( $x ) ) $x = 4; echo $x . "\\n"; }
function g( $x = null ) { f( $x ); f( $x ); }
f(); // prints 4
f( null ); // prints 4
f( $y ); // $y undefined, prints 4
g(); // prints 4 twice
g( null ); // prints 4 twice
g( 5 ); // prints 5 twice
?>
catman at esteticas dot se ¶
8 years ago
I wondered if variable length argument lists and references works together, and what the syntax might be. It is not mentioned explicitly yet in the php manual as far as I can find. But other sources mention the following syntax "&...$variable" that works in php 5.6.16.
<?php
function foo(&...$args)
{
$i = 0;
foreach ($args as &$arg) {
$arg = ++$i;
}
}
foo($a, $b, $c);
echo 'a = ', $a, ', b = ', $b, ', c = ', $c;
?>
Gives
a = 1, b = 2, c = 3
Hayley Watson ¶
7 years ago
If you use ... in a function's parameter list, you can use it only once for obvious reasons. Less obvious is that it has to be on the LAST parameter; as the manual puts it: "You may specify normal positional arguments BEFORE the ... token. (emphasis mine).
<?php
function variadic($first, ...$most, $last)
{/*etc.*/}
variadic(1, 2, 3, 4, 5);
?>
results in a fatal error, even though it looks like the Thing To Do™ would be to set $first to 1, $most to [2, 3, 4], and $last to 5.
info at keraweb dot nl ¶
7 years ago
You can use a class constant as a default parameter.
<?php
class A {
const FOO = 'default';
function bar( $val = self::FOO ) {
echo $val;
}
}
$a = new A();
$a->bar(); // Will echo "default"
John ¶
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)
