Ads 468x60px

Thursday, July 28, 2011

Working with Forms in php.

Working with Forms in php.
Until now, all examples in this book have been missing a crucial dimension. You can
set variables and arrays, create and call functions, and work with objects. All this is
meaningless if users can't reach into a language's environment to offer it
information. In this hour, you will look at strategies for acquiring and working with
user input.
On the World Wide Web, HTML forms are the principal means by which substantial
amounts of information can pass from the user to the server. PHP is designed to
acquire and work with information submitted via HTML forms.
In this hour, you will learn
How to get and use environment variables
How to access information from form fields
How to work with form elements that allow multiple selections
How to create a single document that contains both an HTML form and the PHP
code that handles its submission
How to save state with hidden fields
How to redirect the user to a new page
How to build HTML forms that upload files and how to write the PHP code to
handle them

Global and Environment Variables

Before you actually build a form and use it to acquire data, you need to make a small
detour and look again at global variables. You first met these in Hour 6, "Functions."
A global variable is any variable declared at the "top level" of a script
that is,
declared outside a function. All functions are made available in a built-in associative
array called $GLOBALS. This is useful in Listing 9.1 because we can take a peek at
all our script's global variables with a single loop.

 Looping Through the $GLOBALS Array
1: <html>
2: <head>
3: <title>Listing 9.1 Looping through the $GLOBALS array</title>
4: </head>

5: <body>
6: <?php
7: $user1 = "Bob";
8: $user2 = "Harry";
9: $user3 = "Mary";
10: foreach ( $GLOBALS as $key=>$value )
11:    {
12:    print "\$GLOBALS[\"$key\"] == $value<br>";
13:    }
14: ?>
15: </body>
16: </html>
We declare three variables and then loop through the built-in $GLOBALS associative
array, writing both array keys and values to the browser. In the output, we were
able to locate the variables we defined, but we saw an awful lot more besides these.
PHP automatically defines global variables that describe both the server and client
environments. These are known, therefore, as environment variables. According to
your system, server, and configuration, the availability of these variables will vary,
but they can be immensely useful. Table 9.1 lays out some common environment
variables. These can be accessed as part of the $GLOBALS array, or directly.
Table 9.1: Environment Variables
$HTTP_USER_AGENT    The name and
version of the
(X11;I;Linux2.2.6 -15apmac ppc)
$REMOTE_ADDR    The IP address
of the client
$REQUEST_METHOD    Whether the
request was
requests, the
encoded data
send appended
to the URL
$REQUEST_URI    The full address /matt/php-

of the request
including query
$HTTP_REFERER    The address of
the page from
which the
request was
In addition to environment variables, PHP makes some other global variables
available to you. The variable $GLOBALS["PHP_SELF"], for example, gives you the
path to the script currently running. On my system this was as follows:
This variable can also be directly accessed as the global variable $PHP_SELF. This
will be useful in many of the examples in this hour. We will often include the HTML
forms we use in the same page as the PHP code that analyzes the content they
submit. We can use $PHP_SELF as the string assigned to the HTML FORM element's
ACTION argument, saving us the trouble of hard-coding the name of the page.
PHP's $GLOBALS array will become useful in other ways as well.

A Script to Acquire User Input
For now, we'll keep our HTML separate from our PHP code. Listing 9.2 builds a
simple HTML form.

A Simple HTML Form
1: <html>
2: <head>
3: <title>Listing 9.2 A simple HTML form</title>
4: </head>
5: <body>
6: <form action="eg9.3.php" method="GET">
7: <input type="text" name="user">
8: <br>
9: <textarea name="address" rows="5" cols="40">
10: </textarea>
11: <br>
12: <input type="submit" value="hit it!">
13: </form>
14: </body>
15: </html>

We define a form that contains a text field with the name "user", a text area with the
name "address", and a submit button. It is beyond the remit of this book to cover
HTML in detail. If you find the HTML in these examples hard going, take a look at
Sams Teach Yourself HTML in 24 Hours
or one of the numerous online HTML
tutorials. The FORM element's ACTION argument points to a file called eg9.3.php,
which processes the form information. Because we haven't added anything more
than a filename to the ACTION argument, the file eg9.3.php should be in the same
directory on the server as the document that contains our HTML.
Listing 9.3 creates the code that receives our users' input.

 Reading Input from the Form 
1: <html>
2: <head>
3: <title>Listing 9.3 Reading input from the form in Listing 9.2</title>
4: </head>
5: <body>
6: <?php
7: print "Welcome <b>$user</b><P>\n\n";
8: print "Your address is:<P>\n\n<b>$address</b>";
9: ?>
10: </body>
11: </html>
This is the first script in this book that is not designed to be called by hitting a link
or typing directly into the browser's location field. We include the code from Listing
9.3 in a file called eg9.3.php. This file is called when a user submits the form defined
in Listing 9.2.
In the code, we have accessed two variables, $user and $address. It should come as
no surprise that these variables contain the values that the user added to the text
field named "user" and the text area named "address". Forms in PHP4 really are as
simple as that. Any information submitted by a user will be available to you in global
variables that will have the same names as those of the form elements on an HTML

Accessing Input from Multiple SELECT Elements

The examples so far enable us to gather information from HTML elements that
submit a single value per element name. This leaves us with a problem when
working with
elements. These elements make it possible for the user to

choose multiple items. If we name the
element with plain name
<select name="products" multiple>
the script that receives this data will only have access to a single value
corresponding to this name. We can change this behavior by renaming any
elements of this kind so that its name ends with an empty set of square brackets.
We do this in Listing 9.4.

An HTML Form Including a SELECT Element

1: <html>
2: <head>
3: <title>Listing 9.4 An HTML form including a SELECT element</title>
4: </head>
5: <body>
6: <form action="eg9.5.php" method="POST">
7: <input type="text" name="user">
8: <br>
9: <textarea name="address" rows="5" cols="40">
10: </textarea>
11: <br>
12: <select name="products[]" multiple>
13: <option>Sonic Screwdriver
14: <option>Tricorder
15: <option>ORAC AI
16: <option>HAL 2000
17: </select>
18: <br>
19: <input type="submit" value="hit it!">
20: </form>
21: </body>
22: </html>
In the script that processes the form input, we now find that input from the
element will be available in an array called
. We
demonstrate this in Listing 9.5.
Listing 9.5: Reading Input from the Form in Listing 9.4
1: <html>
2: <head>
3: <title>Listing 9.5 Reading input from the form in Listing 9.4</title>
4: </head>

5: <body>
6: <?php
7: print "Welcome <b>$user</b><p>\n\n";
8: print "Your address is:<p>\n\n<b>$address</b><p>\n\n";
9: print "Your product choices are:<p>\n\n";
10: print "<ul>\n\n";
11: foreach ( $products as $value )
12:    {
13:    print "<li>$value<br>\n";
14:    }
15: print "</ul>";
16: ?>
17: </body>
18: </html>
element is not the only one that allows for multiple values. By giving
a number of check boxes the same name, you can allow a user to choose many
values within a single field name. As long as the name you choose ends with empty
square brackets, PHP compiles the user input for this field into an array. We can
replace the
element in Listing 9.4 with a series of check boxes to achieve
exactly the same effect:
<input type="checkbox" name="products[]" value="Sonic Screwdriver">
Sonic Screwdriver<br>
<input type="checkbox" name="products[]" value="Tricorder">Tricorder<br>
<input type="checkbox" name="products[]" value="ORAC AI">ORAC AI<br>
<input type="checkbox" name="products[]" value="HAL 2000">HAL 2000<br>

Accessing All the Fields from a Form in an Associative
The techniques you have looked at so far work well, as long as your script knows in
advance what fields to expect. You may often want to write code that can adapt to
changes in a form or even service more than one form, without worrying itself about
the names of specific form fields. The global variables that PHP4 makes available
provide the solution to this problem. According to whether or not a submitting form
used the  GET or  POST method, you will have access to one or both of
$HTTP_GET_VARS or $HTTP_POST_VARS. These are associative arrays that contain
the name/value pairs submitted.  Listing 9.6 takes advantage of this to list all the
fields submitted from a form via a GET request.

Reading Input from Any Form Using the  $HTTP_GET_VARS
1: <html>
2: <head>
3: <title>Listing 9.6 Reading input from any form using the $HTTP_GET_VARS
4: </head>
5: <body>
6: <?php
7: foreach ( $HTTP_GET_VARS as $key=>$value )
8:    {
9:    print "$key == $value<BR>\n";
10:    }
11: ?>
12: </body>
13: </html>
This code lists the names and values of all parameters passed to it via a  GET
transaction. Of course, it's not yet smart enough to deal with parameters that have
been set up to resolve to arrays. If we were to amend the HTML form in Listing 9.4
that includes a multiple  SELECT element to point to the script in Listing 9.6, we
would typically get the following output when the form was submitted:
user == Matt Zandstra
address == London, England
products == Array
The products array exists in the $HTTP_GET_VARS[products] array item, but we
haven't yet written code to take account of this eventuality.  Listing 9.7 tests the
data type of each of the elements in $HTTP_GET_VARS and amends the output

Reading Input from Any Form Using the  $HTTP _GET_VARS
1: <html>
2: <head>
3: <title>Listing 9.7 Reading input from any form using the $HTTP_GET_VARS
4: </head>
5: <body>
6: <?php

7: foreach ( $HTTP_GET_VARS as $key=>$value )
8:    {
9:    if ( gettype( $value ) == "array" )
10:       {
11:       print "$key == <br>\n";
12:       foreach ( $value as $two_dim_value )
13:          print ".........$two_dim_value<br>";
14:       }
15:    else
16:       {
17:       print "$key == $value<br>\n";
18:       }
19:    }
20: ?>
21: </body>
22: </html>
As before, we use foreach to loop through the $HTTP_GET_VARS array. We use the
gettype() function to ascertain whether each of its values is an array. If the value is
itself an array, we create a second foreach statement to loop through it, outputting
each value to the browser


Post a Comment