User-defined functions:

A valid function name starts with a letter or underscore, followed by any

number of letters, numbers, or underscores.
When a function is defined in a conditional manner, Its definition must be
processed prior to being called.

A function may be defined using syntax such as the following:

Example 17.1. Pseudo code to demonstrate function uses

<?php
function foo($arg_1, $arg_2, /* ..., */ $arg_n)
{
echo "Example function.\n";
return $retval;
}
?>

Any valid PHP code may appear inside a function, even other functions and class definitions.

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: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*.

In PHP 3, functions must be defined before they are referenced. No such requirement exists since
PHP 4. Except when a function is conditionally defined such as shown in the two examples below.

When a function is defined in a conditional manner such as the two examples shown. Its definition
must be processed prior to being called.

Example 17.2. Conditional functions

<?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";
}

?>

Example 17.3. Functions within functions

<?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 processesing has
made it accessible. */

bar();

?>

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.
PHP does not support function overloading, nor is it possible to undefine
or redefine previously-declared functions.
Function names are case-insensitive, though it is usually good form to call
functions as they appear in their declaration.

PHP 3 does not support variable numbers of arguments to functions, although default arguments
are supported .Both are supported, as of PHP 4:
It is possible to call recursive functions in PHP. However avoid recursive function/method calls
with over 100-200 recursion levels as it can smash the stack and cause a termination of the
current script.

Example 17.4. Recursive functions

<?php
function recursion($a)
{
if ($a < 20) {
echo "$a\n";
recursion($a + 1);
}
}
?>

Function arguments

Information may be passed to functions via the argument list, which is a comma-delimited list of
expressions.

PHP supports passing arguments by value (the default), Passing by

reference, and default argument values.

Variable-length argument lists are supported only in PHP 4 and later. A similar effect can be
achieved in PHP 3 by passing an array of arguments to a function:

Example 17.5. Passing arrays to functions

<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>

Making arguments be passed by reference

By default, function arguments are passed by value (so that if you change the value of the
argument within the function, it does not get changed outside of the function). If you wish to
allow a function to modify its arguments, you must pass them by reference.

If you want an argument to a function to always be passed by reference, you can prepend an
ampersand (&) to the argument name in the function definition:

Example 17.6. Passing function parameters by reference

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

Default argument values

A function may define C++-style default values for scalar arguments as follows:

Example 17.7. Use of default parameters in functions

<?php
function makecoffee($type = "cappuccino")
{
return "Making a cup of $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>

The output from the above snippet is:

Making a cup of cappuccino.

Making a cup of .
Making a cup of espresso.

Also PHP allows you to use arrays and special type NULL as default values, for example:

Example 17.8. Using non-scalar types as default values

<?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");
?>
 The default value must be a constant expression, not (for example) a
variable, a class member or a function call.
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.

Example 17.9. Incorrect usage of default function arguments

<?php
function makeyogurt($type = "acidophilus", $flavour)
{
return "Making a bowl of $type $flavour.\n";
}

echo makeyogurt("raspberry"); // won't work as expected

?>

The output of the above example is:

Warning: Missing argument 2 in call to makeyogurt() in

/usr/local/etc/httpd/htdocs/php3test/functest.html on line 41
Making a bowl of raspberry .

Now, compare the above with this:

Example 17.10. Correct usage of default function arguments

<?php
function makeyogurt($flavour, $type = "acidophilus")
{
return "Making a bowl of $type $flavour.\n";
}

echo makeyogurt("raspberry"); // works as expected

?>

The output of this example is:

Making a bowl of acidophilus raspberry.

Note: As of PHP 5, default values may be passed by reference.

Returning values:

Values are returned by using the optional return statement. Any type may be returned, including
lists and objects. This causes the function to end its execution immediately and pass control back
to the line from which it was called.

Example 17.11. Use of return()

<?php
function square($num)
{
return $num * $num;
}
echo square(4); // outputs '16'.
?>

You can't return multiple values from a function, but similar results can be obtained
by returning a list.

Example 17.12. Returning an array to get multiple values

<?php
function small_numbers()
{
return array (0, 1, 2);
}
list ($zero, $one, $two) = small_numbers();
?>

To return a reference from a function, you have to use the reference operator & in both the function
declaration and when assigning the returned value to a variable:

Example 17.13. Returning a reference from a function

<?php
function &returns_reference()
{
return $someref;
}

$newref =& returns_reference();

?>

Variable functions:

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.

Variable functions won't work with language constructs such as echo(), print(), unset(), isset(),
empty(), include(), require() and the like. You need to use your own wrapper function to utilize any
of these constructs as variable functions.

Example 17.14. Variable function example

<?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()
?>

You can also call an object's method by using the variable functions feature.

Example 17.15. Variable method example

<?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()

?>