-
Notifications
You must be signed in to change notification settings - Fork 706
/
functions.xml
1507 lines (1362 loc) · 37.4 KB
/
functions.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<chapter xml:id="language.functions" xmlns="http://docbook.org/ns/docbook">
<title>Functions</title>
<sect1 xml:id="functions.user-defined">
<title>User-defined functions</title>
<para>
A function may be defined using syntax such as the following:
</para>
<para>
<example>
<title>Pseudo code to demonstrate function uses</title>
<programlisting role="php">
<![CDATA[
<?php
function foo($arg_1, $arg_2, /* ..., */ $arg_n)
{
echo "Example function.\n";
return $retval;
}
?>
]]>
</programlisting>
</example>
</para>
<simpara>
Any valid PHP code may appear inside a function, even other
functions and <link linkend="language.oop5.basic.class">class</link>
definitions.
</simpara>
<para>
Function names follow the same rules as other labels in PHP. A
valid function name starts with a letter or underscore, followed
by any number of letters, numbers, or underscores. As a regular
expression, it would be expressed thus:
<code>^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$</code>.
</para>
&tip.userlandnaming;
<simpara>
Functions need not be defined before they are referenced,
<emphasis>except</emphasis> when a function is conditionally defined as
shown in the two examples below.
</simpara>
<para>
When a function is defined in a conditional manner such as the two
examples shown. Its definition must be processed <emphasis>prior</emphasis>
to being called.
</para>
<para>
<example>
<title>Conditional functions</title>
<programlisting role="php">
<![CDATA[
<?php
$makefoo = true;
/* We can't call foo() from here
since it doesn't exist yet,
but we can call bar() */
bar();
if ($makefoo) {
function foo()
{
echo "I don't exist until program execution reaches me.\n";
}
}
/* Now we can safely call foo()
since $makefoo evaluated to true */
if ($makefoo) foo();
function bar()
{
echo "I exist immediately upon program start.\n";
}
?>
]]>
</programlisting>
</example>
</para>
<para>
<example>
<title>Functions within functions</title>
<programlisting role="php">
<![CDATA[
<?php
function foo()
{
function bar()
{
echo "I don't exist until foo() is called.\n";
}
}
/* We can't call bar() yet
since it doesn't exist. */
foo();
/* Now we can call bar(),
foo()'s processing has
made it accessible. */
bar();
?>
]]>
</programlisting>
</example>
</para>
<para>
All functions and classes in PHP have the global scope - they can be
called outside a function even if they were defined inside and vice versa.
</para>
<simpara>
PHP does not support function overloading, nor is it possible to
undefine or redefine previously-declared functions.
</simpara>
<note>
<simpara>
Function names are case-insensitive for the ASCII characters <literal>A</literal> to <literal>Z</literal>, though it is usually good form
to call functions as they appear in their declaration.
</simpara>
</note>
<simpara>
Both <link linkend="functions.variable-arg-list">variable number of
arguments</link> and <link linkend="functions.arguments.default">default
arguments</link> are supported in functions. See also the function
references for
<function>func_num_args</function>,
<function>func_get_arg</function>, and
<function>func_get_args</function> for more information.
</simpara>
<para>
It is possible to call recursive functions in PHP.
<example>
<title>Recursive functions</title>
<programlisting role="php">
<![CDATA[
<?php
function recursion($a)
{
if ($a < 20) {
echo "$a\n";
recursion($a + 1);
}
}
?>
]]>
</programlisting>
</example>
<note>
<simpara>
Recursive function/method calls with over 100-200 recursion levels can
smash the stack and cause a termination of the current script. Especially,
infinite recursion is considered a programming error.
</simpara>
</note>
</para>
</sect1>
<sect1 xml:id="functions.arguments">
<title>Function arguments</title>
<simpara>
Information may be passed to functions via the argument list,
which is a comma-delimited list of expressions. The arguments are
evaluated from left to right.
</simpara>
<para>
PHP supports passing arguments by value (the default), <link
linkend="functions.arguments.by-reference">passing by
reference</link>, and <link
linkend="functions.arguments.default">default argument
values</link>. <link linkend="functions.variable-arg-list">Variable-length
argument lists</link> are also supported.
</para>
<para>
<example>
<title>Passing arrays to functions</title>
<programlisting role="php">
<![CDATA[
<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>
]]>
</programlisting>
</example>
</para>
<para>
As of PHP 8.0.0, the list of function arguments may include a trailing comma, which
will be ignored. That is particularly useful in cases where the list of arguments is
long or contains long variable names, making it convenient to list arguments vertically.
</para>
<example>
<title>Function Argument List with trailing Comma</title>
<programlisting role="php">
<![CDATA[
<?php
function takes_many_args(
$first_arg,
$second_arg,
$a_very_long_argument_name,
$arg_with_default = 5,
$again = 'a default string', // This trailing comma was not permitted before 8.0.0.
)
{
// ...
}
?>
]]>
</programlisting>
</example>
<para>
As of PHP 8.0.0, passing optional arguments after mandatory arguments
is deprecated. This can generally be resolved by dropping the default value.
One exception to this rule are arguments of the form
<code>Type $param = &null;</code>, where the &null; default makes the type implicitly
nullable. This usage remains allowed, though it is recommended to use an
explicit nullable type instead.
</para>
<example>
<title>Passing optional arguments after mandatory arguments</title>
<programlisting role="php">
<![CDATA[
<?php
function foo($a = [], $b) {} // Before
function foo($a, $b) {} // After
function bar(A $a = null, $b) {} // Still allowed
function bar(?A $a, $b) {} // Recommended
?>
]]>
</programlisting>
</example>
<sect2 xml:id="functions.arguments.by-reference">
<title>Passing arguments by reference</title>
<simpara>
By default, function arguments are passed by value (so that if
the value of the argument within the function is changed, it does
not get changed outside of the function). To allow a function to modify its
arguments, they must be passed by reference.
</simpara>
<para>
To have an argument to a function always passed by reference, prepend an
ampersand (&) to the argument name in the function definition:
</para>
<para>
<example>
<title>Passing function parameters by reference</title>
<programlisting role="php">
<![CDATA[
<?php
function add_some_extra(&$string)
{
$string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str; // outputs 'This is a string, and something extra.'
?>
]]>
</programlisting>
</example>
</para>
</sect2>
<sect2 xml:id="functions.arguments.default">
<title>Default argument values</title>
<para>
A function may define C++-style default values for scalar
arguments as follows:
</para>
<para>
<example>
<title>Use of default parameters in functions</title>
<programlisting role="php">
<![CDATA[
<?php
function makecoffee($type = "cappuccino")
{
return "Making a cup of $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>
]]>
</programlisting>
&example.outputs;
<screen>
<![CDATA[
Making a cup of cappuccino.
Making a cup of .
Making a cup of espresso.
]]>
</screen>
</example>
</para>
<para>
PHP also allows the use of <type>array</type>s and the special type &null;
as default values, for example:
</para>
<para>
<example>
<title>Using non-scalar types as default values</title>
<programlisting role="php">
<![CDATA[
<?php
function makecoffee($types = array("cappuccino"), $coffeeMaker = NULL)
{
$device = is_null($coffeeMaker) ? "hands" : $coffeeMaker;
return "Making a cup of ".join(", ", $types)." with $device.\n";
}
echo makecoffee();
echo makecoffee(array("cappuccino", "lavazza"), "teapot");
?>
]]>
</programlisting>
</example>
</para>
<simpara>
The default value must be a constant expression, not (for
example) a variable, a class member or a function call.
</simpara>
<para>
Note that when using default arguments, any defaults should be on
the right side of any non-default arguments; otherwise, things
will not work as expected. Consider the following code snippet:
</para>
<para>
<example>
<title>Incorrect usage of default function arguments</title>
<programlisting role="php">
<![CDATA[
<?php
function makeyogurt($type = "acidophilus", $flavour)
{
return "Making a bowl of $type $flavour.\n";
}
echo makeyogurt("raspberry"); // won't work as expected
?>
]]>
</programlisting>
&example.outputs;
<screen>
<![CDATA[
Warning: Missing argument 2 in call to makeyogurt() in
/usr/local/etc/httpd/htdocs/phptest/functest.html on line 41
Making a bowl of raspberry .
]]>
</screen>
</example>
</para>
<para>
Now, compare the above with this:
</para>
<para>
<example>
<title>Correct usage of default function arguments</title>
<programlisting role="php">
<![CDATA[
<?php
function makeyogurt($flavour, $type = "acidophilus")
{
return "Making a bowl of $type $flavour.\n";
}
echo makeyogurt("raspberry"); // works as expected
?>
]]>
</programlisting>
&example.outputs;
<screen>
<![CDATA[
Making a bowl of acidophilus raspberry.
]]>
</screen>
</example>
</para>
<note>
<simpara>
Arguments that are passed by reference may have a default value.
</simpara>
</note>
</sect2>
<sect2 xml:id="functions.variable-arg-list">
<title>Variable-length argument lists</title>
<simpara>
PHP has support for variable-length argument lists in
user-defined functions by using the
<literal>...</literal> token.
</simpara>
<note>
<simpara>
It is also possible to achieve variable-length arguments by using
<function>func_num_args</function>,
<function>func_get_arg</function>, and
<function>func_get_args</function> functions.
This technique is not recommended as it was used prior to the introduction
of the <literal>...</literal> token.
</simpara>
</note>
<para>
Argument lists may include the
<literal>...</literal> token to denote that the function accepts a
variable number of arguments. The arguments will be passed into the
given variable as an array; for example:
<example>
<title>Using <literal>...</literal> to access variable arguments</title>
<programlisting role="php">
<![CDATA[
<?php
function sum(...$numbers) {
$acc = 0;
foreach ($numbers as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
]]>
</programlisting>
&example.outputs;
<screen>
<![CDATA[
10
]]>
</screen>
</example>
</para>
<para>
<literal>...</literal> can also be used when calling functions to unpack
an <type>array</type> or <classname>Traversable</classname> variable or
literal into the argument list:
<example>
<title>Using <literal>...</literal> to provide arguments</title>
<programlisting role="php">
<![CDATA[
<?php
function add($a, $b) {
return $a + $b;
}
echo add(...[1, 2])."\n";
$a = [1, 2];
echo add(...$a);
?>
]]>
</programlisting>
&example.outputs;
<screen>
<![CDATA[
3
3
]]>
</screen>
</example>
</para>
<para>
You may specify normal positional arguments before the
<literal>...</literal> token. In this case, only the trailing arguments
that don't match a positional argument will be added to the array
generated by <literal>...</literal>.
</para>
<para>
It is also possible to add a
<link linkend="language.types.declarations">type declaration</link> before the
<literal>...</literal> token. If this is present, then all arguments
captured by <literal>...</literal> must be objects of the hinted class.
<example>
<title>Type declared variable arguments</title>
<programlisting role="php">
<![CDATA[
<?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).' days';
// This will fail, since null isn't a DateInterval object.
echo total_intervals('d', null);
?>
]]>
</programlisting>
&example.outputs;
<screen>
<![CDATA[
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
]]>
</screen>
</example>
</para>
<para>
Finally, variable arguments can also be passed
<link linkend="functions.arguments.by-reference">by reference</link> by
prefixing the <literal>...</literal> with an ampersand
(<literal>&</literal>).
</para>
<sect3 xml:id="functions.variable-arg-list.old">
<title>Older versions of PHP</title>
<para>
No special syntax is required to note that a function is variadic;
however access to the function's arguments must use
<function>func_num_args</function>, <function>func_get_arg</function>
and <function>func_get_args</function>.
</para>
<para>
The first example above would be implemented as follows in old versions of PHP:
<example>
<title>Accessing variable arguments in old PHP versions</title>
<programlisting role="php">
<![CDATA[
<?php
function sum() {
$acc = 0;
foreach (func_get_args() as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
]]>
</programlisting>
&example.outputs;
<screen>
<![CDATA[
10
]]>
</screen>
</example>
</para>
</sect3>
</sect2>
<sect2 xml:id="functions.named-arguments">
<title>Named Arguments</title>
<para>
PHP 8.0.0 introduced named arguments as an extension of the existing
positional parameters. Named arguments allow passing arguments to a
function based on the parameter name, rather than the parameter position.
This makes the meaning of the argument self-documenting, makes the
arguments order-independent and allows skipping default values arbitrarily.
</para>
<para>
Named arguments are passed by prefixing the value with the parameter name
followed by a colon. Using reserved keywords as parameter names is allowed.
The parameter name must be an identifier, specifying dynamically
is not allowed.
</para>
<example>
<title>Named argument syntax</title>
<programlisting role="php">
<![CDATA[
<?php
myFunction(paramName: $value);
array_foobar(array: $value);
// NOT supported.
function_name($variableStoringParamName: $value);
?>
]]>
</programlisting>
</example>
<example>
<title>Positional arguments versus named arguments</title>
<programlisting role="php">
<![CDATA[
<?php
// Using positional arguments:
array_fill(0, 100, 50);
// Using named arguments:
array_fill(start_index: 0, num: 100, value: 50);
?>
]]>
</programlisting>
</example>
<para>
The order in which the named arguments are passed does not matter.
</para>
<example>
<title>Same example as above with a different order of parameters</title>
<programlisting role="php">
<![CDATA[
<?php
array_fill(value: 50, num: 100, start_index: 0);
?>
]]>
</programlisting>
</example>
<para>
Named arguments can be combined with positional arguments. In this case,
the named arguments must come after the positional arguments.
It is also possible to specify only some of the optional arguments of a
function, regardless of their order.
</para>
<example>
<title>Combining named arguments with positional arguments</title>
<programlisting role="php">
<![CDATA[
<?php
htmlspecialchars($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
?>
]]>
</programlisting>
</example>
<para>
Passing the same parameter multiple times results in an Error exception.
</para>
<example>
<title>Error exception when passing the same parameter multiple times</title>
<programlisting role="php">
<![CDATA[
<?php
function foo($param) { ... }
foo(param: 1, param: 2);
// Error: Named parameter $param overwrites previous argument
foo(1, param: 2);
// Error: Named parameter $param overwrites previous argument
?>
]]>
</programlisting>
</example>
</sect2>
</sect1>
<sect1 xml:id="functions.returning-values">
<title>Returning values</title>
<para>
Values are returned by using the optional return statement. Any
type may be returned, including arrays and objects. This causes the
function to end its execution immediately and pass control back to
the line from which it was called. See <function>return</function>
for more information.
</para>
<note>
<para>
If the <function>return</function> is omitted the value &null; will be
returned.
</para>
</note>
<sect2>
<title>Use of return</title>
<para>
<example>
<title>Use of <function>return</function></title>
<programlisting role="php">
<![CDATA[
<?php
function square($num)
{
return $num * $num;
}
echo square(4); // outputs '16'.
?>
]]>
</programlisting>
</example>
</para>
<para>
A function can not return multiple values, but similar results can be
obtained by returning an array.
</para>
<para>
<example>
<title>Returning an array to get multiple values</title>
<programlisting role="php">
<![CDATA[
<?php
function small_numbers()
{
return array (0, 1, 2);
}
list ($zero, $one, $two) = small_numbers();
?>
]]>
</programlisting>
</example>
</para>
<para>
To return a reference from a function, use the reference operator & in
both the function declaration and when assigning the returned value to a
variable:
</para>
<para>
<example>
<title>Returning a reference from a function</title>
<programlisting role="php">
<![CDATA[
<?php
function &returns_reference()
{
return $someref;
}
$newref =& returns_reference();
?>
]]>
</programlisting>
</example>
</para>
<simpara>
For more information on references, please check out <link
linkend="language.references">References Explained</link>.
</simpara>
</sect2>
</sect1>
<sect1 xml:id="functions.variable-functions">
<title>Variable functions</title>
<para>
PHP supports the concept of variable functions. This means that if
a variable name has parentheses appended to it, PHP will look for
a function with the same name as whatever the variable evaluates
to, and will attempt to execute it. Among other things, this can
be used to implement callbacks, function tables, and so forth.
</para>
<para>
Variable functions won't work with language constructs such
as <function>echo</function>, <function>print</function>,
<function>unset</function>, <function>isset</function>,
<function>empty</function>, <function>include</function>,
<function>require</function> and the like. Utilize wrapper functions to make
use of any of these constructs as variable functions.
</para>
<para>
<example>
<title>Variable function example</title>
<programlisting role="php">
<![CDATA[
<?php
function foo() {
echo "In foo()<br />\n";
}
function bar($arg = '')
{
echo "In bar(); argument was '$arg'.<br />\n";
}
// This is a wrapper function around echo
function echoit($string)
{
echo $string;
}
$func = 'foo';
$func(); // This calls foo()
$func = 'bar';
$func('test'); // This calls bar()
$func = 'echoit';
$func('test'); // This calls echoit()
?>
]]>
</programlisting>
</example>
</para>
<para>
Object methods can also be called with the variable functions syntax.
<example>
<title>Variable method example</title>
<programlisting role="php">
<![CDATA[
<?php
class Foo
{
function Variable()
{
$name = 'Bar';
$this->$name(); // This calls the Bar() method
}
function Bar()
{
echo "This is Bar";
}
}
$foo = new Foo();
$funcname = "Variable";
$foo->$funcname(); // This calls $foo->Variable()
?>
]]>
</programlisting>
</example>
</para>
<para>
When calling static methods, the function call is stronger than the static property operator:
<example>
<title>Variable method example with static properties</title>
<programlisting role="php">
<![CDATA[
<?php
class Foo
{
static $variable = 'static property';
static function Variable()
{
echo 'Method Variable called';
}
}
echo Foo::$variable; // This prints 'static property'. It does need a $variable in this scope.
$variable = "Variable";
Foo::$variable(); // This calls $foo->Variable() reading $variable in this scope.
?>
]]>
</programlisting>
</example>
</para>
<para>
<example>
<title>Complex callables</title>
<programlisting role="php">
<![CDATA[
<?php
class Foo
{
static function bar()
{
echo "bar\n";
}
function baz()
{
echo "baz\n";
}
}
$func = array("Foo", "bar");
$func(); // prints "bar"
$func = array(new Foo, "baz");
$func(); // prints "baz"
$func = "Foo::bar";
$func(); // prints "bar"
?>
]]>
</programlisting>
</example>
</para>
<sect2 role="seealso">
&reftitle.seealso;
<para>
<simplelist>
<member><function>is_callable</function></member>
<member><function>call_user_func</function></member>
<member><function>function_exists</function></member>
<member><link linkend="language.variables.variable">variable variables</link></member>
</simplelist>
</para>
</sect2>
</sect1>
<sect1 xml:id="functions.internal">
<title>Internal (built-in) functions</title>
<para>
PHP comes standard with many functions and constructs. There are also
functions that require specific PHP extensions compiled in, otherwise
fatal "undefined function" errors will appear. For example, to use
<link linkend="ref.image">image</link> functions such as
<function>imagecreatetruecolor</function>, PHP must be compiled with
<productname>GD</productname> support. Or, to use
<function>mysqli_connect</function>, PHP must be compiled with
<link linkend="book.mysqli">MySQLi</link> support. There are many core functions
that are included in every version of PHP, such as the
<link linkend="ref.strings">string</link> and
<link linkend="ref.var">variable</link> functions. A call
to <function>phpinfo</function> or
<function>get_loaded_extensions</function> will show which extensions are
loaded into PHP. Also note that many extensions are enabled by default and
that the PHP manual is split up by extension. See the
<link linkend="configuration">configuration</link>,
<link linkend="install">installation</link>, and individual
extension chapters, for information on how to set up PHP.
</para>
<para>
Reading and understanding a function's prototype is explained within the
manual section titled <link linkend="about.prototypes">how to read a
function definition</link>. It's important to realize what a function
returns or if a function works directly on a passed in value. For example,
<function>str_replace</function> will return the modified string while
<function>usort</function> works on the actual passed in variable
itself. Each manual page also has specific information for each
function like information on function parameters, behavior changes,
return values for both success and failure, and availability information.
Knowing these important (yet often subtle) differences is crucial for
writing correct PHP code.
</para>
<note>
<simpara>
If the parameters given to a function are not what it expects, such as
passing an <type>array</type> where a <type>string</type> is expected,
the return value of the function is undefined. In this case it will
likely return &null; but this is just a convention, and cannot be relied
upon.
</simpara>
</note>
<sect2 role="seealso">
&reftitle.seealso;
<para>
<simplelist>
<member><function>function_exists</function></member>
<member><link linkend="funcref">the function reference</link></member>
<member><function>get_extension_funcs</function></member>
<member><function>dl</function></member>
</simplelist>
</para>
</sect2>
</sect1>
<sect1 xml:id="functions.anonymous">
<title>Anonymous functions</title>
<simpara>
Anonymous functions, also known as <literal>closures</literal>, allow the
creation of functions which have no specified name. They are most useful as
the value of <type>callable</type>
parameters, but they have many other uses.
</simpara>
<simpara>
Anonymous functions are implemented using the <link linkend="class.closure">
<classname>Closure</classname></link> class.
</simpara>
<example>
<title>Anonymous function example</title>
<programlisting role="php">