User-Defined Functions
Thus far, all the script examples that you have been exposed to have been linear (meaning that they started from the top and executed to the bottom). However, it would be very limiting if this was the only way scripts could be created. To overcome this limitation, you can use functions. For those with prior programming experience, functions probably are already a firm concept requiring little explanation. For those who need a little explanation, read on.
In PHP, functions are defined in the following fashion:
function func_name ([variable [= constant][, ...]) {
/* Any valid PHP code */
}
The name of the function (labeled by "func_name") is an arbitrary (but descriptive) name following the same rules as those imposed on PHP variables followed by a set of parameters. How many parameters, their default values (if any), and the parameter names are all up to the developer. Functions can also "return" a value using the PHP return statement. An example of a PHP function that determines whether a given year is a leap year is shown in Listing 1.19:
Listing 1.19. User-Defined Function to Determine a Leap Year
<?php
function is_leapyear($year = 2004) {
$is_leap = (!($year % 4) && (($year % 100) || !($year % 400)));
return $is_leap;
}
?>
|
If you are looking at the preceding function and scratching your head, I'll explain how it works. A year is considered a leap year if
|
After this function has been defined within your script, it can be used as shown in Listing 1.20:
Listing 1.20. Using User-Defined Functions
<?php
$answer = is_leapyear(2000);
if($answer) {
echo "2000 is a leap year<BR>";
} else {
echo "2000 is not a leap year.<BR>";
}
/* Use default for the parameter */
$answer = is_leapyear();
if($answer) {
echo "2003 is a leap year.<BR>";
} else {
echo "2003 is not a leap year.<BR>";
}
?>
With the introduction of functions comes the discussion of variable scope. The term variable scope refers to how PHP decides which declared variables can be used from where in the PHP script. Up to this point, all your variables have been a part of what is called the global variable scope. However, variables declared within a function are a part of what is called the local function scope unless otherwise defined. What does this mean to you as a developer? Looking back at your is_leapyear() function, this means the $is_leap variable exists only within that specific function and cannot be accessed from outside that function's scope. In fact, you can even create a variable called $is_leap somewhere else in your script (as long as it's not in the is_leapyear() function) without affecting the variable within the function. Furthermore, any variables defined outside the function are similarly not accessible.
Although this concept of scope is incredibly useful and makes development considerably easier, there are times when it would be useful to access variables from another scope from within your functions. To accomplish this, PHP has the global statement. This statement modifies the scope of a given variable from a local scope to the global variable scope. Its syntax is as follows:
global $var1 [, $var2 [, $var3 [, ...]]];
In PHP, the variable passed to the global statement does not have to already be declared in any scope. This can be particularly useful when you want to design a function that "creates" a variable in the global scope, as shown in Listing 1.21:
Listing 1.21. Working with Variable Scope in PHP
<?php
function createglobal() {
global $my_global;
$my_global = 10;
}
echo "The value of \$my_global is '$my_global'<BR>";
createglobal();
echo "The value of \$my_global is '$my_global'<BR>";
?>
This produces the following output:
The value of $my_global is ''
The value of $my_global is '10'
As you can see, although $my_global was never initialized anywhere in the global scope, through the use of the global statement it was created from within the createglobal() function. Likewise, variables that exist within the global scope may also be brought into the local scope of a function in the same fashion, as shown in Listing 1.22:
Listing 1.22. More Working with Variable Scope
<?php
function getglobal() {
global $my_global;
echo "The value of \$foobar is '$foobar'<BR>";
}
$my_global = 20;
getglobal();
?>
This produces the following output:
The value of $my_global is '20';
|
Although all local variables adhere to the concept of variable scope, certain variables created by PHP, namely $_SERVER, $_GET, $_POST, $_REQUEST, $_GLOBALS, $_COOKIE, $_ENV, $_SESSION, and $_FILES are always available regardless of the current scope (names are case sensitive). These variables, called superglobals, are available anytime during the execution of a PHP script. These superglobals will be explained and used throughout the book; however, a brief introduction to them all can be found online at http://www.php.net/manual/en/language.variables.predefined.php. |
Under most circumstances, when a function in PHP is executed, any variables that were created by the function are destroyed when the function is complete. However, like most modern programming languages, PHP supports what are known as static variables, which do not get destroyed when the function terminates. To create a static variable within a function, you use the static statement as follows:
static $varname [= constant [, $var2 [= constant]] ...];
$varname is the name of the variable you would like not to be destroyed, and the optional constant value refers to the initial value of the variable. In the example, the static statement functions as shown in Listing 1.23:
Listing 1.23. Working with Static Variables in Functions
<?php
function statictest() {
static $count = 0;
$count++;
return $count;
}
statictest();
statictest();
$foo = statictest();
echo "The statictest() function ran $foo times.<BR>";
?>
This results in the following output:
The statictest() function ran 2 times.
| 
