Variables

Although variables have been used in numerous examples in this chapter, the concept has yet to be formally introduced. This section does so, starting with a definition. Simply put, a variable is a symbol that can store different values at different times. For example, suppose you create a Web-based calculator capable of performing mathematical tasks. Of course, the user will want to plug in values of his choosing; therefore, the program must be able to dynamically store those values and perform calculations accordingly. At the same time, the programmer requires a user-friendly means for referring to these value-holders within the application. The variable accomplishes both tasks.

Given the importance of this programming concept, it would be wise to explicitly lay the groundwork as to how variables are declared and manipulated. In this section, these rules are examined in detail.

Variable Declaration

A variable always begins with a dollar sign, $, which is then followed by the variable name. Variable names follow the same naming rules as identifiers. That is, a variable name can begin with either a letter or an underscore and can consist of letters, underscores, numbers, or other ASCII characters ranging from 127 through 255. The following are all valid variables:
• $color
• $operating_system
• $_some_variable
• $model
Note that variables are case sensitive. For instance, the following variables bear absolutely no relation to one another:
• $color
• $Color
• $COLOR
Interestingly, variables do not have to be explicitly declared in PHP as they do in Perl. Rather, variables can be declared and assigned values simultaneously. Nonetheless, just because you can do something doesn’t mean you should. Good programming practice dictates that all variables should be declared prior to use, preferably with an accompanying comment.

Once you’ve declared your variables, you can begin assigning values to them. Two methodologies are available for variable assignment: by value and by reference. Both are introduced next.
Value Assignment
Assignment by value simply involves copying the value of the assigned expression to the variable assignee. This is the most common type of assignment. A few examples follow:

                    $color = "red";

                    $number = 12;

                    $age = 12;

                    $sum = 12 + "15"; // $sum = 27

Keep in mind that each of these variables possesses a copy of the expression assigned to it. For example, $number and $age each possesses their own unique copy of the value 12. If you prefer that two variables point to the same copy of a value, you need to assign by reference, introduced next.
Reference Assignment
PHP 4 introduced the ability to assign variables by reference, which essentially means that you can create a variable that refers to the same content as another variable does. Therefore, a change to any variable referencing a particular item of variable content will be reflected among all other variables referencing that same content. You can assign variables by reference by appending an ampersand (&) to the equal sign. Let’s consider an example:

                 <?php

                 $value1 = "Hello";

                 $value2 =& $value1; // $value1 and $value2 both equal "Hello"

                 $value2 = "Goodbye"; // $value1 and $value2 both equal "Goodbye"

                 ?>

An alternative reference-assignment syntax is also supported, which involves appending the ampersand to the front of the variable being referenced. The following example adheres to this new syntax:

                    <?php

                    $value1 = "Hello";

                    $value2 = &$value1; // $value1 and $value2 both equal "Hello"

                    $value2 = "Goodbye"; // $value1 and $value2 both equal "Goodbye"

                     ?>

References also play an important role in both function arguments and return values, as well as in object-oriented programming. Chapters 4 and 6 cover these
features, respectively.

Variable Scope

However you declare your variables (by value or by reference), you can declare them anywhere in a PHP script. The location of the declaration greatly influences the realm in which a variable can be accessed, however. This accessibility domain is known as its scope.
PHP variables can be one of four scope types:
• Local variables
• Function parameters
• Global variables
• Static variables
Local Variables
A variable declared in a function is considered local. That is, it can be referenced only in that function. Any assignment outside of that function will be considered to be an entirely different variable from the one contained in the function. Note that when you exit the function in which a local variable has been declared, that variable and its corresponding value are destroyed.
Local variables are helpful because they eliminate the possibility of unexpected side effects, which can result from globally accessible variables that are modified, intentionally or not. Consider this listing:

                   $x = 4;

                   function assignx () {

                   $x = 0;

                  printf("\$x inside function is %d <br />", $x);

                  }

                  assignx();

                  printf("\$x outside of function is %d <br />", $x);

                  Executing this listing results in the following:

                  $x inside function is 0

                  $x outside of function is 4

As you can see, two different values for $x are output. This is because the $x located inside the assignx() function is local. Modifying the value of the local $x has no bearing on any values located outside of the function. On the same note, modifying the $x located outside of the function has no bearing on any variables contained in assignx().
Function Parameters
As in many other programming languages, in PHP, any function that accepts arguments must declare those arguments in the function header. Although those arguments accept values that come from outside of the function, they are no longer accessible once the function has exited.

Function parameters are declared after the function name and inside parentheses. They are declared much like a typical variable would be:

// multiply a value by 10 and return it to the caller

              function x10 ($value) {

              $value = $value * 10;

              return $value;

              }

Keep in mind that although you can access and manipulate any function parameter in the function in which it is declared, it is destroyed when the function execution ends. You’ll learn more about functions in Chapter 4.
Global Variables
In contrast to local variables, a global variable can be accessed in any part of the program. To modify a global variable, however, it must be explicitly declared to be global in the function in which it is to be modified. This is accomplished, conveniently enough, by placing the keyword GLOBAL in front of the variable that should be recognized as global.
Placing this keyword in front of an already existing variable tells PHP to use the variable having that name. Consider an example:

                  $somevar = 15;

                  function addit() {

                  GLOBAL $somevar;

                  $somevar++;

                    echo "Somevar is $somevar";

                 }

                 addit();

The displayed value of $somevar would be 16. However, if you were to omit this line, GLOBAL $somevar; the variable $somevar would be assigned the value 1 because $somevar would then be considered local within the addit() function. This local declaration would be implicitly set to 0 and then incremented by 1 to display the value 1.
An alternative method for declaring a variable to be global is to use PHP’s $GLOBALS array. Reconsidering the preceding example, you can use this array to declare the variable $somevar to be global:

               $somevar = 15;

               function addit() {

               $GLOBALS["somevar"]++;

               }

                addit();

               echo "Somevar is ".$GLOBALS["somevar"];

               This returns the following:

               Somevar is 16

Regardless of the method you choose to convert a variable to global scope, be aware that the global scope has long been a cause of grief among programmers due
to unexpected results that may arise from its careless use. Therefore, although global variables can be extremely useful, be prudent when using them.
Static Variables
The final type of variable scoping to discuss is known as static. In contrast to the variables declared as function parameters, which are destroyed on the function’s exit, a static variable does not lose its value when the function exits and will still hold that value if the function is called again. You can declare a variable as static simply by placing the keyword STATIC in front of the variable name:

                STATIC $somevar;

                Consider an example:

                function keep_track() {

                STATIC $count = 0;

                $count++;

                echo $count;

                echo "<br />";

                 }

                 keep_track();

                 keep_track();

                 keep_track();

What would you expect the outcome of this script to be? If the variable $count was
not designated to be static (thus making $count a local variable), the outcome would
be as follows:

             1

             1

             1

However, because $count is static, it retains its previous value each time the function
is executed. Therefore, the outcome is the following:

            1

            2

            3

Static scoping is particularly useful for recursive functions. Recursive functions are a powerful programming concept in which a function repeatedly calls itself until a particular condition is met. Recursive functions are covered in detail in Chapter 4.

PHP’s Superglobal Variables

PHP offers a number of useful predefined variables that are accessible from anywhere within the executing script and provide you with a substantial amount of environment- specific information. You can sift through these variables to retrieve details about the current user session, the user’s operating environment, the local operating environment, and more. PHP creates some of the variables, while the availability and value of many of the other variables are specific to the operating system and Web server. Therefore, rather than attempt to assemble a comprehensive list of all possible predefined variables and their possible values, the following code will output all predefined variables pertinent to any given Web server and the script’s execution environment:

              foreach ($_SERVER as $var => $value) {

              echo "$var => $value <br />";

                }

This returns a list of variables similar to the following. Take a moment to peruse the listing produced by this code as executed on a Windows server. You’ll see some of these variables again in the examples that follow:

              HTTP_HOST => localhost:81

              HTTP_USER_AGENT => Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US;

              rv:1.8.0.10) Gecko/20070216 Firefox/1.5.0.10

              HTTP_ACCEPT =>

              text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;

              q=0.8,image/png,*/*;q=0.5

              HTTP_ACCEPT_LANGUAGE => en-us,en;q=0.5

              HTTP_ACCEPT_ENCODING => gzip,deflate

              HTTP_ACCEPT_CHARSET => ISO-8859-1,utf-8;q=0.7,*;q=0.7

              HTTP_KEEP_ALIVE => 300

              HTTP_CONNECTION => keep-alive

              PATH =>

              C:\oraclexe\app\oracle\product\10.2.0\server\bin;c:\ruby\bin;C:\Windows\system32

               ;

              C:\Windows;C:\Windows\System32\Wbem;C:\Program

              Files\QuickTime\QTSystem\;c:\php52\;c:\Python24

              SystemRoot => C:\Windows

              COMSPEC => C:\Windows\system32\cmd.exe

              PATHEXT => .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.RB;.RBW

              WINDIR => C:\Windows

              SERVER_SIGNATURE =>

              Apache/2.0.59 (Win32) PHP/6.0.0-dev Server at localhost Port 81

              SERVER_SOFTWARE => Apache/2.0.59 (Win32) PHP/6.0.0-dev

              SERVER_NAME => localhost

              SERVER_ADDR => 127.0.0.1

              SERVER_PORT => 81

              REMOTE_ADDR => 127.0.0.1

              DOCUMENT_ROOT => C:/apache2/htdocs

              SERVER_ADMIN => example@note.com

              SCRIPT_FILENAME => C:/apache2/htdocs/books/php-oracle/3/server.php

              REMOTE_PORT => 49638

              GATEWAY_INTERFACE => CGI/1.1

              SERVER_PROTOCOL => HTTP/1.1

              REQUEST_METHOD => GET

              QUERY_STRING =>REQUEST_URI => /books/php-oracle/3/server.php

              SCRIPT_NAME => /books/php-oracle/3/server.php

              PHP_SELF => /books/php-oracle/3/server.php

              REQUEST_TIME => 1174440456

As you can see, quite a bit of information is available—some useful, some not so useful. You can display just one of these variables simply by treating it as a regular variable. For example, use this to display the user’s IP address:

            printf("Your IP address is: %s", $_SERVER['REMOTE_ADDR']);

This returns a numerical IP address, such as 192.0.34.166.
You can also gain information regarding the user’s browser and operating system. Consider the following one-liner:

            printf("Your browser is: %s", $_SERVER['HTTP_USER_AGENT']);

This returns information similar to the following:
Your browser is: Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US;
rv:1.8.0.10)Gecko/20070216 Firefox/1.5.0.10
This example illustrates only one of PHP’s nine predefined variable arrays. The rest of this section is devoted to introducing the purpose and contents of each.

Learning More About the Server and Client
The $_SERVER superglobal contains information created by the Web server and offers a bevy of information regarding the server and client configuration and the current request environment. Although the value and number of variables found in $_SERVER varies by server, you can typically expect to find those defined in the CGI 1.1 specification (available at the National Center for Supercomputing Applications at http://hoohoo.ncsa.uiuc.edu/cgi/env.html). You’ll likely find all of these variables to be quite useful in your applications, some of which include the following:

$_SERVER['HTTP_REFERER']: The URL of the page that referred the user to the current location.
$_SERVER['REMOTE_ADDR']: The client’s IP address.
$_SERVER['REQUEST_URI']: The path component of the URL. For example, if the URL is http://www.example.com/blog/apache/index.html, the URI is /blog/apache/index.html.
$_SERVER['HTTP_USER_AGENT']: The client’s user agent, which typically offers information about both the operating system and the browser.
Retrieving Variables Passed Using GET
The $_GET superglobal contains information pertinent to any parameters passed using the GET method. If the URL http://www.example.com/index.html?cat=apache&id=157 is requested, you could access the following variables by using the $_GET superglobal:

                    $_GET['cat'] = "apache"

                    $_GET['id'] = "157"

The $_GET superglobal by default is the only way that you can access variables passed via the GET method. You cannot reference GET variables like this: $cat, $id. See Chapter 21 for more about safely accessing external data.
Retrieving Variables Passed Using POST
The $_POST superglobal contains information pertinent to any parameters passed using the POST method. Consider the following form, used to solicit subscriber information:

                     <form action="subscribe.php" method="post">

                      <p>

                         Email address:<br />

                      <input type="text" name="email" size="20" maxlength="50" value="" />

                       </p>

                      <p>

                       Password:<br />

                       <input type="password" name="password" size="20" maxlength="15" value="" />

                       </p>

                       <p>

                       <input type="submit" name="subscribe" value="subscribe!" />

                     </p>

                   </form>

The following POST variables will be made available via the target subscribe.php script:

                $_POST['email'] = "example@note.com";

                $_POST['pswd'] = "common";

                $_POST['subscribe'] = "subscribe!";

Like $_GET, the $_POST superglobal is by default the only way to access POST variables.
You cannot reference POST variables like this: $email, $pswd, and $subscribe.
Retrieving Information Stored Within Cookies
The $_COOKIE superglobal stores information passed into the script through HTTP cookies. Such cookies are typically set by a previously executed PHP script through the PHP function setcookie(). For example, suppose that you use setcookie() to store a cookie named example.com with the value ab2213. You could later retrieve that value by calling $_COOKIE["example.com"]. Chapter 18 introduces PHP’s cookie-handling capabilities.
Retrieving Information About Files Uploaded Using POST
The $_FILES superglobal contains information regarding data uploaded to the server via the POST method. This superglobal is a tad different from the others in that it is a two-dimensional array containing five elements. The first subscript refers to the name of the form’s file-upload form element; the second is one of five predefined subscripts that describe a particular attribute of the uploaded file:
$_FILES['upload-name']['name']: The name of the file as uploaded from the client to the server.
$_FILES['upload-name']['type']: The MIME type of the uploaded file. Whether this variable is assigned depends on the browser capabilities.
$_FILES['upload-name']['size']: The byte size of the uploaded file.
$_FILES['upload-name']['tmp_name']: Once uploaded, the file will be assigned a temporary name before it is moved to its final location.

$_FILES['upload-name']['error']: An upload status code. Despite the name, this
variable will be populated even in the case of success. There are five possible values:
• UPLOAD_ERR_OK: The file was successfully uploaded.
• UPLOAD_ERR_INI_SIZE: The file size exceeds the maximum size imposed by the upload_max_filesize directive.
• UPLOAD_ERR_FORM_SIZE: The file size exceeds the maximum size imposed by an optional MAX_FILE_SIZE hidden form-field parameter.
• UPLOAD_ERR_PARTIAL: The file was only partially uploaded.
• UPLOAD_ERR_NO_FILE: A file was not specified in the upload form prompt.
Chapter 15 is devoted to a complete introduction of PHP’s file-upload functionality.
Learning More About the Operating System Environment
The $_ENV superglobal offers information regarding the PHP parser’s underlying server environment. Some of the variables found in this array include the following:

                         $_ENV['HOSTNAME']: The server hostname

                         $_ENV['SHELL']: The system shell

Retrieving Information Stored in Sessions
The $_SESSION superglobal contains information regarding all session variables. Registering session information allows you the convenience of referring to it throughout your entire Web site, without the hassle of explicitly passing the data via GET or POST.
Chapter 18 is devoted to PHP’s formidable session-handling feature.

Variable Variables

On occasion, you may want to use a variable whose content can be treated dynamically as a variable in itself. Consider this typical variable assignment:

                   $recipe = "spaghetti";

Interestingly, you can treat the value spaghetti as a variable by placing a second dollar sign in front of the original variable name and again assigning another value:

                   $$recipe = "& meatballs";

This in effect assigns & meatballs to a variable named spaghetti.
Therefore, the following two snippets of code produce the same result:

                   echo $recipe $spaghetti;

                   echo $recipe ${$recipe};

The result of both is the string spaghetti & meatballs.