Save this script as colors.php, and view it in your Web browser. You should see
an HTML page containing a table with three rows and two columns, with one column
containing a color and the other its corresponding name (Figure 1-4).
Use your browser’s View Source command to inspect the HTML code of the page, and
you’ll see that the PHP parser has interpolated the output of the various echo statements
into the HTML source code to create a complete HTML page. This is a very common
Figure 1-4
A Web page containing colors and color codes, generated by mixing PHP
with HTML
Chapter 1:
Introducing PHP
technique used for building Web applications with PHP, and you’ll see it in almost every
example that follows.
Escaping Special Characters
There’s one interesting thing about colors.php that bears explaining: the numerous
backslashes used in the script. Look at the PHP-generated third row of the HTML table,
and then at the corresponding HTML source code of the output page, and you’ll notice
that none of these backslashes make an appearance. Where did they go?
There’s a simple explanation for this. As you’ve already seen, output to be displayed
by PHP is wrapped in quotation marks. But what happens when the output to be displayed
includes quotation marks of its own, as occurs with the HTML code generated in colors.php?
If you simply enclose one set of quotation marks within another, PHP will get confused
about which quotation marks are to be printed literally, and which ones are simply
used to enclose the string value, and will generate a parser error Therefore, to handle
these situations, PHP allows you to escape certain characters by preceding them with a
backslash (\). There so-called escape sequences include
Sequence
What It Represents
\n
a line feed character
\t
a tab
\r
a carriage return
\"
a double quotation mark
\'
a single quotation mark
When the parser encounters one of these escape sequences, it knows to replace it with
the corresponding value before sending it to the output device. Consider, for example, this
line of code:
PHP knows that the quotation marks preceded with a backslash are to be printed “as is,”
and it will not confuse them with the quotation marks that signal the beginning and end of
a string. This is why you see a backslash before every PHP-generated quotation mark and
line feed in colors.php.
15
16
PHP: A Beginner’s Guide
Ask the Expert
Q:
Why does the colors.php script use single quotes in some places, and double quotes in
others?
A:
Escape sequences, such as those for line feeds (\n), carriage returns (\r), and double
quotation marks (\"), can only be understood by the PHP parser when they are themselves
enclosed in double quotes. If these escape sequences are enclosed in single quotes, they
will be printed “as is.”
Consider the following code snippets and their output, which illustrate the difference:
Now, the colors.php script is responsible for dynamically generating the HTML
code for the last row of the HTML table. This row code must be formatted for easy
readability, with
and elements appearing on different lines. Performing this
task requires use of the line feed (\n) escape sequence, which, as explained earlier, is
only recognized when enclosed within double quotes. This is why double quotes are
used at certain places within the colors.php script.
Sample Applications
Obviously, there’s a lot more to PHP than just the echo statement, and you’ll get a crash
course in the language’s many different capabilities in subsequent chapters. For the
moment, though, this is a good place to take a well-earned break, grab some coffee, and
reflect on all you’ve just learned. And just to whet your interest for what’s coming up,
here’s a small sample of the many applications that developers just like you have used
PHP for.
Chapter 1:
Introducing PHP
phpMyAdmin
The phpMyAdmin (www.phpmyadmin.net/) application is a PHP-based administration
tool for the MySQL RDBMS. One of the most popular projects on the SourceForge
network, it allows table and record creation and modification, index management, ad hoc
SQL query execution, data import and export, and database performance monitoring.
phpBB
The phpBB (www.phpbb.com/) application is a robust, open-source PHP implementation
of an online bulletin board system that is both easy to use and simple to administer. It
provides a simple, user-friendly discussion board for portal members and includes support
for features like message posting and replying, message threading, subject/body search,
themes, private messages, and many others.
Gallery
Gallery (http://gallery.menalto.com/) is a highly configurable digital photo archive written
in PHP. It supports multiple image galleries and multiple keywords per photo, and it
includes features such as automatic thumbnail creation, image captioning and editing,
keyword search, and gallery-level authentication.
Ask the Expert
Q:
I understand how the backslash is used to mark escape sequences. But what happens
if I need to print an actual backslash in my output?
A:
The solution to this is fairly simple: use a double backslash!
PoMMo
PoMMo (www.pommo.org/) is a mass-mailing application written entirely in PHP. It is
particularly useful for managing and sending e-mail messages to one or more subscriber
mailing lists, and it also supports the use of customized input forms for the collection of
subscriber data. It allows administrators to import and export subscriber data from a MySQL
database, and subscribers to manage their subscriptions through an online control panel.
17
18
PHP: A Beginner’s Guide
Smarty
Smarty (www.smarty.net/) is a PHP-based framework for separating the business logic
of a PHP application from its user interface. It achieves this separation through the use
of templates containing output placeholders, which are replaced at run time with actual
content. Smarty supports template caching and nesting, pre- and post-rendering filters,
and built-in functions to simplify common tasks. It has rapidly become one of the most
popular template engines for PHP-based application development.
Squirrelmail
Squirrelmail (www.squirrelmail.org/) is a Web-based mail client written in PHP, with support
for both the SMTP and IMAP protocols. It includes the ability to send and receive attachments,
manage address book collections, and manipulate server-based mailboxes. The application is
highly configurable and can be extended through the use of plug-ins and themes.
eZ Publish
The eZ Publish (www.ez.no/) application is a PHP-based content management system that is
suitable for the development of both small, personal Web pages and large, corporate Web sites.
It includes support for creating and editing content, tracking changes, building customized
publishing workflows, and setting up a “Web shop” with integrated e-commerce functions.
Mantis
Mantis (www.mantisbt.org/) is a Web-based bug-tracking system designed specifically to
track and resolve issues for software and other projects. It supports multiple user access
levels, multiple projects, and multiple priority levels, and it includes a full-featured search
engine and various built-in reports for up-to-date snapshots of a project’s status.
Wordpress
Wordpress (www.wordpress.org/) is a well-known Weblog (aka blog) publishing tool. It
allows users to maintain and publish online diaries of their activities and supports themes,
tags, automatic spell-checking, video and photo upload, and built-in spam protection. It’s
extremely fast, easy to set up, and simple to use—three reasons that have made it popular
with millions of bloggers around the world.
Summary
This chapter provided a gentle introduction to the world of PHP, discussing the history
and evolution of the language and highlighting some of its unique features and advantages
vis-à-vis competing alternatives. It explained the various components of the typical PHP
Chapter 1:
Introducing PHP
development environment and illustrated how they interact with each other. Finally, it
got you started writing PHP code, showing you the basic syntactical rules of the language
and explaining how to embed PHP code inside HTML documents using the special
PHP tags through an easy project. These basic skills will serve you well
through the next chapter, which gives you a crash course in two of the PHP’s fundamental
building blocks: variables and operators.
If you’d like to learn more about the topics discussed in this chapter, you’ll find the
following links useful:
✓
●
The official PHP Web site, at www.php.net
●
PHP usage statistics, at www.php.net/usage.php
●
A brief history of PHP, at www.php.net/manual/en/history.php
●
The community behind PHP, at www.php.net/credits.php
Chapter 1 Self Test
1. Which are the four components of the LAMP framework?
2. Why is PHP superior to client-side languages such as JavaScript?
3. What does the echo statement do?
4. What happens when the PHP parser encounters whitespace or blank lines in a PHP
script?
5. What character must necessarily be used to terminate every PHP statement? Name one
situation where omitting this termination character does not produce an error.
6. What is an escape sequence? Name three commonly used escape sequences.
7. What will be the output of the following PHP scripts:
A
B
19
20
PHP: A Beginner’s Guide
8. Find the error in each of the following PHP scripts:
A
B
Copyright Me, 2008';
?>
C
Chapter
2
Using Variables
and Operators
21
Copyright © 2009 by The McGraw-Hill Companies. Click here for terms of use.
22
PHP: A Beginner’s Guide
Key Skills & Concepts
●
Create and use variables and constants
●
Understand PHP’s simple data types
●
Become familiar with some of PHP’s built-in functions
●
Perform arithmetic operations
●
Compare and logically test variables
●
Handle data submitted through a Web form
T
he preceding chapter gave you a gentle introduction to PHP, letting you get your hands
dirty with two simple projects. However, as you’ll shortly see, PHP is good for much
more than simply filling in the blanks in an HTML page. In this chapter, you’ll learn about
variables and operators, the two basic building blocks of any PHP program, and you’ll
begin using them to develop more sophisticated programs. You’ll also create your very
first interactive PHP script, one which asks for, and responds to, a user’s input. So without
further ado, let’s jump straight in!
Storing Data in Variables
A variable is simply a container that’s used to store both numeric and non-numeric
information. And just as with any container, you can move it from place to place, add stuff
to it, or empty it out on the floor in a pile and fill it with something completely different.
To stretch the analogy a little further, just as it’s a good idea to label every container,
so too should you give every variable in your program a name. As a general rule, these
names should make sense and should be easy to understand. In the real world, this makes
it easier to find things; in the programming world, it makes your code cleaner and easier
to understand by others. As someone who’s been there, I can tell you that there’s nothing
more frustrating than spending three hours searching a bunch of boxes for Mom’s best
china, only to realize it’s in the one marked “Miscellaneous” together with an old rubber
bone and some crumbly biscuits!
PHP has some simple rules for naming variables. Every variable name must be
preceded with a dollar ($) symbol and must begin with a letter or underscore character,
Chapter 2:
Using Variables and Operators
optionally followed by more letters, numbers, or underscore characters. Common
punctuation characters, such as commas, quotation marks, or periods, are not permitted in
variable names; neither are spaces. So, for example, $root, $_num, and $query2 are
all valid variable names, while $58%, $1day, and email are all invalid variable names.
Assigning Values to Variables
Assigning a value to a variable in PHP is quite easy: use the equality (=) symbol, which
also happens to be PHP’s assignment operator. This assigns the value on the right side of
the equation to the variable on the left.
To use a variable in a script, simply call it by name in an expression and PHP will
replace it with its value when the script is executed. Here’s an example:
Welcome to 's Blog!
In this example, the variable $name is assigned the value 'Simon'. The echo statement
is then used to print the value of this variable to the Web page.
You can also assign a variable the value of another variable, or the result of a calculation.
The following example demonstrates both these situations:
23
24
PHP: A Beginner’s Guide
Ask the Expert
Q:
Is it possible for a variable’s name itself to be a variable?
A:
In rare situations, you might find it useful to set a variable’s name dynamically, at run
time. PHP allows you to do this, by enclosing the dynamic part of the variable name
in curly braces. The following example illustrates:
Destroying Variables
To destroy a variable, pass the variable to PHP’s aptly named unset() function, as in the
following example:
Chapter 2:
Using Variables and Operators
NOTE
Trying to access or use a variable that’s been unset(), as in the preceding script,
will result in a PHP “undefined variable” error message. This message may or may
not be visible in the output page, depending on how your PHP error reporting level
is configured. Refer to Chapter 10 for more information on how PHP errors work.
Alternatively, empty a variable of its contents by assigning PHP’s special NULL value
to it. You can read more about PHP’s NULL data type in the next section, but here’s a quick
revision of the preceding example to illustrate how it works:
CAUTION
Variable names in PHP are case-sensitive. As a result, $help refers to a different
variable than does $HELP or $Help. Forgetting this simple rule is a common cause
of frustration among developers new to PHP programming.
Inspecting Variable Contents
PHP offers the var_dump() function, which accepts a variable and X-rays it for you.
Here’s an example:
25
26
PHP: A Beginner’s Guide
TIP
There’s also a print_r() function that performs the same function as var_dump(),
although it returns less information.
Understanding PHP’s Data Types
The values assigned to a PHP variable may be of different data types, ranging from simple
string and numeric types to more complex arrays and objects. You’ve already seen two of
these, strings and numbers, in action in previous examples. Here’s a full-fledged example,
which introduces three more data types:
●
Booleans are the simplest of all PHP data types. Like a switch that has only two states,
on and off, it consists of a single value that may be set to either 1 (true) or 0 (false).
In this listing, $validUser is a Boolean variable set to true.
●
PHP also supports two numeric data types: integers and floating-point values. Floatingpoint values (also known as floats or doubles) are decimal or fractional numbers, while
integers are round numbers. Both may be less than, greater than, or equal to zero. In
this listing, $size holds an integer value, while $temp holds a floating-point value.
●
For non-numeric data, PHP offers the string data type, which can hold letters, numbers,
and special characters. String values must be enclosed in either single quotes or double
quotes. In the previous listing, $cat is a string variable containing the value 'Siamese'.
●
You may also encounter the NULL data type, which is a “special” data type first
introduced in PHP 4. NULLs are used to represent “empty” variables in PHP; a variable
of type NULL is a variable without any data. In the preceding listing, $here is NULL.
Chapter 2:
Using Variables and Operators
Ask the Expert
Q:
Does PHP support numbers written in hexadecimal, octal, or scientific notation?
A:
Yes, yes, and yes. Here are some examples:
CAUTION
Many novice PHP developers mistakenly believe that assigning the empty string '' to a
variable automatically renders it empty. This is untrue, as PHP does not consider a NULL
value equivalent to an empty string. To definitely remove a variable’s contents, always
set it to NULL.
Setting and Checking Variable Data Types
Unlike other programming languages, where a variable’s data type must be explicitly
defined by the programmer, PHP automatically determines a variable’s data type from the
content it holds. And if the variable’s content changes over the duration of a script, the
language will automatically set the variable to the appropriate new data type.
Here’s an example which illustrates this type juggling:
This example introduces PHP’s gettype() operator, which is a handy little tool
for finding out the type of a particular variable. As the script output demonstrates, the
variable $whoami begins life as a string, assigned the value 'Sarah'. It’s then assigned
the number 99.8, which automatically converts it to a floating-point variable. Following
this, the variable is de-initialized with the unset() method, which removes its value and
turns it into a NULL. PHP has been the invisible hand behind each of these conversions,
internally resetting the data type of $whoami from string to floating-point to null.
This doesn’t mean that you’re entirely at PHP’s mercy, however; it’s possible to
explicitly set the type of a PHP variable by casting a variable to a specific type before
using it. Casting is a technique commonly used by Java programmers; to use it, simply
specify the desired data type in parentheses on the right side of the assignment equation.
Consider the following example, which illustrates turning a floating-point value into an
integer value:
In addition to the gettype() function, PHP includes a number of more specialized
functions, to test if a variable is of a specific type. Table 2-1 has a list.
TIP
Remember that var_dump() function you met in a previous section? If you look closely
at its output, you’ll see that in addition to telling you what a variable contains, it also
shows you the variable’s data type.
Chapter 2:
Using Variables and Operators
Function
Purpose
is_bool()
Tests if a variable holds a Boolean value
is_numeric()
Tests if a variable holds a numeric value
is_int()
Tests if a variable holds an integer
is_float()
Tests if a variable holds a floating-point value
is_string()
Tests if a variable holds a string value
is_null()
Tests if a variable holds a NULL value
is_array()
Tests if a variable is an array
is_object()
Tests if a variable is an object
Table 2-1 PHP Functions to Test Variable Data Types
Using Constants
So far, this chapter has focused mainly on variables, which are good for storing and changing
values over the lifetime of a PHP script. But what if you need to store a fixed value, one that
remains static over the course of a script? Well, that’s when you reach for a constant.
As the name suggests, constants are PHP containers for values that remain constant
and never change. They’re mostly used for data that is known well in advance and that
is used, unchanged, in multiple places within your application. Good candidates for
constants are debug and log levels, version numbers, configuration flags, and formulae.
Constants are defined using PHP’s define() function, which accepts two arguments:
the name of the constant, and its value. Constant names must follow the same rules as
variable names, with one exception: the $ prefix is not required for constant names.
Here’s an example of defining and using a constant in a script:
NOTE
By convention, constant names are usually entirely uppercased; this is to enable their
easy identification and differentiation from “regular” variables in a script.
29
30
PHP: A Beginner’s Guide
Manipulating Variables with Operators
By themselves, variables are simply containers for information. In order to do anything
useful with them, you need operators. Operators are symbols that tell the PHP processor
to perform certain actions. For example, the addition (+) symbol is an operator that tells
PHP to add two variables or values, while the greater-than (>) symbol is an operator that
tells PHP to compare two values.
PHP supports more than 50 such operators, ranging from operators for arithmetical
operations to operators for logical comparison and bitwise calculations. This section
discusses the most commonly used operators.
Ask the Expert
Q:
When should I use a variable, and when should I use a constant?
A:
Variables are temporary storage; use them for values which are likely to change over
the course of the script. Constants are a little more permanent; use them for values
that are likely to remain fixed and are referenced multiple times in your script. Unlike
variables, constants cannot be unset, nor can their names be generated dynamically.
Performing Arithmetic Operations
PHP supports all standard arithmetic operations, as illustrated by the list of operators
in Table 2-2.
Operator
Description
+
Add
-
Subtract
*
Multiply
/
Divide and return quotient
%
Divide and return modulus
Table 2-2 Common Arithmetic Operators
Chapter 2:
Using Variables and Operators
And here’s an example illustrating these operators in action:
Ask the Expert
Q:
Is there any limit on how large a PHP integer value can be?
A:
Yes there is, but it’s pretty high: 2147483647. This limit is defined by PHP in its
PHP_INT_MAX constant, so you can check it yourself at any time.
Concatenating Strings
To combine strings, use PHP’s concatenation operator, which happens to be a period (.).
The following example illustrates:
Comparing Variables
PHP lets you compare one variable or value with another via its wide range of comparison
operators, listed in Table 2-3.
And here’s an example illustrating these operators in action:
$p);
// test if $q is less than $p
// returns false
echo ($q < $p);
// test if $q is greater than or equal to $s
// returns true
echo ($q >= $s);
// test if $r is less than or equal to $s
// returns false
echo ($r <= $s);
Operator
Description
==
Equal to
!=
Not equal to
>
Greater than
>=
Greater than or equal to
<
Less than
<=
Less than or equal to
===
Equal to and of the same type
Table 2-3 Common Comparison Operators
Chapter 2:
Using Variables and Operators
// test if $q is equal to $s
// returns true
echo ($q == $s);
// test if $q is equal to $r
// returns false
echo ($q == $r);
?>
It’s worth making special mention here of the === operator, which is excluded from
the preceding example. This operator allows for stricter comparison between variables: it
only returns true if the two variables or values being compared hold the same information
and are of the same data type. Thus, in the next example, a comparison between $bool
and $num would return true when compared with the == operator, but false when
compared with the === operator:
Performing Logical Tests
When building complex conditional expressions—a topic that will be discussed in detail
in Chapter 3—you will often come across situations where it’s necessary to combine
one or more logical tests. PHP’s three most commonly used logical operators, listed in
Table 2-4, are intended specifically for this situation.
Operator
Description
&&
AND
||
OR
!
NOT
Table 2-4 Common Logical Operators
33
34
PHP: A Beginner’s Guide
Logical operators really come into their own when combined with conditional tests,
so the following example is illustrative only; you’ll find something much meatier to chew
on in Chapter 3.
50 && $size < 25);
// logical OR test
// returns true if any of the comparisons are true
// returns false here
echo ($price > 150 || $size > 75);
// logical NOT test
// reverses the logical test
// returns false here
echo !($size > 10);
?>
Other Useful Operators
There are a few other operators that tend to come in handy during PHP development. First,
the addition-assignment operator, represented by the symbol +=, lets you simultaneously
add and assign a new value to a variable. The following example illustrates:
Here, the expression $count +=7 is equivalent to the expression $count =
$count + 2—an addition operation followed by an assignment of the result back to the
same variable. In a similar vein, there exist operators for other mathematical and string
assignments. Table 2-5 has a list.
Chapter 2:
Using Variables and Operators
Operator
Description
+=
Add and assign
-=
Subtract and assign
*=
Multiply and assign
/=
Divide and assign quotient
%=
Divide and assign modulus
.=
Concatenate and assign (strings only)
Table 2-5 Common Assignment Operators
Here are examples of these in action:
As you proceed through this book, you’ll also comes across the auto-increment
and auto-decrement operators, represented by the ++ and -- symbols respectively.
35
36
PHP: A Beginner’s Guide
The operators automatically add 1 to, or subtract 1 from, the variable they are applied to.
Here’s an example:
These operators are commonly found in loop counters, another topic that will be
discussed in detail in Chapter 3.
Understanding Operator Precedence
Back in math class, you probably learned about BODMAS, a mnemonic that specifies
the order in which a calculator or a computer performs a sequence of mathematical
operations: Brackets, Order, Division, Multiplication, Addition, and Subtraction. Well,
PHP follows a similar set of rules when determining which operators have precedence
over others—and learning these rules can save you countless frustrating hours debugging
a calculation that looks right, yet somehow always returns the wrong result!
The following list (a short version of a much longer list in the PHP manual)
illustrates PHP’s most important precedence rules. Operators at the same level have
equal precedence.
●
++ --
●
!
●
* / %
●
+ - .
●
< <= > >=
Chapter 2:
●
== != === !==
●
&&
●
||
●
= += -= *= /= .= %= &= |= ^=
Using Variables and Operators
Ask the Expert
Q:
PHP’s precedence rules are tough to remember. Is there an easier way to tell
PHP the order in which I’d like a calculation performed?
A:
Yes. Parentheses always have the highest precedence, so wrapping an expression in
these will force PHP to evaluate it first. When using multiple sets of parentheses,
remember that evaluation begins from the innermost set of parentheses and proceeds
outward (rather like peeling an onion from the inside). As an example, consider the
expression (((4 * 8) - 2) / 10), which evaluates to 3 with parentheses and
31.8 without.
Try This 2-1
Building a Dollars-to-Euros Converter
Let’s now take a quick break from all this theory and try applying some of it to a practical,
real-world project: a currency converter for dollars into euros. This project will apply some
of what you’ve learned in previous sections about variables, constants, and arithmetic
operators; it’ll also come in handy the next time you jet off to Europe on vacation!
Here’s the code (convert.php):
Project 2-1: USD/EUR Currency Conversion
Project 2-1: USD/EUR Currency Conversion
If you’ve been following along, this script should be fairly easy to understand. It
begins by defining a constant named EXCHANGE_RATE which—surprise, surprise—stores
the dollar-to-euro exchange rate (assumed here at 1.00 U.S. dollar to 0.70 euro). Next, it
defines a variable named $dollars to hold the number of dollars to be converted, and
then it performs an arithmetic operation using the * operator, the $dollars variable, and
the EXCHANGE_RATE constant to return the equivalent number of euros. This result is then
stored in a new variable named $euros, and printed to the Web page.
Figure 2-1 illustrates what the output looks like.
To convert a different quantity of dollars, simply change the $dollars variable. Go
on, give it a whirl and see for yourself!
Figure 2-1
The output of the dollars-to-euros converter
Chapter 2:
Using Variables and Operators
Handling Form Input
So far, all the examples you’ve seen have had their variables neatly defined at the top
of the script listing. However, as your PHP scripts become more complex, this happy
situation will change, and you’ll need to learn how to interact with user-supplied input.
The most common source of this information is a Web form, and PHP comes with a
simple mechanism to retrieve information submitted through such forms.
To illustrate, consider the following simple Web form (choose.html), which asks you
to select a brand of automobile and enter your desired color:
Select Your Car
As forms go, this is a fairly simple one: it has a selection list and an input box.
Figure 2-2 illustrates what it looks like.
Notice the 'action' attribute of this Web form: it references a PHP script named
car.php. This is the script that receives the data entered into the form once the form is
submitted. Notice also the form’s 'method' attribute, which specifies that the submission
of data will occur through the POST method.
With these two facts firmly in mind, let’s take a look at car.php next:
Success!
39
40
PHP: A Beginner’s Guide
Figure 2-2
A simple form
What’s going on here? Well, whenever a form is submitted to a PHP script through the
POST method, the form’s input variables and their values automatically become available
to the PHP script through a special container variable named $_POST. Accessing the value
entered into a particular form field then becomes as simple as referencing $_POST with
the corresponding field’s name, as in the preceding script.
Consider, for example, the task of accessing the color entered by the user in the Web
form. From the form code, it can be seen that the text input field designated for this data
in the form is named 'txtColor'. Therefore, within the PHP script, the value entered
into this text input field can be accessed using the syntax $_POST['txtColor'].
Chapter 2:
Figure 2-3
Using Variables and Operators
The result of submitting the form
This value can then be used in the normal fashion: it may be printed to the Web page,
assigned to another variable, or manipulated using one of the many operators discussed
in preceding sections.
Figure 2-3 illustrates the result of submitting the form.
In case your Web form submits data using the GET method instead of the POST
method, PHP has you covered there as well: form input submitted using the GET method
finds a home in the $_GET container variable and may be accessed by referencing $_GET
instead of $_POST.
Ask the Expert
Q:
I understood the previous sections about variables and how they work, but
$_GET and $_POST don’t seem to follow those rules. What’s going on here?
A:
The $_GET and $_POST variables are different from the simple string and numeric
variable types you’ve seen so far in this chapter. They’re a more complex type of
variable known as an array, which can hold more than one value at a time and which
also follows different rules for storing and accessing the values within it. Arrays will
be discussed extensively in Chapter 4, at which point everything you’ve just read
about $_GET and $_POST will fall into place.
41
42
PHP: A Beginner’s Guide
Try This 2-2
Building an Interactive HTML
Color Sampler
Now that you’ve understood how to access form input through a PHP script, let’s put
together an application that demonstrates this feature in a more practical way. In this
project, you’ll build an HTML color sampler, a tool that will let you enter RGB color
values and will display a swatch of the corresponding color in your Web browser. The
RGB color values will be entered into a form and processed with PHP, thus providing a
real-world usage example of what you’ve learned in the preceding section.
First up, the Web form (color.html):
Project 2-2: An Interactive HTML Color Sampler
Project 2-2: An Interactive HTML Color Sampler
Pretty standard fare here—a Web form with three input fields, one each for the red,
green, and blue color components. Notice that this form submits its data to a PHP script
named display.php, and it uses the GET method (for variety).
Figure 2-4 illustrates what the form looks like.
Next up, the PHP script that accepts the input and uses it to display a color swatch
(display.php):
Project 2-2: An Interactive HTML Color Sampler
Project 2-2: An Interactive HTML Color Sampler
R:
G:
B:
The data entered into the form becomes accessible through the $_GET array (notice
that it’s $_GET because the GET method was used to submit the form). This data is then
swept into three variables by this script: $r, $g, and $b. These are then concatenated into
a single string using PHP’s concatenation operator (remember him?). This RGB string
is then used to set the background color for a element a little further down in the
HTML document.
(continued)
43
44
PHP: A Beginner’s Guide
Figure 2-5
The color sample resulting from form submission
The result? When the browser renders the page, you’ll see a 150×150 block solidfilled with the color corresponding to the selected RGB values. And if you go back to
the Web form and enter a new set of RGB codes, the color will change appropriately . . .
hence the “interactive” in “interactive color sampler”!
Figure 2-5 illustrates what happens when you enter the codes 153,153,153 (a light
shade of gray, because this page is in black and white).
Table 2-6 has some more RGB color combinations for you to try.
Color
R
Pink
250
75
200
Orange
255
105
0
Yellow
255
255
0
Green
75
200
60
Brown
100
75
25
Table 2-6 Sample RGB Color Combinations
G
B
Chapter 2:
Using Variables and Operators
Summary
This chapter probably took you a little longer to get through than the preceding one, but at
the end of it, your knowledge of PHP’s basic constructs should have noticeably increased.
The chapter began by introducing you to PHP variables and constants, explaining how
to name them, assign values to them, use them in a script, and destroy them when done.
It gave you a quick introduction to PHP’s simple data types and then took you on a
whirlwind tour of PHP’s arithmetic, string, comparison, and logical operators, using
commented examples to explain how each of these operators could be used to manipulate
and modify variable contents.
With these basics out of the way, the chapter proceeded to an explanation of how to
process form input with PHP, a common task that you’ll perform over and over again
through the course of this book and, indeed, throughout your career as a PHP developer.
Finally, two projects—one demonstrating the use of operators to perform calculations on
variables and the other illustrating how easy it is to create an interactive PHP application
using form input—showed how this learning can be put to practical use.
The next chapter will build on everything you’ve learned so far, explaining how you
can add intelligence to your PHP scripts through the use of conditional tests, and showing
you how PHP’s loop constructs can help in performing repetitive actions. Until then,
though, spend some time looking at these PHP manual links, which offer more detailed
information on the topics discussed in this chapter:
✓
●
PHP data types, at www.php.net/manual/en/language.types.php
●
Type juggling and typecasting in PHP, at
www.php.net/manual/en/language.types.type-juggling.php
●
PHP type comparison tables, at www.php.net/manual/en/types.comparisons.php
●
Variable basics, at www.php.net/manual/en/language.variables.php
●
PHP operators and operator precedence, at
www.php.net/manual/en/language.operators.php
●
Accessing form data with PHP, at
www.php.net/manual/en/language.variables.external.php
Chapter 2 Self Test
1. The PHP function to detect the type of a variable is: _____________
2. Identify which of the following variable names are invalid: $24, $IAMHERE, $_error,
$^b, ${$var}, $yA_K
45
46
PHP: A Beginner’s Guide
3. Write a PHP statement to create a constant value holding the name of your favorite
ice-cream flavor.
4. Write a PHP script to initialize a variable and then increment its value by 3.
5. Mark the following statements as true or false:
A The unset() function de-initializes a variable and removes it from the program’s
variable space.
B The PHP expressions $c = '' and $c = null are equivalent.
C The result of the calculation (56 - 1 * 36 % 7) is 6.
D The == operator tests two variables for both value and type equality.
E The OR logical operator has higher precedence than the AND logical operator.
F The is_numeric() function returns true if passed a floating-point value.
G Casting a floating-point number to an integer always results in the number being
rounded down.
H Form elements of type 'hidden' are excluded from $_POST and $_GET.
6. What are the values of $x and ABC at the end of the following PHP script?
7. What is the likely output of the following PHP script?
8. What is the likely output of the following PHP script?
9. Rewrite the code from Try This 2-1 such that both the exchange rate and the amount to
be converted are supplied by the user through a Web form.
Chapter 2:
Using Variables and Operators
10. Write a PHP script that accepts a temperature value in Celsius (C) through a Web
form and converts it to the Fahrenheit (F) scale. The conversion formula to use is:
F = (9/5) * C + 32.
11. Write a PHP script to display the values entered into a Web form that contains:
●
One text input field
●
One selection list
●
One text area
●
Two radio buttons
●
One hidden field
●
Two checkboxes
●
One password field
47
This page intentionally left blank
Chapter
3
Controlling
Program Flow
49
Copyright © 2009 by The McGraw-Hill Companies. Click here for terms of use.
50
PHP: A Beginner’s Guide
Key Skills & Concepts
●
Learn to use conditional statements like if-else and switch-case
●
Automate repetitive tasks with the while, do-while, and for loops
●
Gain experience with PHP’s built-in string and numeric functions
T
he PHP programs you saw in the preceding chapter were fairly straightforward: they
accepted one or more input values, performed calculations or comparisons with
them, and returned a result. In reality, though, PHP programs are never so simple: most
programs will need to make complex decisions and execute different operations at run
time in accordance with programmer-specified conditions.
In this chapter, you’ll learn how to create PHP programs that are more “intelligent”
and can perform different actions based on the results of a logical or comparative test.
You’ll also learn how to automate repetitive actions using loops, and find out more about
PHP’s built-in functions for working with strings and numbers. To ensure that you’re able
to apply this learning in the real world, this chapter also lets you test your newly acquired
knowledge against four practical projects.
Writing Simple Conditional Statements
In addition to storing and retrieving values in variables, PHP also lets programmers
evaluate different conditions during the course of a program and take decisions based
on whether these conditions evaluate to true or false. These conditions, and the actions
associated with them, are expressed by means of a programming construct called a
conditional statement. PHP supports different types of conditional statements, each one
intended for a particular use.
The if Statement
The simplest of PHP’s conditional statements is the if statement. This works much like
the English-language statement, “if X happens, do Y.” Here’s a simple example, which
contains a conditional statement that checks if the value of the $number variable is less
than 0 and prints a notification message if so.
Chapter 3:
Controlling Program Flow
The key to the if statement is thus the condition to be evaluated, which is always
enclosed in parentheses. If the condition evaluates to true, the code within the curly braces
is executed; if it evaluates to false, the code within the curly braces is skipped. This true/
false test is performed using PHP’s comparison operators, which you learned about in the
preceding chapter; Table 3-1 quickly recaps them.
The if-else Statement
The if statement is quite basic: it only lets you define what happens when the condition
specified evaluates to true. But PHP also offers the if-else statement, an improved
version of the if construct that allows you to define an alternative set of actions that the
program should take when the condition specified evaluates to false. Using this statement
often results in more compact and readable code, because it lets you combine two actions
into a single, unified code block. In English, this statement would read, “if X happens,
do Y; otherwise, do Z.”
Operator
Description
==
Equal to
!=
Not equal to
>
Greater than
>=
Greater than or equal to
<
Less than
<=
Less than or equal to
===
Equal to and of the same type
Table 3-1
Common Comparison Operators
51
52
PHP: A Beginner’s Guide
To illustrate, consider this revision of the previous listing:
Here, an if-else statement is used to account for two possible outcomes: a number
less than zero, and all other numbers. To see it in action, try running this script once as is,
and then again after changing the value of the $number variable to a positive value.
Ask the Expert
Q:
Is there a more compact way to write an if-else statement?
A:
Yes, there is. It involves a little thingamajig called the ternary operator. This operator,
represented by the question mark (?) symbol, lets you represent an if-else conditional
statement in a single, compact line of code. To see it in action, consider the following two
equivalent scripts:
The Standard if-else Block
The Equivalent Block Using the
Ternary Operator
Here, the ternary operator selects the code on the left of the colon if the condition
evaluates to true, and the code on the right if the condition evaluates to false.
Chapter 3:
Try This 3-1
Controlling Program Flow
Testing Odd and Even Numbers
Now that you know the basics of conditional statements, let’s look at an example of how
they can be used. The following program will ask the user to enter a number into a Web
form, test it to see whether it is odd or even, and return a corresponding message.
Here’s the code (oddeven.php):
Project 3-1: Odd/Even Number Tester
Project 3-1: Odd/Even Number Tester
(continued)
53
54
PHP: A Beginner’s Guide
Figure 3-1
Testing odd and even numbers with PHP
This program consists of two sections: the first half generates a Web form for the user
to enter a value, while the second half checks whether the value is odd or even and prints
an appropriate message. In most cases, these two sections would be in separate files;
they’ve been combined into a single PHP script by the magic of a conditional statement.
How does it work? Well, when the Web form is submitted, the $_POST variable will
contain an entry for the
element. A conditional test then
checks for the presence or absence of this variable: if absent, the program “knows” that
the Web form has not been submitted yet and so prints the form’s HTML code; if present,
the program “knows” that the Web form has been submitted and it then proceeds to test the
input value.
Testing the input value for evenness is handled by a second if-else conditional
statement. Here, the conditional expression consists of dividing the input value by 2
and testing if the remainder is zero. If this test returns true, one message is printed; else,
another message is printed.
Figure 3-1 illustrates what the output of the script looks like.
Writing More Complex Conditional Statements
The if-else statement lets you define actions for two eventualities: a true condition
and a false condition. In reality, however, your program may have more than just these
two simple outcomes to contend with. For these situations, PHP offers two constructs
Chapter 3:
Controlling Program Flow
that allow the programmer to account for multiple possibilities: the if-elseif-else
statement and the switch-case statement.
The if-elseif-else Statement
The if-elseif-else statement lets you chain together multiple if-else statements,
thus allowing the programmer to define actions for more than just two possible outcomes.
Consider the following example, which illustrates its use:
Here, the program will output a different message for each day of the week (as set
in the $today variable). Notice also the final else branch: this is a “catch-all” branch,
which will be triggered if none of the previous conditional statements evaluate to true, and
it’s a handy way to account for situations that you can’t foresee.
There’s one important thing to remember about the if-elseif-else construct:
as soon as one of the conditional statements evaluates to true, PHP will execute the
corresponding code, skip the remaining conditional tests, and jump straight to the lines
following the entire if-elseif-else block. So, even if more than one of the conditional
tests evaluates to true, PHP will only execute the code corresponding to the first true test.
The switch-case Statement
An alternative to the if-elseif-else statement is the switch-case statement, which
does almost the same thing: it tests a variable against a series of values until it finds a
55
56
PHP: A Beginner’s Guide
match, and then executes the code corresponding to that match. Consider the following
code listing, which is equivalent to the preceding one:
The switch-case construct differs from the if-elseif-else construct in one
important way. Once PHP finds a case statement that evaluates to true, it executes not
only the code corresponding to that case statement, but also the code for all subsequent
case statements. If this is not what you want, add a break statement to the end of each
case block (as is done in the previous listing) to tell PHP to break out of the switchcase statement block once it executes the code corresponding to the first true case.
Notice also the 'default' case: as the name suggests, this specifies the default set
of actions PHP should take if none of the other cases evaluate to true. This default case,
like the else branch of the if-elseif-else block, is very useful as a “catch-all”
handler for unforeseen situations.
Chapter 3:
Try This 3-2
Controlling Program Flow
Assigning Boy Scouts to Tents
Let’s now use the if-elseif-else statement to create a small application for
Scoutmasters everywhere: a Web tool that can automatically assign Scouts to the correct
tent during camping expeditions, on the basis of their age. This application presents Scouts
with a Web form into which they can enter their age; it then assigns them to one of four
tents—Red, Green, Blue, and Black—with other Scouts of approximately the same age.
Here’s the code (tent.php):
Project 3-2: Tent Assignment
Project 3-2: Tent Assignment
9 && $age <= 11) {
echo "You're in the Blue tent.";
} elseif ($age > 11 && $age <= 14) {
echo "You're in the Green tent.";
(continued)
57
58
PHP: A Beginner’s Guide
Figure 3-2
The result page, which assigns the user to a tent
} elseif ($age > 14 && $age <= 17) {
echo "You're in the Black tent.";
} else {
echo "You'd better get in touch with the Scoutmaster.";
}
}
?>
Like the previous project in this chapter, this one too combines the Web form and its
result page into a single script, separated by an if-else conditional statement. Once the
Scout enters his age into the Web form and submits it, an if-elseif-else block takes care
of defining four age ranges (one for each tent), testing the input age against these ranges, and
figuring out which tent is most appropriate for the Scout. The age ranges are: 0–9 (Red tent);
10–11 (Blue tent); 12–14 (Green tent); and 14–17 (Black tent). Scouts over the age of 17 see
a message asking them to contact the Scoutmaster to arrange their accommodation.
Figure 3-2 shows the result page of a form submission.
Combining Conditional Statements
PHP allows one conditional statement to be nested within another, to allow for more
complex decision-making. To illustrate this, consider the following listing:
= 3 get a $5000 bonus
// everyone else gets a $3000 bonus
if ($rating >= 3) {
if ($salary < 15000) {
$bonus = 5000;
}
} else {
if ($salary < 15000) {
$bonus = 3000;
}
}
?>
You can also combine conditional statements by using logical operators, such as the
&& or || operator. You learned about logical operators in the preceding chapter; Table 3-2
quickly recaps the list.
Here’s an example of how these logical operators can be used with a conditional
statement:
Repeating Actions with Loops
Like any good programming language, PHP also supports loops—essentially, the ability to
repeat a series of actions until a prespecified condition is fulfilled. Loops are an important
tool that help in automating repetitive tasks within a program. PHP supports four different
Operator
Description
&&
AND
||
OR
!
NOT
Table 3-2
Common Logical Operators
59
60
PHP: A Beginner’s Guide
types of loops, three of which are discussed in the following section (the fourth type is
explained in the next chapter).
The while Loop
The easiest type of loop to understand is the while loop, which repeats continuously
while a prespecified condition is true. Here’s an example, which uses a loop to repeatedly
print an 'x' to the output page.
Notice the condition enclosed in parentheses; so long as this condition evaluates to
true, the code within the curly braces is executed. As soon as the condition becomes false,
the loop stops repeating, and the lines following the loop are executed in the usual fashion.
The do-while Loop
With a while loop, the condition to be evaluated is tested at the beginning of each loop
iteration. There’s also a variant of this loop, the do-while loop, which evaluates the
condition at the end of each loop iteration. Here’s a revision of the preceding example that
illustrates it in action:
The difference in structure should also be apparent: with a do-while loop, the
condition to be evaluated now appears at the bottom of the loop block, rather than the
beginning.
Chapter 3:
Controlling Program Flow
NOTE
The difference in behavior between a while loop and a do-while loop has one
important implication: with a while loop, if the conditional expression evaluates to
false on the first pass itself, the loop will never be executed. With a do-while loop,
on the other hand, the loop will always be executed once, even if the conditional
expression is false, because the condition is evaluated at the end of the loop iteration
rather than the beginning.
The for Loop
The while and do-while loops are fairly simple: they repeat for so long as the specified
condition remains true. But PHP also supports a more sophisticated type of loop, the for
loop, which is useful when you need to execute a set of statements a specific number of
times.
The best way to understand a for loop is by looking at some code. Here’s a simple
example, which lists the numbers between 1 and 10:
In this listing, the loop begins by initializing the counter variable $x to 1; it then
executes the statements that make up the loop. Once it reaches the end of the first loop
iteration, it updates the loop counter by adding 1 to it, checks the conditional expression to
ensure that the counter hasn’t yet reached 10, and executes the loop once more. This process
continues until the counter reaches 10 and the conditional expression becomes false.
As this listing illustrates, there are thus three expressions involved in the typical for
loop, separated by semicolons and enclosed in parentheses:
●
The first of these is an assignment expression, which initializes the loop counter to a
specific value—in this case, assigning the value 1 to the variable $x.
●
The second is a conditional expression, which must evaluate to either true or false;
the loop will continue to execute so long as this condition remains true. Once the
condition becomes false, the loop will stop executing.
●
The third is again an assignment expression, which is executed at the end of each loop
iteration, and which updates the loop counter with a new value—in this case, adding 1
to the value of $x.
61
62
PHP: A Beginner’s Guide
Figure 3-3
A dynamically generated list
Here’s another example, this one demonstrating how to use a for loop to generate an
ordered HTML list:
";
for ($x=1; $x<7; $x++) {
echo "
Item $x ";
}
echo "";
?>
Figure 3-3 illustrates what the output looks like.
Combining Loops
Just as with conditional statements, it’s also possible to nest one loop inside another.
To illustrate, consider the next example, which nests one for loop inside another to
dynamically generate an HTML table.
";
Chapter 3:
Controlling Program Flow
for ($row=1; $row<4; $row++) {
echo "
";
for ($col=1; $col<5; $col++) {
echo "Row $row, Column $col ";
}
echo " ";
}
echo "";
?>
This script utilizes two for loops. The outer loop is responsible for generating the
table rows, and it runs three times. On each iteration of this outer loop, an inner loop is
also triggered; this loop is responsible for generating the cells within each row, and it runs
four times. The end result is a table with three rows, each containing four cells. Figure 3-4
displays this result.
Interrupting and Skipping Loops
While on the topic of loops, it’s interesting to discuss two PHP statements that allow you
to either interrupt a loop or skip a particular iteration of a loop. PHP’s break statement
is aptly named: it allows you to break out of a loop at any point. To illustrate, consider
the following loop, which would normally iterate five times but stops after the second
iteration due to the break statement:
";
}
?>
Unlike break, continue doesn’t halt processing of the loop; it simply “jumps one”
iteration. To see how this works, consider the following loop, which iterates five times but
skips the third iteration due to the intervention of the continue statement:
";
}
?>
Try This 3-3
Building a Factorial Calculator
A simple real-world application that you can try for yourself to better understand how
loops work, is a factorial calculator. In case you were snoozing in math class the day they
discussed factorials, the factorial of a number n is simply the product of all the numbers
between n and 1. So, for example, the factorial of 4 is 4 *3 * 2 * 1 = 24.
The factorial calculator you’ll build in this section is interactive: it asks the user to
enter a number into a Web form, and it then calculates the factorial of that number. Here’s
the code (factorial.php):
Project 3-3: Factorial Calculator
Chapter 3:
Controlling Program Flow
Project 3-3: Factorial Calculator
=1; $x--) {
$factorial *= $x;
}
echo "Factorial of $num is: $factorial";
}
?>
Most of the work here is performed by the for loop. This loop’s counter is initialized
to the number entered by the user, and the loop then runs backward, decrementing the loop
counter by 1 on each iteration. Each time the loop runs, the previously calculated product
is multiplied by the current value of the loop counter. The end result is the factorial of the
input number.
Figure 3-5 shows the result after submitting the form.
65
66
PHP: A Beginner’s Guide
Figure 3-5
The output page, which displays the factorial of the number
Working with String and Numeric Functions
In the preceding chapter, you learned a little bit about PHP’s data types, including its
operators for string and number manipulation. But PHP lets you do a lot more than simply
concatenate strings and add values; the language comes with a full-featured library
of built-in functions that let you do everything from reversing and splitting strings to
calculating logarithmic values. This section will introduce you to some of these functions.
Using String Functions
PHP has over 75 built-in string manipulation functions, supporting operations ranging
from string repetition and reversal to comparison and search-and-replace. Table 3-3 lists
some of these functions.
Checking for Empty Strings
The empty() function returns true if a string variable is “empty.” Empty string variables
are those with the values '', 0, '0', or NULL. The empty() function also returns true
when used with a non-existent variable. Here are some examples:
Function
What It Does
empty()
Tests if a string is empty
strlen()
Calculates the number of characters in a string
strrev()
Reverses a string
str_repeat()
Repeats a string
substr()
Retrieves a section of a string
strcmp()
Compares two strings
str_word_count()
Calculates the number of words in a string
str_replace()
Replaces parts of a string
trim()
Removes leading and trailing whitespace from a string
strtolower()
Lowercases a string
strtoupper()
Uppercases a string
ucfirst()
Uppercases the first character of a string
ucwords()
Uppercases the first character of every word of a string
addslashes()
Escapes special characters in a string with backslashes
stripslashes()
Removes backslashes from a string
htmlentities()
Encodes HTML within a string
htmlspecialchars()
Encodes special HTML characters within a string
nl2br()
Replaces line breaks in a string with
elements
html_entity_decode()
Decodes HTML entities within a string
htmlspecialchars_decode()
Decodes special HTML characters within a string
strip_tags()
Removes PHP and HTML code from a string
Table 3-3
Common PHP String Functions
67
68
PHP: A Beginner’s Guide
Reversing and Repeating Strings
The strlen() function returns the number of characters in a string. Here’s an example
of it in action:
Reversing a string is as simple as calling the strrev() function, as in the next
listing:
In case you need to repeat a string, PHP offers the str_repeat() function, which
accepts two arguments—the string to be repeated, and the number of times to repeat it.
Here’s an example:
Working with Substrings
PHP also allows you to slice a string into smaller parts with the substr() function,
which accepts three arguments: the original string, the position (offset) at which to start
slicing, and the number of characters to return from the starting position. The following
listing illustrates this in action:
Chapter 3:
Controlling Program Flow
NOTE
When using the substr() function, the first character of the string is treated as offset 0,
the second character as offset 1, and so on.
To extract a substring from the end of a string (rather than the beginning), pass
substr() a negative offset, as in this revision of the preceding example:
Ask the Expert
Q:
Can I retrieve a single character of a string? How?
A:
There are two ways to retrieve a single character of a string. The longer way involves
using the substr() function, as in the next listing:
The substr() function accepts three arguments: the original string, the offset
at which substring extraction should begin, and the number of characters to extract
starting from the specified offset. Note that offset counting begins at 0, not 1.
However, PHP also supports a shortcut syntax to accomplish the same thing. This
consists of specifying the offset of the character to be retrieved within curly braces,
after the variable name. The following listing illustrates:
69
70
PHP: A Beginner’s Guide
Comparing, Counting, and Replacing Strings
If you need to compare two strings, the strcmp() function performs a case-sensitive
comparison of two strings, returning a negative value if the first is “less” than the second,
a positive value if it’s the other way around, and zero if both strings are “equal.” Here are
some examples of how this works:
PHP’s str_word_count() function provides an easy way to count the number of
words in a string. The following listing illustrates its use:
If you need to perform substitution within a string, PHP also has the str_replace()
function, designed specifically to perform find-and-replace operations. This function
accepts three arguments: the search term, the replacement term, and the string in which to
perform the replacement. Here’s an example:
Formatting Strings
PHP’s trim() function can be used to remove leading or trailing whitespace from a string;
this is quite useful when processing data entered into a Web form. Here’s an example:
Chapter 3:
Controlling Program Flow
Changing the case of a string is as simple as calling the strtolower() or
strtoupper() function, as illustrated in the next listing:
You can also uppercase the first character of a string with the ucfirst() function,
or format a string in “word case” with the ucwords() function. The following listing
demonstrates both these functions:
Working with HTML Strings
PHP also has some functions exclusively for working with HTML strings. First up, the
addslashes() function, which automatically escapes special characters in a string with
backslashes. Here’s an example:
71
72
PHP: A Beginner’s Guide
You can reverse the work done by addslashes() with the aptly named
stripslashes() function, which removes all the backslashes from a string.
Consider the following example, which illustrates:
The htmlentities() and htmlspecialchars() functions automatically convert
special HTML symbols (like < and >) into their corresponding HTML representations (<
and &
gt;). Similarly, the nl2br() function automatically replaces newline
characters in a string with the corresponding HTML line break tag log in again ';
echo strip_tags($html);
?>
Chapter 3:
Controlling Program Flow
Using Numeric Functions
Don’t think that PHP’s power is limited to strings only: the language has over 50 built-in
functions for working with numbers, ranging from simple formatting functions to
functions for arithmetic, logarithmic, and trigonometric manipulations. Table 3-4 lists
some of these functions.
Doing Calculus
A common task when working with numbers involves rounding them up and down. PHP offers
the ceil() and floor() functions for this task, and they’re illustrated in the next listing:
There’s also the abs() function, which returns the absolute value of a number. Here’s
an example:
The pow() function returns the value of a number raised to the power of another:
The log() function calculates the natural or base-10 logarithm of a number, while the
exp() function calculates the exponent of a number. Here’s an example of both in action:
Generating Random Numbers
Generating random numbers with PHP is pretty simple too: the language’s built-in
rand() function automatically generates a random integer greater than 0. You can
constrain it to a specific number range by providing optional limits as arguments. The
following example illustrates:
Converting Between Number Bases
PHP comes with built-in functions for converting between binary, decimal, octal, and
hexadecimal bases. Here’s an example which demonstrates the bindec(), decbin(),
decoct(), dechex(), hexdec(), and octdec() functions in action:
Formatting Numbers
When it comes to formatting numbers, PHP offers the number_format() function, which
accepts four arguments: the number to be formatted, the number of decimal places to
display, the character to use instead of a decimal point, and the character to use to separate
grouped thousands (usually a comma). Consider the following example, which illustrates:
For more control over number formatting, PHP offers the printf() and sprintf()
functions. These functions, though very useful, can be intimidating to new users, and
so the best way to understand them is with an example. Consider the next listing, which
shows them in action:
Both functions accept two arguments, a series of format specifiers and the raw string or
number to be formatted. The input is then formatted according to the format specifiers and
the output either displayed with printf() or assigned to a variable with sprintf().
Some common format specifiers are listed in Table 3-5.
You can also combine these format specifiers with a precision specifier, which
indicates the number of digits to display for floating-point values—for example, %1.2f
implies that the number should be formatted as a floating-point value with two digits
displayed after the decimal point. For smaller numbers, it’s also possible to add a padding
specifier, which tells the function to pad the numbers to a specified length using a custom
character. You can see both these types of specifiers in action in the preceding listing.
Chapter 3:
Specifier
What It Means
%s
String
%d
Decimal number
%x
Hexadecimal number
%o
Octal number
%f
Floating-point number
Table 3-5
Controlling Program Flow
Format Specifiers for the printf() and sprintf() Functions
Try This 3-4
Processing a Member Registration Form
Now that you’ve seen some of PHP’s built-in functions, let’s apply some of what you’ve
learned to a practical application: a membership application form for a sports club. This
form will ask the applicant to enter various bits of personal information; it will then
validate this information and, if acceptable, will formulate and send an e-mail with the
applicant’s information to the club administrator.
Here’s the HTML form (register.html):
Project 3-4: Member Registration
Project 3-4: Member Registration
This form has five input fields, one each for the applicant’s name, address, age,
profession, and residential status. Figure 3-6 has a picture of what the form looks like.
Figure 3-6
A Web-based application form
Chapter 3:
Controlling Program Flow
NOTE
In order to successfully send mail with PHP using the mail() function, your php.ini
configuration file must include some information about the mail server or mail agent to
be used. Windows users will need to set the 'SMTP' and 'smtp_port' options, while
*NIX users may need to set the 'sendmail_path' option. More information on these
options can be obtained from the PHP manual page at www.php.net/mail.
Once the form is submitted, the data entered into it by the applicant is passed to the
form processing script (register.php) via the POST method. The next listing shows the
contents of this script:
Project 3-4: Member Registration
Project 3-4: Member Registration
60) {
die('ERROR: Membership is only open to those between 18 and 60 years.');
}
// check profession
if (empty($profession)) {
die('ERROR: Please provide your profession.');
}
(continued)
79
80
PHP: A Beginner’s Guide
// check residential status
if (strcmp($resident, 'no') == 0) {
die('ERROR: Membership is only open to residents.');
}
// if we get this far
// all the input has passed validation
// formulate and send e-mail message
$to = 'registration@some.domain.com';
$from = 'webmaster@some.domain.com';
$subject = 'Application for membership';
$body = "Name: $name\r\nAddress: $address\r\n
Age: $age\r\nProfession: $profession\r\n
Residential status: $resident\r\n";
if(mail($to, $subject, $body, "From: $from")) {
echo 'Thank you for your application.';
} else {
die('ERROR: Mail delivery error');
}
?>
NOTE
Remember to alter the value of the $to variable in the register.php script, to reflect your
e-mail address.
This script begins by retrieving the values submitted by the user from $_POST and
assigning these values to regular PHP variables. Next, the empty() function is used
to test whether they are empty; those which are, generate an error message and cause
the script to terminate immediately. Two extra conditional tests are also present in this
section: the first for the applicant’s age, to filter out applicants younger than 18 or older
than 60; and the second for the applicant’s residential status, to filter out non-residents.
Assuming all the checks are successful, the script proceeds to create an e-mail
message, setting variables for the sender, recipient, message subject, and message body.
These variables are then passed to PHP’s mail() function, which actually does the hard
work of sending the e-mail message. If message transmission is successful, a success
notification appears; if not, an error message is generated.
The mail() function is new to you and so deserves a more detailed examination. The
mail() function is a built-in PHP function to send an e-mail message, and it accepts four
parameters: the recipient e-mail address, the message subject, the message body, and a list
of additional message headers (of which the 'From' header is mandatory). It uses these
Chapter 3:
Controlling Program Flow
parameters to construct an e-mail message, connect to the specified mail server, and hand
the message over to delivery. If handover is successful, mail() returns true; otherwise, it
returns false.
CAUTION
It’s important to understand what the return value of the mail() function means. If the
mail() function returns true, it merely means is that the message was successfully handed
over to the mail server for delivery. It does not mean that the message was subsequently
successfully transmitted to, or received by, the intended recipient (because PHP has no
way of tracking the message once it’s been handed over to the mail server). Failing to
understand this distinction is a common error made by programmers new to PHP.
Also new in this script is the die() function: this function provides a convenient way
to immediately terminate script processing, usually if an error occurs. You can also pass
an optional message to die(); this message will be output by PHP at the point of script
termination and thus serves as a useful explanation to the user about what went wrong.
Ask the Expert
Q:
Can I add a custom header to e-mail messages sent through PHP?
A:
Yes. The fourth argument to the mail() function is a string containing your custom
header, in header:value format. If you have more than one custom header to add,
separate the headers with \r\n. The following example illustrates:
81
82
PHP: A Beginner’s Guide
Summary
The goal of this chapter was to move you along the learning curve, from building simple,
linear programs to creating more sophisticated PHP applications. It began by explaining
how you can add intelligence to your PHP scripts through the use of conditional tests, and
offered usage examples for PHP’s if, if-else, if-elseif-else, and switch-case
statements. It then proceeded to a discussion of PHP’s loop constructs, showing you how
easy it is to automate repetitive actions with PHP and introducing you to three common
loop types: the while, do-while, and for loops.
The latter half of the chapter took you on a whirlwind tour of PHP’s built-in
string and numeric functions, using commented examples to explain how to perform
tasks ranging from simple string comparison and extraction to more complex number
conversion and formatting. And as if all that wasn’t enough, this chapter helped you
work your way through four projects, each designed to demonstrate practical usage
of the concepts taught. Conditional statements, loops, and built-in functions all got a
workout in these projects, which ranged the gamut from a simple odd/even number
tester to a full-fledged Web application form that included input validation and e-mail
message transmission functions.
At the close of this chapter, you now know enough about PHP’s basic grammar and
syntax to begin writing your own, reasonably complex PHP scripts. The next chapter will
help expand your bag of PHP tricks, by introducing you to a new type of PHP variable
and also giving you some insight into PHP’s date and time manipulation functions. Until
then, though, spend some time looking at the links that follow, which offer more detailed
information on the topics discussed in this chapter:
●
Conditional statements and loops, at
www.php.net/manual/en/language.control-structures.php
●
A discussion of PHP string functions, at www.php.net/manual/en/ref.strings.php
and www.melonfire.com/community/columns/trog/article.php?id=88
●
PHP math functions, at www.php.net/manual/en/ref.math.php
●
Sending e-mail with PHP, at www.php.net/manual/en/ref.mail.php
●
PHP’s ternary operator, at www.php.net/manual/en/language.operators.php
Chapter 3:
✓
Controlling Program Flow
Chapter 3 Self Test
1. What is the difference between an if-else statement and an if-elseif-else
statement?
2. Write a conditional statement that checks the value of $city and displays a message if
it is equal to 'Minneapolis'.
3. Explain the difference between a while loop and a do-while loop. Illustrate your
answer with an example.
4. Using a while loop, write a program that prints a multiplication table for the
number 8.
5. Rewrite the program from Question 4 using a for loop.
6. Name the functions you would use to
A Decode HTML entities
B Uppercase a string
C Round a number down
D Remove whitespace from a string
E Generate a random number
F Reverse a string
G Count words in a string
H Count characters in a string
I Terminate script processing with a custom message
J Compare two strings
K Calculate the exponent of a number
L Convert a decimal number to a hexadecimal value
7. What will be the output of the following line of PHP code:
8. Given the string 'Mark had a nice day', create the new string 'Mark had
icecream'.
83
This page intentionally left blank
Chapter
4
Working with Arrays
85
Copyright © 2009 by The McGraw-Hill Companies. Click here for terms of use.
86
PHP: A Beginner’s Guide
Key Skills & Concepts
●
Understand the different array types supported by PHP
●
Process array contents with the foreach loop
●
Use arrays with Web forms
●
Sort, merge, add, modify, and split arrays using PHP’s built-in functions
●
Work with dates and times
B
y now, PHP’s simple data types should be old hat to you—you’ve spent the last few
chapters using them, in different permutations and combinations, to create applications
of varying complexity and usefulness. But there’s a lot more to PHP’s data types than
strings, numbers, and Booleans; PHP also supports arrays, which let you group and
manipulate more than one value at a time.
In this chapter, you’ll learn all about arrays: how to create them, how to add and edit
them, and how to manipulate the values they hold. You’ll also learn about a new loop type
designed specifically for use with arrays, get a crash course in some of PHP’s built-in
array functions, and apply your learning to some practical projects.
Storing Data in Arrays
So far, all the variables you’ve used have held only a single value. Array variables
are “special,” because they can hold more than one value at a time. This makes them
particularly useful for storing related values—for example, a set of fruit names, as in this
example:
Once you’ve got an array like this one, a natural question arises: how do you retrieve a
particular value? It’s quite simple: use index numbers to access the various values stored
inside it, with zero representing the first value. Thus, to access the value 'apple' from
Chapter 4:
Working with Arrays
the preceding array, you’d use the notation $fruits[0], while the value 'grape' can
be retrieved using the notation $fruits[3].
PHP also supports a slightly different type of array, in which index numbers are
replaced with user-defined strings, or “keys.” Here’s a revised version of the preceding
example, which uses keys instead of index numbers:
'apple',
'b' => 'banana',
'p' => 'pineapple',
'g' => 'grape'
);
?>
This type of array is known as an associative array. The keys of the array must be
unique; each key references a single value, and the key-value relationship is expressed
through the => symbol. To access the value 'apple' from the array, you’d use the
notation $fruits['a'], while the value 'banana' can be retrieved using the notation
$fruits['b'].
Assigning Array Values
PHP’s rules for naming array variables are the same as those for regular variables:
variable names must be preceded with a dollar ($) symbol and must begin with a letter
or underscore character, optionally followed by more letters, numbers, or underscore
characters. Punctuation characters and spaces are not allowed within array variable names.
Once you’ve decided a name for your array, there are two ways of assigning values
to it. The first is the method you saw in the preceding section, where the values are all
assigned at once, separated with commas. This method creates a standard, numberindexed array. Here’s an example:
87
88
PHP: A Beginner’s Guide
The second way to create such an array is to set values individually using index notation.
Here’s an example, which is equivalent to the preceding one:
Ask the Expert
Q:
In all these examples, you’ve explicitly specified the array index for each assignment
statement. What if I don’t know what the correct index is? Can I make PHP
automatically assign the next available array index to my value?
A:
To automatically assign the next available index to an array value, omit the index number
in your array assignment statement, as you see here:
You can also use both these techniques with associative arrays. To assign all the values
of such an array in a single statement, set a key for each value and link the two using
the => connector, remembering to separate each key-value pair with commas. Here’s an
example:
'john',
'password' => 'secret',
'host' => '192.168.0.1'
);
?>
Chapter 4:
Working with Arrays
You can also assign values to keys one by one, as in this next example:
To access a value from an array in a script, simply use the array name and index/key
in an expression and PHP will replace it with its value when the script is executed, as with
any normal variable. Here’s a simple example that illustrates how this works:
'john',
'password' => 'secret',
'host' => '192.168.0.1'
);
// use array value
echo 'The password is: ' . $data['password'];
?>
NOTE
Do you remember the special container variables named $_GET and $_POST that you
first encountered in Chapter 2? Well, they’re arrays too! When a form is submitted,
each element of the form is automatically converted by PHP into a member of either the
$_POST or $_GET array (depending on the method of submission).
Modifying Array Values
Modifying an array value is as simple as modifying any other variable value: simply
assign a new value to the element using either its index or its key. Consider the following
example, which modifies the second element of the $meats array to hold the value
'turkey' instead of 'ham':
To remove an element from an array, use the unset() function on the corresponding
key or index:
Ask the Expert
Q:
If I remove an element from the middle of an array, what happens to the values on
either side?
A:
If you remove an element from an array with unset(), PHP will set that array element to
NULL but will not automatically re-index the array. If the array is a numerically indexed
array, you can re-index it to remove these “holes” in the indexing sequence, by passing the
array through PHP’s array_multisort() function.
You can also remove an element from an array using the array_pop() or array_
push() function; these functions are discussed a little further along in this chapter.
Retrieving Array Size
An important task when using arrays, especially in combination with loops, is finding out
how many values the array contains. This is easily accomplished with PHP’s count()
function, which accepts the array variable as a parameter and returns an integer value
indicating how many elements it contains. Here’s an example:
TIP
Instead of the count() function, you can also use the sizeof() function, which
does the same thing.
Ask the Expert
Q:
A:
Is there an upper limit on how many elements a PHP array can hold?
No. The number of elements in an array is limited only by available memory, as defined in
the 'memory_limit' configuration variable in PHP’s configuration file.
Nesting Arrays
PHP also allows you to combine arrays, by placing one inside another to an unlimited
depth. This can come in handy when dealing with structured, hierarchically arranged
information. To illustrate, consider the following example:
'Raymond Rabbit',
'tel' => '1234567',
'email' => 'ray@bunnyplanet.in',
),
array(
'name' => 'David Duck',
'tel' => '8562904',
'email' => 'dduck@duckpond.corp',
),
array(
'name' => 'Harold Horse',
'tel' => '5942033',
'email' => 'kingharold@farmersmarket.horsestuff.com',
)
);
?>
91
92
PHP: A Beginner’s Guide
In this example, $phonebook is an array nested two levels deep. The first level is
numerically indexed, with each element representing an entry from a phone book. Each of
these elements is itself an associative array, holding specific information on the attributes
of the corresponding phone book entry, such as the contact’s name, phone number, and
e-mail address.
To access a value a few levels deep in a nested array, use the correct hierarchical
sequence of indices/keys to get to the value. Here’s an example, which returns the phone
number of the contact 'David Duck':
'Raymond Rabbit',
'tel' => '1234567',
'email' => 'ray@bunnyplanet.in',
),
array(
'name' => 'David Duck',
'tel' => '8562904',
'email' => 'dduck@duckpond.corp',
),
array(
'name' => 'Harold Horse',
'tel' => '5942033',
'email' => 'kingharold@farmersmarket.horsestuff.com',
)
);
// access nested value
echo "David Duck's number is: " . $phonebook[1]['tel'];
?>
TIP
Want to look inside an array and see what it contains? The var_dump() and
print_r() functions discussed in Chapter 2 work just as well on arrays as on other
variables. Try them out for yourself and see!
Processing Arrays with Loops and Iterators
Often, your PHP program will need to work its way through an array, performing an
operation or calculation on each value it finds. The best way to do this is with a loop,
Chapter 4:
Working with Arrays
which you learned about in the preceding chapter. Consider the following example, which
sets up an array and then iterates over it using a for loop:
In this listing, a for loop iterates over the $cities array, printing each value found. The
loop runs as many times as there are elements in the array; this information is quickly
ascertained by a call to the count() function.
The foreach Loop
You might remember that the preceding chapter’s discussion of loops was left unfinished,
with one loop type still left to be explained. That loop, the foreach loop, was first
introduced in PHP 4.0 and is the simplest way of iterating over arrays—not surprising, as
that’s what it was specifically designed for!
With a foreach loop, each time the loop runs, the current array element is assigned to
a temporary variable, which can then be processed in any way you please—printed, copied
to another variable, used in a calculation, and so on. Unlike a for loop, a foreach loop
doesn’t use a counter; it automatically “knows” where it is in the array, and it moves forward
continuously until it reaches the end of the array, at which point it automatically halts.
The best way to understand this marvel of automation is with an example. The next
listing shows it in action, rewriting the preceding listing to use a foreach loop instead of
a for loop:
93
94
PHP: A Beginner’s Guide
The foreach loop also works with associative arrays, except that for such arrays, it
uses two temporary variables (one each for the key and value). The next listing illustrates
the difference:
"London",
"United States" => "Washington",
"France" => "Paris",
"India" => "Delhi"
);
// iterate over array
// print each value
foreach ($cities as $key => $value) {
echo "$value is in $key. \r\n";
}
?>
The Array Iterator
Alternatively, you may prefer to use an ArrayIterator (new in PHP 5.0), which provides a
ready-made, extensible tool to loop over array elements. Here’s a simple example:
"London",
"United States" => "Washington",
"France" => "Paris",
"India" => "Delhi"
);
// create an ArrayIterator object
$iterator = new ArrayIterator($cities);
// rewind to beginning of array
$iterator->rewind();
// iterate over array
// print each value
while($iterator->valid()) {
print $iterator->current() . " is in " . $iterator->key() . ". \r\n";
$iterator->next();
}
?>
In this listing, an ArrayIterator object is initialized with an array variable, and the
object’s rewind() method is used to reset the internal array pointer to the first element
Chapter 4:
Working with Arrays
of the array. A while loop, which runs so long as a valid() element exists, can then be
used to iterate over the array. Individual array keys are retrieved with the key() method,
and their corresponding values are retrieved with the current() method. The next()
method moves the internal array pointer forward to the next array element.
NOTE
Don’t worry if the syntax used by the ArrayIterator object isn’t completely clear to you.
Objects are dealt with in some depth in Chapter 5, and the preceding listing will make
more sense once you’ve worked your way through that chapter.
Try This 4-1
Averaging the Grades of a Class
Now that you’ve understood the basics of working with arrays, let’s try a small application
that demonstrates their practical utility. In this section, you’ll write a small script that
accepts an array of values, representing the numerical grades of individual students in
a class, and then calculates various summary statistics, including the average and the
number of students in the top and bottom 20 percent of the class.
Here’s the code (grades.php):
Project 4-1: Grade Averaging
Project 4-1: Grade Averaging
= 80) {
$top++;
}
}
// calculate average
$avg = round($total / $count);
// print statistics
echo "Class average: $avg element, which is named artists[].
This tells PHP that, when the form is submitted, all the selected values from the list should be
converted into elements of an array. The name of the array will be $_POST['artists'],
and it will look something like this:
Array
(
[0] => Britney Spears
[1] => Black-Eyed Peas
[2] => Diana Ross
)
Try This 4-2
Selecting Pizza Toppings
A practical application will make it easier to understand how PHP interacts with array
variables and forms. This next application presents the user with a form containing various
pizza toppings and asks the user to select, via checkbox, his or her favorite toppings.
Here’s the form (pizza.html):
(continued)
97
98
PHP: A Beginner’s Guide
Project 4-2: Pizza Topping Selector
Project 4-2: Pizza Topping Selector
Figure 4-2 illustrates what the form looks like.
And here’s the code for the form submission script (pizza.php):
Project 4-2: Pizza Topping Selector
Project 4-2: Pizza Topping Selector
You selected the following toppings: Project 4-3: Prime Number Tester
Project 4-3: Prime Number Tester
(continued)
107
108
PHP: A Beginner’s Guide
0) {
$primes = array_unique($primes);
sort($primes);
echo 'The following numbers are prime: ' . implode($primes, ' ');
} else {
echo 'No prime numbers found';
}
}
?>
Using a technique that should now be familiar to you, this application also combines
the Web form and its result page into a single script, separated by an if-else conditional
statement. The Web form allows the user to enter a series of numbers, separated by
commas. Figure 4-4 illustrates what the form looks like.
Once a user enters some numbers into the Web form and submits it, the second half
of the script is triggered. It should be clear that this part of the script uses many of the
array functions discussed in the preceding section. First, the explode() function takes
care of extracting the individual numbers from the user’s submission into an array, using
Figure 4-4
A Web form to enter numbers
(continued)
109
110
PHP: A Beginner’s Guide
Figure 4-5
The result of the form submission, displaying the prime numbers found
the comma as separator. Next, a foreach loop iterates over the array, first calculating
the absolute value of each number and then dividing that number by all other numbers
between itself and 2 to determine whether or not it is prime.
Assuming the number is not perfectly divisible by at least one other number, the
number is considered prime, and the array_push() function is used to add it to a new
array named $primes. Once all the numbers submitted by the user are processed in this
manner, the count() function is used to check if any primes were found; if yes, the
$primes array is checked for duplicate values, sorted from lowest to highest value, and
sent to the page as output.
Figure 4-5 shows the output after submitting the sequence.
Working with Dates and Times
In addition to allowing you to store multiple values in an array, PHP also comes with a
full-featured set of functions for working with dates and times. Although the language
does not have a dedicated data type for date and time values, it nevertheless allows
programmers a great deal of flexibility when creating, formatting, and manipulating
such values.
Chapter 4:
Working with Arrays
Ask the Expert
Q:
A:
What’s a UNIX timestamp?
Very simply, a UNIX timestamp for a particular time point represents the number of
seconds that have elapsed between midnight on January 1, 1970, and that time point. So,
for example, the time point January 5 2008 10:15:00 AM in UNIX timestamp format
would be 1199508300.
PHP can automatically turn a date value into a UNIX timestamp with its mktime()
function, which accepts day, month, year, hour, minute, and second arguments and
returns a UNIX timestamp corresponding to that instant in time.
Generating Dates and Times
Like many other programming languages, PHP represents date/time values in UNIX
timestamp format. Generating a timestamp is usually accomplished with the mktime()
function, which accepts a series of date and time parameters and converts them into
a timestamp. To illustrate, consider the following example, which returns a UNIX
timestamp corresponding to January 5 2008 10:15:00 AM:
Calling mktime() without any arguments returns the UNIX timestamp corresponding
to the present time:
Another way to get the current date and time is with PHP’s getdate() function,
which returns an associative array containing information about the current date and time.
Here’s an example of what this array looks like:
Array
(
[seconds] => 33
[minutes] => 27
111
112
PHP: A Beginner’s Guide
[hours] => 19
[mday] => 12
[wday] => 1
[mon] => 11
[year] => 2007
[yday] => 315
[weekday] => Monday
[month] => November
[0] => 1194875853
)
And here’s an example of this function in action:
TIP
Notice that the array returned by getdate() includes a UNIX timestamp representation
of the date, at index position 0.
Formatting Dates and Times
In most cases, generating a timestamp is only half the battle: you also need to find a
way to display it in human-readable form. That’s where PHP’s date() function comes
in: it allows you to massage that long, ugly timestamp into something that’s much more
informative. This function accepts two arguments: a formatting string and a timestamp.
The formatting string is a sequence of characters, each of which has a special meaning;
Table 4-2 has a list of the most commonly used ones.
Using the special characters from Table 4-2, it’s possible to format a UNIX timestamp
with date() to customize the display of a date/time value. Here are some examples:
Useful Date and Time Functions
PHP also supports many other date/time manipulation functions, which allow you to check
if a date is valid or convert between time zones. Table 4-3 lists some of these functions.
Function
What It Does
checkdate()
Checks a date for validity
strtotime()
Creates timestamps from English-language descriptions
gmdate()
Expresses a timestamp in GMT
Table 4-3
Common PHP Date Functions
113
114
PHP: A Beginner’s Guide
Checking Date Validity
A useful built-in function is the checkdate() function, which accepts a month, day,
and year combination and returns a true/false value indicating whether the corresponding
date is valid. Consider the following example, which illustrates it by testing the date
30 February 2008:
Converting Strings to Timestamps
Another very useful function is PHP’s strtotime() function, which accepts a string
value containing an embedded date or time and converts this into a UNIX timestamp.
Here’s an example:
Interestingly, strtotime() also recognizes common time descriptions such as
"now", "3 hours ago", "tomorrow", or "next Friday". The following listing
illustrates this very useful feature:
Mapping Day and Month Numbers to Names
The date() function discussed in the preceding section isn’t useful only for formatting
timestamps into readable date strings; it can also be used to find the weekday name
corresponding to a particular date. To do this, simply use the 'D' format character with
your timestamp . . . as in the following example, which displays the day that Oct 5 2008
falls on:
You can also do this for month names, by using the date() function’s 'F' parameter:
Calculating GMT Time
PHP’s gmdate() function works exactly like its date() function, except that it returns
GMT representations of formatted date strings, instead of local time representations. To
see this in action, consider the following examples, which return GMT equivalents for two
local times:
115
116
PHP: A Beginner’s Guide
Try This 4-4
Building an Age Calculator
Now that you know a little bit about how PHP deals with dates and times, let’s put all this
learning to good use with a practical project: a Web application that lets you enter your
date of birth and calculates how old you are today, in years and months.
Here’s the code (agecalc.php):
Project 4-4: Age Calculator
Project 4-4: Age Calculator
= $now) {
die('ERROR: Please enter a date of birth earlier than today');
}
// calculate difference between date of birth and today in days
// convert to years
// convert remaining days to months
// print output
$ageDays = floor(($now - $dateTs) / 86400);
$ageYears = floor($ageDays / 365);
$ageMonths = floor(($ageDays - ($ageYears * 365)) / 30);
echo "You are approximately $ageYears years and $ageMonths months old.";
}
?>
Once a user submits his or her date of birth into the Web form (Figure 4-6) in
MM/DD/YYYY format, the second half of the script is triggered. The first bit of this section
of the program is concerned mostly with error checks. First, the date entered into the form
is split into its constituent values of month, day, and year, and the checkdate() function
is used to verify whether or not it is valid. Following this, the strtotime() function is
used to convert the entered date into a UNIX timestamp; this is then compared with “today”
to verify that the date entered is in the past.
Figure 4-6
A Web form for the user to enter his or her date of birth
(continued)
117
118
PHP: A Beginner’s Guide
Figure 4-7
The result of the form submission, showing the calculated age
Assuming the date entered into the form passes these error checks, the script proceeds
to the calculation stage. First, “today’s” timestamp is subtracted from the birth timestamp;
as both timestamps are expressed in seconds, the result of this calculation returns the
user’s age, in seconds. This value is then divided by 86400—the number of seconds
in a day—to return the user’s age in days. Dividing the number of days by 365 returns
the user’s age in years. Finally, the fractional part of the age (months) is calculated by
dividing the remaining days by 30.
Figure 4-7 shows the output after a form submission.
Summary
This chapter introduced you to a new type of PHP variable, the array, which allows you to
group multiple related values together and operate on them as a single entity. In addition
to showing you how to create, edit, and process arrays, it also demonstrated some of
PHP’s array manipulation functions, showed you how you can use arrays in the context
of Web forms, and put arrays to practical use through three simple applications. Finally, it
explained how to work with temporal data in PHP, illustrating the most commonly used
date and time functions and using them to build a simple age calculator.
Chapter 4:
Working with Arrays
Arrays are an important addition to your PHP toolkit, and as your scripts become more
sophisticated, you’ll begin to appreciate how powerful and flexible they really are. To find
out more about them, consider visiting the following links:
✓
●
Arrays, at www.php.net/manual/en/language.types.array.php
●
Array operators, at www.php.net/manual/en/language.operators.array.php
●
Array manipulation functions, at www.php.net/manual/en/ref.array.php
●
The special $_POST and $_GET arrays, at
www.php.net/manual/en/reserved.variables.php#reserved.variables.get
●
Date and time functions, at www.php.net/manual/en/ref.datetime.php
Chapter 4 Self Test
1. What are the two types of PHP arrays, and how do they differ?
2. Name the functions you would use to
A Remove duplicate elements from an array
B Add an element to the beginning of an array
C Sort an array in reverse
D Count the number of elements in an array
E Search for a value in an array
F Display the contents of an array
G Shuffle the contents of an array
H Combine two arrays into one
I Find the common elements between two arrays
J Convert a string to an array
K Extract a segment of an array
3. What will be the output of the following line of PHP code:
119
120
PHP: A Beginner’s Guide
4. Using only an array and a foreach loop, write a program that prints the days of
the week.
5. Write a program that reads an array of numbers and returns a list of all those numbers
less than 15.
6. Write a program that reads an array and returns a message indicating whether the array
contains only unique values.
Chapter
5
Using Functions
and Classes
121
Copyright © 2009 by The McGraw-Hill Companies. Click here for terms of use.
122
PHP: A Beginner’s Guide
Key Skills & Concepts
●
Learn the benefits of encapsulating code into functions and classes
●
Define and use your own functions, arguments, and return values
●
Understand local and global variables
●
Learn about recursion and variable-length argument lists
●
Define and use your own classes, methods, and properties
●
Understand OOP concepts of visibility, extensibility, and reflection
A
s your PHP programs get more complex, you might find yourself repeatedly writing
code to perform the same task—for example, testing a number for prime-ness or
checking a form field to see if it’s empty or not. In these situations, it usually makes
sense to turn this code into a reusable component, which can be managed independently
and “called upon” as needed from different PHP programs. Not only does this reduce the
amount of duplicate code you have to write, but it also makes your scripts leaner, more
efficient, and easier to maintain.
PHP offers two constructs to help you reduce code duplication in your programs:
user-defined functions are reusable code segments that are created by the programmer to
perform specific tasks, while classes provide a more formal, object-oriented approach to
reusability and encapsulation. This chapter will introduce you to both these constructs,
using practical examples to illustrate their real-world utility.
Creating User-Defined Functions
In previous chapters, you’ve been introduced to many of PHP built-in functions for string,
number, and array manipulation. However, PHP doesn’t only restrict you to its built-in
functions; it also lets you define your own. These user-defined functions are a neat way for
you to create independent, reusable code “packages” that perform specific tasks and can
be maintained independently of the main program.
Chapter 5:
Using Functions and Classes
Packaging your code into functions has four important advantages:
●
It reduces duplication within a program, by allowing you to extract commonly used
routines into a single component. This has the added benefit of making programs
smaller, more efficient, and easier to read.
●
A function is created once but used many times, often from more than one program.
If the function code changes, the changes are implemented in one spot (the
function definition) while the function invocations remain untouched. This fact can
significantly simplify code maintenance and upgrades, especially when contrasted
with the alternative: manually changing every occurrence of the earlier code wherever
it occurs (and possibly introducing new errors in the process).
●
Debugging and testing a program becomes easier when the program is subdivided
into functions, as it becomes easier to trace the source of an error and correct it with
minimal impact on the rest of the program.
●
Functions encourage abstract thinking, because packaging program code into a
function is nothing more or less than understanding how a specific task may be
encapsulated into a generic component. In this sense, functions encourage the creation
of more robust and extensible software designs.
Creating and Invoking Functions
There are three components to every function:
●
Arguments, which serve as inputs to the function
●
Return values, which are the outputs returned by the function
●
The function body, which contains the processing code to turn inputs into outputs
To begin with, let’s start with a simple example, one that doesn’t use either arguments
or return values. Consider the following PHP script, which contains a user-defined
function to print the current day of the week:
123
124
PHP: A Beginner’s Guide
Function definitions begin with the function keyword, followed by the function
name and a list of arguments (optional) in parentheses. Curly braces then enclose the
main body of the function, which can contain any legal PHP code, including variable
definitions, conditional tests, loops, and output statements. Function names must begin
with a letter or underscore character, optionally followed by more letters, numbers, or
underscore characters; punctuation characters and spaces are not allowed within function
names. In the preceding listing, the function is named whatIsToday() and its body
contains a single statement, which uses echo and date() to obtain and print the current
weekday name.
Of course, defining a function is only half the battle: the other half is using it. In PHP,
invoking a function is as simple as calling it by name (and passing it optional arguments,
if needed). The main body of the script in the preceding listing does just this: it invokes
the function by name and then stands back to see the results.
Ask the Expert
Q:
A:
Can I invoke a function before it’s been defined?
Yes. PHP 4.0 (and better) allow developers to invoke a function even if the corresponding
function definition appears later on in the program. This feature is particularly useful for
developers who prefer to place their function definitions at the bottom of a PHP script,
rather than the top, for easier readability.
Using Arguments and Return Values
A function that always returns the same output is a lot like a radio station that plays the
same song all day—not very useful or interesting at all! What you’d really like is the
ability to change the music the station plays in response to feedback that you, the listener,
provide—in effect, to create an audience request show. In PHP terms, this amounts to
creating functions that can accept input values at run time and use these input values to
affect the output returned by the function.
That’s where arguments come in. Arguments are “placeholder” variables within a
function definition; they’re replaced at run time by values provided to the function from
the main program. The processing code within the function then manipulates these values
to return the desired result. Since the input to the function will differ each time it is
invoked, the output will necessarily differ too.
Chapter 5:
Using Functions and Classes
To illustrate, consider the following listing, which defines a function accepting two
arguments and uses these arguments to perform a geometric calculation:
The function in this listing performed a calculation and then printed the result directly
to the output page. But what if you want the function to perform its work and, instead
of printing the result, do something else with it? Well, in PHP, you can have a function
explicitly return a value, like the result of a calculation, to the statement that called it. This
is accomplished by using a return statement inside the function, as in the next example:
You can return multiple values from a function, by placing them all in an array and
returning the array. The next example illustrates, by accepting a sentence and returning the
individual words, reversed, to the caller as an array:
$v) {
$words[$k] = strrev($v);
}
return $words;
}
// function invocation
// output: 'evaH a doog yad'
echo implode(' ', reverseMe('Have a good day'));
// function invocation
// output: 'lliW uoy yrram em'
echo implode(' ', reverseMe('Will you marry me'));
?>
NOTE
When PHP encounters a return statement inside a function, it halts processing of the
function and “returns” control to the main body of the program.
Setting Default Argument Values
As you saw earlier, the arguments that a function expects to receive from the main
program are specified in the function’s argument list. For convenience, you can assign
default values to any or all of these arguments; these default values are used in the event
the function invocation is missing some arguments. Here’s an example, which generates
an e-mail address from supplied username and domain arguments; if the domain argument
is missing, a default domain is automatically assigned:
Notice that in the first instance, the function has been called with only a single
argument, even though the function definition requires two. However, since a default
value is present for the second argument, the missing argument is automatically replaced
by said default value, and no errors are generated.
TIP
If only some of your function’s arguments have default values assigned to them, place
these arguments at the end of the function’s argument list. This lets PHP correctly
differentiate between missing arguments that don’t have default values, and missing
arguments that do.
Using Dynamic Argument Lists
A PHP function definition normally has a fixed argument list, where the number of
arguments is known in advance. However, PHP also lets you define functions with
so-called variable-length argument lists, where the number of arguments can change
with each invocation of the function. A good example of this is a function that accepts an
arbitrary number of arguments, adds them up, and returns the average . . . as illustrated in
the following listing:
127
128
PHP: A Beginner’s Guide
Notice that the calcAverage() function definition in the previous listing does not
include a predefined argument list; rather, the arguments passed to it are retrieved at run
time using the func_num_args() and func_get_args() functions. The func_num_
args() function returns the number of arguments passed to a function, while the func_
get_args() function returns the actual argument values, as an array. As illustrated in
the preceding listing, both functions come in very handy when dealing with functions that
accept an arbitrary number of arguments.
Understanding Variable Scope
A key concept related to user-defined functions in PHP is variable scope: the extent of a
variable’s visibility within the space of a PHP program. By default, variables used within
a function are local—their impact is restricted to the function space alone, and they cannot
be viewed or manipulated from outside the function in which they exist. To illustrate this,
consider the following example:
// output: 11
Here, the variable $score is defined in the main program, and the changeScore()
function contains code to change the value of this variable. However, after running this
function, the value of $score remains at its original setting, because the changes made to
$score within the changeScore() function remain “local” to the function and do not
reflect in the main program.
This “bounding” of variables to within a function space is deliberate: it maintains
a degree of separation between the main program and its functions, and it reduces
Chapter 5:
Using Functions and Classes
the chances of variables from the main program affecting variables within a function.
However, there are certainly occasions when it may be necessary to “import” a variable
from the main program into a function, or vice versa. For these situations, PHP offers
the global keyword: when applied to a variable inside a function, this keyword
turns the variable into a global variable, making it visible both inside and outside
the function.
The next example illustrates the difference between global and local scope more
clearly:
// output: 25
In this revision of the previous listing, the global keyword used with the $score
variable within the changeScore() function changes the scope of the variable,
increasing its scope to encompass the entire program. As a result, changes made to the
variable within the function will reflect in the main program (and vice versa). The output
of the script illustrates this fact clearly.
Using Recursive Functions
Another, slightly more complex idea involving functions is recursion. A recursive function
is a function that calls itself repeatedly until a condition is satisfied. Such a function
is typically used to solve complex, iterative calculations, or to process deeply nested
structures.
129
130
PHP: A Beginner’s Guide
To illustrate how a recursive function works, consider the next example, which writes
a recursive function to drill down into a nested array and print all of its contents:
$count, 'values' => $out);
}
// define nested array
$data = array(
'o' => array(
'orange',
'owl',
'one'),
't' => array(
Chapter 5:
Using Functions and Classes
'tea',
'ten',
'tag',
'twentythree' => array(
array('twenty', 'three'),
array('vingt', 'trois', array(
'red' => 'baron',
'blue' => 'blood'
))
)
)
);
// count and print values in nested array
$ret = printValues($data);
echo $ret['total'] . ' value(s) found: ';
echo implode(', ', $ret['values']);
?>
The output of this example would be
12 value(s) found: orange, owl, one, tea, ten,
tag, twenty, three, vingt, trois, baron, blood
The core of this example is the printValues() function, which accepts an array
as argument. It then loops through this array using a foreach loop, adding each value
it finds to an output array named $out. For each such value found, it also increments
a counter named $count by 1. In the event that any of the values encountered in this
manner is itself an array, printValues() calls itself recursively to process that child
array (and any other child arrays found at deeper nesting levels). This process continues
until no further values are left to be processed.
Because both $out and $count are global variables, they maintain their values
throughout this process. Once the function has completed its work, these two variables are
packaged into a single associative array, which is returned to the caller and printed to the
output page.
TIP
While recursive functions are often the quickest way to solve a complex calculation,
they’re not the only way: in most cases, you can accomplish the same thing, albeit less
elegantly, by using one or more loops.
131
132
PHP: A Beginner’s Guide
Try This 5-1
Calculating GCF and LCM
Now that you’ve imbibed a fair amount of knowledge about PHP’s user-defined functions,
let’s put that knowledge to the test with a small practical application. This next example
invites the user to enter two numbers into a Web form, and calculates the greatest common
factor (GCF) and least common multiple (LCM) of the entered numbers.
NOTE
In case you skipped Math class, the GCF of two numbers is the largest factor common to
both, while the LCM of two numbers is the smallest multiple common to both. Thus, for
example, the GCF of 6 and 10 is 2, while the LCM is 30. Read more about GCF and
LCM, including a detailed description of the Euclidean algorithm used in this example,
at http://en.wikipedia.org/wiki/Greatest_common_factor and http://en.wikipedia.org/
wiki/Least_common_multiple.
Here’s the code (gcf_lcm.php):
Project 5-1: GCF and LCM
Project 5-1: GCF and LCM
";
echo "The GCF of ($num1, $num2) is: " . getGCF($num1, $num2);
echo "getKey() + ($x * $this->getKey());
}
return implode('/', $cipher);
}
// decrypt
public function decrypt($cipher) {
$data = explode('/', $cipher);
$plain = '';
for ($x=0; $xgetKey() - ($x * $this->getKey()));
}
return $plain;
}
}
?>
(continued)
139
140
PHP: A Beginner’s Guide
This class has a single property and four methods:
●
The $key property holds the numeric key entered by the user. This key is used to
perform the encryption.
●
The setKey() method accepts an argument and sets the $key property to that value.
●
The getKey() method returns the value of the $key property.
●
The encrypt() function accepts a plain-text string and “jumbles” it using the key.
●
The decrypt() function accepts an encrypted string and restores the original plaintext string from it using the key.
A quick word about the internals of the encrypt() and decrypt() methods, before
proceeding to a usage example. When encrypt() is invoked with a plain-text string, it
steps through the string and calculates a numeric value for each character. The numeric
value is the sum of
●
The character’s ASCII code, as returned by the ord() function
●
The numeric key set by the user through the setKey() method
●
The product of the numeric key and the character’s position in the string
Each number returned after this calculation is added to an array, and once the entire
string is processed, the elements of the array are joined into a single string, separated by
slashes, with implode().
Table 5-1 has a brief illustration of how the word 'Ant' is converted into the
encrypted string '410/800/1151' using this method.
The decryption routine reverses this process: it first splits the encrypted ciphertext
string into individual numbers using the slashes as delimiters, and adds them to an array.
It then obtains the character corresponding to each number, by subtracting
●
The numeric key set by the user through the setKey() method; and
●
The product of the numeric key and the character’s position in the string
Character $c
Position $p
'A'
0
65
345
0
410
'n'
1
110
345
345
800
't'
2
116
345
690
1151
Table 5-1
ord($c)
An Example Encryption Run
Key $key
$key * $p
Total
Chapter 5:
Using Functions and Classes
from the number, and then using the chr() function to retrieve the ASCII character
corresponding to the remainder. The characters returned through this process are
concatenated into a single string and returned to the caller.
CAUTION
The encryption routine used by the Jumbler class is illustrative only, and highly
insecure—don’t even think about using it to secure real-world data.
Now that you’ve understood how the class works, let’s look at how it could be used. This
next listing generates a form for the user to enter plaintext or ciphertext, as well as a numeric
key, and then uses a Jumbler object to encrypt or decrypt it. Here’s the code (jumbler.php):
Project 5-2: Encrypting Text
Project 5-2: Encrypting Text
setKey($key);
if ($type == 'C') {
echo $j->decrypt($text);
} else {
echo $j->encrypt($text);
}
}
?>
The script is quite simple: it generates a Web form containing text fields for the user to
enter text and a numeric key, and radio buttons to indicate whether the text being entered
is plaintext or ciphertext. On submission, a new instance of the Jumbler class is created,
and the key entered by the user is registered with the instance via the setKey() method.
Depending on the type of text entered, the instance’s encrypt() or decrypt() method
is called, and the output is printed back to the page.
Figure 5-4 shows what the Web form looks like, and Figure 5-5 has an example of the
encrypted text generated after form submission.
Figure 5-4
A Web form to enter plaintext
Chapter 5:
Figure 5-5
Using Functions and Classes
The result after encryption
Using Advanced OOP Concepts
PHP’s object model also supports many more advanced features, giving developers a great
deal of power and flexibility in building OOP-driven applications. This section illustrates
three such features: constructors and destructors, extensibility, and visibility.
Using Constructors and Destructors
PHP makes it possible to automatically execute code when a new instance of a class is
created, using a special class method called a constructor. You can also run code when
a class instance ends using a so-called destructor. Constructors and destructors can be
implemented by defining functions named __construct() and __destruct() within
the class, and placing object (de)initialization code within them.
Here’s a simple example illustrating how this works:
Extending Classes
For most developers, extensibility is the most powerful reason for using the OOP
paradigm. Put very simply, extensibility implies that a new class can be derived from an
existing one, inheriting all the properties and methods of the parent class and adding its
own new properties and methods as needed. Thus, for example, a Human class could
extend a Mammal class, which is itself an extension of a Vertebrate class, with each new
extension adding its own features as well as inheriting the features of its parent.
In PHP, extending a class is as simple as attaching the extends keyword and the
name of the class being extended to a class definition, as in the following example:
With such an extension, all the properties and methods of the parent class become
available to the child class and can be used within the class’ program logic. To illustrate,
consider the following listing:
age = $age;
}
function getAge() {
return $this->age;
}
function grow() {
$this->age += 4;
}
}
// child class definition
class Human extends Mammal {
public $name;
function __construct() {
parent::__construct();
}
function setName($name) {
$this->name = $name;
}
function getName() {
return $this->name;
}
function grow() {
$this->age += 1;
echo 'Growing...';
}
}
?>
This listing contains two class definitions:
1. Mammal, the parent class, which contains the $age property and the methods
setAge(), getAge(), and grow();
145
146
PHP: A Beginner’s Guide
2. Human, which extends Mammal and inherits all of Mammal’s properties and
methods. Human contains the additional $name property and the additional methods
setName() and getName(); its grow() method overrides the method of the same
name in the parent class. Notice also that Human’s __construct() method internally
calls Mammal’s __construct() method; the special keyword parent provides an
easy shortcut to refer to the current class’ parent.
Here’s an example of how you’d use the extended class:
setAge(1);
$baby->setName('Tonka');
echo $baby->getName() . ' is now ' . $baby->getAge() . ' year(s) old...';
$baby->grow();
$baby->grow();
echo $baby->getName() . ' is now ' . $baby->getAge() . ' year(s) old.';
?>
Figure 5-6 shows the output of this listing.
From the output, it should be clear that even though the class definition for Human
doesn’t explicitly contain getAge() and setAge() methods, nor the $age property,
Figure 5-6
Using inherited methods of a class
Chapter 5:
Using Functions and Classes
instances of the Human class can still use these methods, as they are inherited from the
parent Mammal class.
Once you begin working with inheritance and extensibility, it’s easy to quickly
become overwhelmed with long and complex class trees. For this reason, PHP provides an
instanceof operator, to test if an object is an instance of a particular class. This operator
returns true if the object instance has the named class anywhere in its parent tree. Here’s
an example of it in action:
TIP
There’s also the get_class() function, which returns the name of the class from which
an object was instantiated, and the get_parent_class() function, which returns the
name of its parent.
Adjusting Visibility Settings
In the first part of this chapter, you learned the difference between “local” and “global”
scope, and you saw how variables used inside a function are invisible to the main
program. When working with classes, PHP allows you to exert even greater control over
the visibility of object properties and methods. Three levels of visibility exist, ranging
from most visible to least visible; these correspond to the public, protected, and
private keywords.
You’ll have noticed that all the property and method definitions in earlier examples
are prefixed with the keyword public; this sets the corresponding class methods and
properties to be “public” and allows a caller to manipulate them directly from the main
body of the program. This “public” visibility is the default level of visibility for any class
member (method or property) under PHP.
147
148
PHP: A Beginner’s Guide
If you don’t like the thought of this intrusion, you can explicitly mark a particular
property or method as private or protected, depending on how much control you
want to cede over the object’s internals. “Private” methods and properties are only visible
within the class that defines them, while “protected” methods and properties are visible
to both their defining class and any child (inherited) classes. Attempts to access these
properties or methods outside their visible area typically produces a fatal error that stops
script execution.
To see how this works in practice, consider the following example:
name = 'William';
$mammal->age = 3;
$mammal->species = 'Whale';
$human = new Human;
$human->name = 'Barry';
$human->age = 1;
$human->species = 'Boy';
?>
Try This 5-3
// ok
// fatal error
// fatal error
// ok
// fatal error
// undefined
Generating Form Selection Lists
Let’s now turn to another example to illustrate some of the more advanced concepts
taught in the preceding section. Here, you’ll create objects to mimic the and
elements used in a Web form, writing methods that allow you to define such
a selection list programmatically from your application. There are three primary objects
you’ll encounter in the next example: a base Element object and two derived objects
named Select and Option.
Let’s start with the base Element object, which represents a generic form element:
name = $name;
}
// method: get element 'name'
public function getName() {
return $this->name;
}
// method: set element value
public function setValue($value) {
$this->value = $value;
}
// method: get element value
public function getValue() {
return $this->value;
}
// method: set English-language element label
public function setLabel($label) {
$this->label = $label;
}
// method: get element label
public function getLabel() {
return $this->label;
}
}
?>
We assume here that every form element has three properties: a name, a value, and a
text label. The preceding class definition defines just these properties and also provides
“getter” and “setter” methods to change and retrieve these properties.
This Element object serves as the base for other, more focused form elements—such
as the Option object, which represents an element. Here’s the definition:
setValue($value);
$this->setLabel($label);
}
// method: output HTML for elements
public function render() {
echo " getValue() . "\">" . $this->getLabel() .
" \n";
}
}
?>
The constructor for an Option accepts two arguments: a value and a label. These
two arguments are then used to set the Option’s $value and $label properties, via its
setValue() and setLabel() methods. Note that these methods are not explicitly
defined in the class but actually belong to the Element class; however, due to extensibility,
the methods of the parent class are automatically available to its children.
The Option class also adds a new method, render(), which outputs the HTML
code necessary to create an element. Notice that this method internally calls
getValue() and getLabel(), also methods of its parent, to correctly generate the
necessary HTML code.
All that’s left now is to define the Select class:
options = array();
}
// method: add an option to the list
public function setOption($option) {
$this->options[] = $option;
}
// method: return all options for the list as array
private function getOptions() {
return (array)$this->options;
}
// method: output HTML code for element
public function render() {
Chapter 5:
Using Functions and Classes
echo $this->getLabel() . ": getName() . "\">\n";
foreach ($this->getOptions() as $opt) {
echo $opt->render();
}
echo " ";
}
}
?>
This class defines a single protected property, $options, as an array. The class also
offers the setOption() method, which accepts an Option object and adds it to the
$options array; and the render() method, which iterates over the $options array
and outputs the HTML code needed for the element. Both the preceding
methods are public; however, there’s also a getOptions() method, which is a private
method only used internally to return the $options array to the caller.
How would you use these objects? Here’s an example:
setLabel('Fruits');
$fruits->setName('fruit_sel');
$fruits->setOption(new Option('Oranges', 'Oranges'));
$fruits->setOption(new Option('Strawberries', 'Strawberries'));
$fruits->setOption(new Option('Pineapples', 'Pineapples'));
$fruits->setOption(new Option('Bananas', 'Bananas'));
$fruits->render();
?>
The first step is to initialize an instance of the Select class and assign the element
a label and name via the setLabel() and setName() methods—remember that
these methods have been inherited from the parent Element class. Next, the Select
object’s setOption() method is used to assign options to the selection list—each
setOption() call is passed an Option object holding the option’s label and value. Once
all the options have been assigned, the Select object’s render() method takes care of
actually writing the HTML to the page:
Here’s what the HTML output generated by render() looks like:
Fruits:
Oranges
Strawberries
Pineapples
Bananas
(continued)
151
152
PHP: A Beginner’s Guide
Why stop with just one selection list? The nice thing about OOP, after all, is
reusability—and so, it’s easy to generate multiple selection lists, just by reusing the
three classes described previously. Here’s an example illustrating this (select.php):
Project 5-3: Generating Form Selection Lists
Project 5-3: Generating Form Selection Lists
Figure 5-7 illustrates the output of this listing.
Figure 5-7
A form containing three dynamically generated selection lists
153
154
PHP: A Beginner’s Guide
Summary
This chapter introduced you to two fairly advanced constructs: user-defined functions,
which allow you to package your PHP code into reusable blocks; and classes, which
allow you to group related functions into independent, extensible units. It also gave you
a crash course in important software design concepts, such as recursion, encapsulation,
inheritance, visibility, and reflection. All of these concepts and techniques were reinforced
through the development of three practical examples; you probably found these somewhat
more challenging than those in previous chapters, but working through them will almost
certainly have moved your PHP skills up a notch.
At the close of this chapter (and this section), you know enough about the basic
grammar and syntax of object-oriented programming to recognize and understand its use
in third-party code, and also to begin writing modular, OOP-driven scripts of your own.
These skills will stand you in good stead as you move into the next section of this book,
which focuses on integrating your PHP application with data from other external sources.
Until then, though, spend some time looking at the links that follow, which offer more
detailed information on the topics discussed in this chapter.
✓
●
User-defined functions, at www.php.net/manual/en/language.functions.php
●
Classes, at www.php.net/manual/en/language.oop5.php
●
Class visibility, at www.php.net/manual/en/language.oop5.visibility.php
Chapter 5 Self Test
1. State one advantage of using functions.
2. What is the difference between an argument and a return value?
3. Using the relationship DISTANCE = SPEED * TIME, write a function that calculates
distance given the speed and time. Use this function to find the distance traveled by an
aircraft departing from London, England, at 9:30 P.M. and arriving in Bombay, India,
at 11 A.M. the next day. Assume the aircraft flies at 910 km/hr and the time difference
between London and Bombay is 4.5 hours.
4. Using the property LCM (P,Q,R,S) = LCM(LCM(LCM(P,Q),R),S), extend the
LCM/GCF example in this chapter such that it accepts an arbitrary number of values
and returns the LCM of the series.
5. What is a constructor?
Chapter 5:
Using Functions and Classes
6. What happens if you attempt to access a private method of a parent class from its child
class?
7. What would be the output of the following code?
play();
?>
8. Using the Select class defined earlier in this chapter, create a new DateSelect class
containing three selection lists, one each for day, month, and year. Demonstrate usage
of this class in a Web form.
9. What would be the output of the following PHP code:
155
This page intentionally left blank
Part
II
Working with Data from
Other Sources
Copyright © 2009 by The McGraw-Hill Companies. Click here for terms of use.
This page intentionally left blank
Chapter
6
Working with Files
and Directories
159
Copyright © 2009 by The McGraw-Hill Companies. Click here for terms of use.
160
PHP: A Beginner’s Guide
Key Skills & Concepts
●
Learn to read and write disk files
●
Process directories recursively
●
Copy, move, rename, and delete files and directories
●
Work with file paths and attributes
J
ohn Donne famously said, “No man is an island,” and this maxim holds true for PHP
scripts as well. So far, all the examples you’ve seen have been self-contained, with their
source data arriving either from user input or from variables hard-wired into the program
body. In reality, though, your PHP script will need to work with data retrieved from disk
files, SQL resultsets, XML documents, and many other data sources.
PHP comes with numerous built-in functions to access these data sources and this
chapter will get you started on the road to discovering them, by focusing specifically on
PHP’s file system functions. With 70+ functions available, there’s an abundance of options;
this chapter will give you a crash course in the most important ones, with both examples
and practical projects of reading, writing, and manipulating disk files and directories.
Reading Files
PHP’s file manipulation API is extremely flexible: it lets you read files into a string or into
an array, from the local file system or a remote URL, by lines, bytes, or characters. The
following sections explain all these variants in greater detail.
Reading Local Files
The easiest way to read the contents of a disk file in PHP is with the file_get_
contents() function. This function accepts the name and path to a disk file, and reads
the entire file into a string variable in one fell swoop. Here’s an example:
Chapter 6:
Working with Files and Directories
An alternative method of reading data from a file is PHP’s file() function, which
accepts the name and path to a file and reads the entire file into an array, with each
element of the array representing one line of the file. To process the file, all you need do is
iterate over the array using a foreach loop. Here’s an example, which reads a file into an
array and then displays it using such a loop:
Reading Remote Files
Both file_get_contents() and file() also support reading data from URLs, using
either the HTTP or FTP protocol. Here’s an example, which reads an HTML file off the
Web into an array:
In case of slow network links, it’s sometimes more efficient to read a remote file in
“chunks,” to maximize the efficiency of available network bandwidth. To do this, use the
fgets() function to read a specific number of bytes from a file, as in the next example:
161
162
PHP: A Beginner’s Guide
This listing introduces four new functions, so let’s take a closer look at it. First, the
fopen() function: it accepts the name of the source file and an argument indicating
whether the file is to be opened in read ('r'), write ('w'), or append ('a') mode,
and then creates a pointer to the file. Next, a while loop calls the fgets() function
continuously in a loop to read a specific number of bytes from the file and append these
bytes to a string variable; this loop continues until the feof() function returns true,
indicating that the end of the file has been reached. Once the loop has completed, the
fclose() function destroys the file pointer.
NOTE
In order to read remote URLs, the PHP configuration variable 'allow_url_fopen'
must be set to true in the PHP configuration file php.ini. If this variable is set to false, all
attempts to read remote files will fail.
Reading Specific Segments of a File
A final twist involves reading only a specific block of lines from a line—something that
can be accomplished with a combination of PHP’s fseek() and fgets() functions.
Consider the next example, which sets up a user-defined function named readBlock()
and accepts three arguments: the filename, the starting line number, and the number of
lines to return from the starting point:
= $start) {
$out .= $line;
$linesRead++;
// if max number of lines is defined and reached
Chapter 6:
Working with Files and Directories
// break out of loop
if (!is_null($linesRead) && $linesRead == ($lines)) {
break;
}
}
$linesScanned++;
}
return $out;
}
echo readBlock('example.txt', 3, 4);
?>
Within readBlock(), a loop iterates through the file line by line, until the starting
line number is reached (a line counter named $linesScanned keeps track of the current
line number, incrementing by 1 on each iteration of the loop). Once the starting line is
reached, it (and all subsequent lines) are read into a string variable until the specified
maximum number of lines are processed or until the end of the file is reached.
Writing Files
The flip side of reading data from files is writing data to them. And PHP comes with a
couple of different ways to do this as well. The first is the file_put_contents()
function, a close cousin of the file_get_contents() function you read about in the
preceding section: this function accepts a filename and path, together with the data to be
written to the file, and then writes the latter to the former. Here’s an example:
If the file specified in the call to file_put_contents() already exists on disk,
file_put_contents() will overwrite it by default. If, instead, you’d prefer to preserve
the file’s contents and simply append new data to it, add the special FILE_APPEND flag to
your file_put_contents() function call as a third argument. Here’s an example:
An alternative way to write data to a file is to create a file pointer with fopen(), and
then write data to the pointer using PHP’s fwrite() function. Here’s an example of this
technique:
Notice the flock() function from the preceding listing: this function “locks” a file
before reading or writing it, so that it cannot be accessed by another process. Doing this
reduces the possibility of data corruption that might occur if two processes attempt to
write different data to the same file at the same instant. The second parameter to flock()
specifies the type of lock: LOCK_EX creates an exclusive lock for writing, LOCK_SH
creates a non-exclusive lock for reading, and LOCK_UN destroys the lock.
Ask the Expert
Q:
A:
Can I read and write binary files with PHP?
Yes. The file_get_contents(), file_put_contents(), and file() functions
all read and write data in binary format by default; this lets you use PHP with binary files
without worrying that your data will get corrupted.
NOTE
The directory into which you’re trying to save the file must already exist, or else PHP
will generate a fatal error. You can test if a directory exists with the file_exists()
function, discussed later in this chapter.
Chapter 6:
Try This 6-1
Working with Files and Directories
Reading and Writing Configuration Files
Now that you know how to read and write files, let’s try creating an application that
uses the functions described in the preceding section. Assume for a second that you’re
developing a Weblog application, and you’d like your users to be able to configure certain
aspects of this application’s behavior—for example, how many posts appear on the index
page or the e-mail address that comments are sent to. In this case, you’d probably need
to build a Web-based form that allows users to input these configuration values and saves
them to a file that your application can read as needed.
This next listing generates just such a Web form, allowing users to enter values for
different configuration values and then saving this information to a disk file. When users
revisit the form, the data previously saved to the file is read and used to prefill the form’s
fields.
Here’s the code (configure.php):
Project 6-1: Reading And Writing Configuration Files
Project 6-1: Reading And Writing Configuration Files
$value) {
if (trim($value) != '') {
fwrite($fp, "$key=$value\n") or die('ERROR: Cannot write [$key] to
configuration file');
}
}
Chapter 6:
Working with Files and Directories
// close and save file
flock($fp, LOCK_UN) or die ('ERROR: Cannot unlock file');
fclose($fp);
echo 'Configuration data successfully written to file.';
}
?>
This example illustrates a common, and practical, use of PHP’s file functions: to read
and write configuration files in the context of a Web application. Figure 6-1 illustrates the
Web form generated by this script.
Once the form is submitted, the data entered into it arrives in the form of an associative
array, whose keys correspond to the configuration variables in use. This data is then validated
and a file pointer is opened to the configuration file, config.ini. A foreach loop then iterates
over the array, writing the keys and values to the file pointer in key=value format, with each
key-value pair on a separate line. The file pointer is then closed, saving the data to disk.
Figure 6-1
A Web form to enter configuration data
(continued)
167
168
PHP: A Beginner’s Guide
Here’s an example of what config.ini would look like after submitting the form in
Figure 6-1:
AdminEmailAddress=admin@abc.com
DefAuthor=Charles W
NumPosts=8
NumComments=4
If a user revisits the Web form, the script first checks if a configuration file named
config.ini exists in the current directory. If it does, the lines of the file are read into an
array with PHP’s file() function; a foreach loop then processes this array, splitting
each line on the equality (=) symbol and turning the resulting key-value pairs into an
associative array. This array is then used to prefill the form fields, by assigning a value to
each input field’s 'value' attribute.
Figure 6-2 illustrates one such Web form, prefilled with data read from the
configuration file.
Users are, of course, free to resubmit the form with new data; as explained previously,
this submission will then be used to rewrite the configuration file with new values.
Figure 6-2
A Web form prefilled with data from a configuration file
Chapter 6:
Working with Files and Directories
Processing Directories
PHP also allows developers to work with directories on the file system, iterating through
directory contents or moving forward and backward through directory trees. Iterating through
a directory is a simple matter of calling PHP’s DirectoryIterator object, as in the following
example, which uses the DirectoryIterator to read a directory and list each file within it:
valid()) {
if (!$dit->isDot()) {
echo $dit->getFilename() . "\n";
}
$dit->next();
}
unset($dit);
?>
Here, a DirectoryIterator object is initialized with a directory name, and the object’s
rewind() method is used to reset the internal pointer to the first entry in the directory. A
while loop, which runs so long as a valid() entry exists, can then be used to iterate over
the directory. Individual filenames are retrieved with the getFilename() method, while
the isDot() method can be used to filter out the entries for the current (.) and parent (..)
directories. The next() method moves the internal pointer forward to the next entry.
You can also accomplish the same task with a while loop and some of PHP’s
directory manipulation functions . . . as in the following listing:
169
170
PHP: A Beginner’s Guide
Here, the opendir() function returns a pointer to the directory named in the function
call. This pointer is then used by the readdir() function to iterate over the directory,
returning a single entry each time it is invoked. It’s then easy to filter out the . and ..
directories, and print the names of the remaining entries. Once done, the closedir()
function closes the file pointer.
TIP
Also consider PHP’s scandir() function, which accepts a directory name and returns
an array containing a list of the files within that directory together with their sizes. It’s
then easy to process this array with a foreach loop.
In some cases, you might need to process not just the first-level directory, but also
its subdirectories and sub-subdirectories. A recursive function, which you learned about
in Chapter 5, is usually the best tool for this purpose: consider the next listing, which
illustrates one such function in action:
';
printDir('.');
echo '';
}
?>
Chapter 6:
Working with Files and Directories
The printDir() function in this listing might appear complex, but it’s actually quite
simple. It accepts two arguments: the name of the top-level directory to use, and a “depth
string,” which indicates, via indentation, the position of a particular file or directory in the
hierarchy. Using this input, the function opens a pointer to the named directory and begins
processing it with readdir(), printing the name of each directory or file found. In the
event that a directory is found, the depth string is incremented by an additional character
and the printDir() function is itself recursively called to process that subdirectory. This
process continues until no further files or directories remain to be processed.
Figure 6-3 has an example of the output of this listing.
Figure 6-3
An indented directory listing
171
172
PHP: A Beginner’s Guide
Performing Other File and Directory Operations
In addition to the tools you’ve seen in previous sections, PHP comes with a whole range
of file and directory manipulation functions, which allow you to check file attributes;
copy, move, and delete files; and work with file paths and extensions. Table 6-1 lists some
of the important functions in this category.
Checking if a File or Directory Exists
If you try reading or appending to a file that doesn’t exist, PHP will typically generate a
fatal error. Ditto for attempts to access or read/write from/to a directory that doesn’t exist.
To avoid these error messages, always check that the file or directory you’re attempting to
access already exists, with PHP’s file_exists() function. The next listing illustrates it
in action:
Function
What It Does
file_exists()
Tests if a file or directory exists
filesize()
Returns the size of a file in bytes
realpath()
Returns the absolute path of a file
pathinfo()
Returns an array of information about a file and its path
stat()
Provides information on file attributes and permissions
is_readable()
Tests if a file is readable
is_writable()
Tests if a file is writable
is_executable()
Tests if a file is executable
is_dir()
Tests if a directory entry is a directory
is_file()
Tests if a directory entry is a file
copy()
Copies a file
rename()
Renames a file
unlink()
Deletes a file
mkdir()
Creates a new directory
rmdir()
Removes a directory
include() / require()
Reads an external file into the current PHP script
Table 6-1
Common PHP File and Directory Functions
Chapter 6:
Working with Files and Directories
Calculating File Size
To calculate the size of a file in bytes, call the filesize() function with the filename
as argument:
Finding the Absolute File Path
To retrieve the absolute file system path to a file, use the realpath() function, as in the
next listing:
173
174
PHP: A Beginner’s Guide
Ask the Expert
Q:
A:
Are PHP’s file functions case-sensitive with respect to filenames?
It depends on the underlying file system. Windows is case-insensitive with respect
to filenames, so PHP’s file functions are case-insensitive too. However, filenames
on *NIX systems are case-sensitive, and so PHP’s file functions are case-sensitive
too on these systems. Thus, given the file eXAMple.txt, the statement might return false on a *NIX system but true on a
Windows system.
You can also use the pathinfo() function, which returns an array containing the
file’s path, name, and extension. Here’s an example:
Retrieving File Attributes
You can obtain detailed information on a particular file, including its ownership,
permissions, and modification and access times, with PHP’s stat() function, which
returns this information as an associative array. Here’s an example:
You can check if a file is readable, writable or executable with the is_readable(),
is_writable(), and is_executable() functions. The following example illustrates
their usage:
The is_dir() function returns true if the argument passed to it is a directory, while
the is_file() function returns true if the argument passed to it is a file. Here’s an
example:
Creating Directories
To create a new, empty directory, call the mkdir() function with the path and name of the
directory to be created:
Copying Files
You can copy a file from one location to another by calling PHP’s copy() function with
the file’s source and destination paths as arguments. Here’s an example:
It’s important to note that if the destination file already exists, the copy() function
will overwrite it.
Renaming Files or Directories
To rename or move a file (or directory), call PHP’s rename() function with the old and
new path names as arguments. Here’s an example that renames a file and a directory,
moving the file to a different location in the process:
As with copy(), if the destination file already exists, the rename() function will
overwrite it.
CAUTION
PHP will only allow you to copy, delete, rename, create, and otherwise manipulate a file
or directory if the user "owning" the PHP script has the privileges necessary to perform
the task.
Removing Files or Directories
To remove a file, pass the filename and path to PHP’s unlink() function, as in the
following example:
To remove an empty directory, PHP offers the rmdir() function, which does the
reverse of the mkdir() function. If the directory isn’t empty, though, it’s necessary to
first remove all its contents (including all subdirectories) and only then call the rmdir()
function to remove the directory. You can do this manually, but a recursive function is
177
178
PHP: A Beginner’s Guide
usually more efficient—here’s an example, which demonstrates how to remove a directory
and all its children:
Here, the removeDir() function is a recursive function that accepts one input
argument: the name of the top-level directory to remove. The function begins by creating
Chapter 6:
Working with Files and Directories
a pointer to the directory with opendir() and then iterating over the directory’s contents
with a while loop—you’ve seen this technique in a previous section of this chapter.
For each directory entry found, the is_file() and is_dir() methods are used to
determine if the entry is a file or a sub-directory; if the former, the unlink() function is
used to delete the file and if the latter, the removeDir() function is called recursively
to again process the subdirectory’s contents. This process continues until no files or
subdirectories are left; at this point, the top-level directory is empty and can be removed
with a quick rmdir().
Reading and Evaluating External Files
To read and evaluate external files from within your PHP script, use PHP’s include()
or require() function. A very common application of these functions is to include a
standard header, footer, or copyright notice across all the pages of a Web site. Here’s an
example:
This is the page body.
Here, the script reads two external files, header.php and footer.php, and places
the contents of these files at the location of the include() or require() call. It’s
important to note that any PHP code to be evaluated within the files included in this
manner must be enclosed within tags.
Ask the Expert
Q:
A:
What is the difference between include() and require()?
Fairly simple: a missing include() will generate a warning but allow script execution
to continue, whereas a missing require() will generate a fatal error that halts script
execution.
179
180
PHP: A Beginner’s Guide
Try This 6-2
Creating a Photo Gallery
Let’s now try another practical example, this one using what you’ve learned about
manipulating directories and using different file functions. This next listing scans a
specified directory for digital photographs and dynamically generates a Web page to
display these images—a digital photo gallery, if you will. Here’s the code (gallery.php):
Project 6-2: Creating An Image Gallery
Project 6-2: Creating An Image Gallery
0) {
for ($x=0; $x
This listing begins by defining the path to the directory containing your digital images;
you’ll need to modify this to reflect your local system in order for the listing to work. It
also sets up an array named $photosExt containing common file extensions for digital
photographs; this information is useful when searching for image files in the named
directory.
Having set up these two variables, the listing uses PHP’s opendir() and readdir()
functions to iterate over the specified directory and process each entry in it. If an entry’s
file extension is found to match an element from $photosExt, the file and path are added
(continued)
181
182
PHP: A Beginner’s Guide
to a separate $photosList array. This process continues until all the entries in the named
directory are processed.
Assuming at least one image has been found, the next (and final) step is to generate
the HTML code to display the images on a Web page. This is accomplished by iterating
over $photosList with a foreach loop and generating an Project 7-2: Adding Employees to a Database
Project 7-2: Adding Employees to a Database
Add New Employee
';
// retrieve and check input values
$inputError = false;
if (empty($_POST['emp_name'])) {
Chapter 7:
Working with Databases and SQL
echo 'ERROR: Please enter a valid employee name';
$inputError = true;
} else {
$name = $mysqli->escape_string($_POST['emp_name']);
}
if ($inputError != true && empty($_POST['emp_desig'])) {
echo 'ERROR: Please enter a valid employee designation';
$inputError = true;
} else {
$designation = $mysqli->escape_string($_POST['emp_desig']);
}
// add values to database using INSERT query
if ($inputError != true) {
$sql = "INSERT INTO employees (name, designation)
VALUES ('$name', '$designation')";
if ($mysqli->query($sql) === true) {
echo 'New employee record added with ID: ' . $mysqli->insert_id;
} else {
echo "ERROR: Could not execute query: $sql. " . $mysqli->error;
}
}
// close message block
echo '';
// close connection
$mysqli->close();
}
?>
When this script is invoked, it generates a Web form with fields for an employee’s
name and designation. Figure 7-4 demonstrates what the initial form looks like.
(continued)
211
212
PHP: A Beginner’s Guide
Figure 7-4
A Web form to enter a new employee
When this form is submitted, the script proceeds to initialize a new MySQLi object
and open a connection to the MySQL database server. It then checks the form fields to
ensure that they contain valid input values. If they do, each input value is “sanitized” using
the MySQLi object’s escape_string() method, which automatically escapes special
characters in the input as a prelude to inserting it into the database, and then interpolated into
an INSERT query, which is executed via the object’s query() method to save the values to
the database. Errors, if any, are displayed using the MySQLi object’s error property.
Figure 7-5 demonstrates the output when a record is successfully added and Figure 7-6
demonstrates the output when an input field fails validation.
So that was pretty easy. Now, how about revising this script so that, in addition to
allowing you to add new employees to the database, it also displays the existing employee
records from the database? This isn’t very difficult—add another call to the query()
Chapter 7:
Working with Databases and SQL
Figure 7-5
The results of successfully adding a new employee to the database
Figure 7-6
The output after invalid data is submitted through the Web form
(continued)
213
214
PHP: A Beginner’s Guide
method, this time with a SELECT query, and process the result set using a loop. Here’s the
revised code:
Project 7-2: Adding Employees to a Database
Project 7-2: Adding Employees to a Database
Add New Employee
';
// retrieve and check input values
$inputError = false;
if (empty($_POST['emp_name'])) {
Chapter 7:
Working with Databases and SQL
echo 'ERROR: Please enter a valid employee name';
$inputError = true;
} else {
$name = $mysqli->escape_string($_POST['emp_name']);
}
if ($inputError != true && empty($_POST['emp_desig'])) {
echo 'ERROR: Please enter a valid employee designation';
$inputError = true;
} else {
$designation = $mysqli->escape_string($_POST['emp_desig']);
}
// add values to database using INSERT query
if ($inputError != true) {
$sql = "INSERT INTO employees (name, designation)
VALUES ('$name', '$designation')";
if ($mysqli->query($sql) === true) {
echo 'New employee record added with ID: ' . $mysqli->insert_id;
} else {
echo "ERROR: Could not execute query: $sql. " . $mysqli->error;
}
}
// close message block
echo '';
}
?>
Employee Listing
query($sql)) {
if ($result->num_rows > 0) {
echo "\n";
echo " \n";
echo "
ID \n";
echo "
Name \n";
echo "
Designation \n";
(continued)
215
216
PHP: A Beginner’s Guide
echo " \n";
while($row = $result->fetch_object()) {
echo " \n";
echo "
" . $row->id . " \n";
echo "
" . $row->name . " \n";
echo "
" . $row->designation . " \n";
echo " \n";
}
echo "
";
$result->close();
} else {
echo "No employees in database.";
}
} else {
echo "ERROR: Could not execute query: $sql. " . $mysqli->error;
}
// close connection
$mysqli->close();
?>
This version of the script now sports a SELECT query, which retrieves the records
from the employees table as objects and processes them using a loop. These records are
formatted as an HTML table and printed below the Web form. A useful side effect of this
arrangement is that new employee records saved through the form will be immediately
reflected in the HTML table once the form is submitted.
Figure 7-7 illustrates the revised output of the script.
Using PHP’s SQLite Extension
At this point, you know how to hook a PHP script up to a MySQL database and retrieve,
add, edit, and delete records from it. However, MySQL isn’t the only game in town—
PHP 5.x also includes built-in support for SQLite, a lightweight, efficient alternative to
MySQL. This section discusses SQLite and PHP’s SQLite extension in greater detail.
Introducing SQLite
SQLite is a fast, efficient database system that offers a viable alternative to MySQL,
especially for small- to medium-sized applications. However, unlike MySQL, which
contains a large number of interrelated components, SQLite is fully self-contained in a
Chapter 7:
Figure 7-7
Working with Databases and SQL
A Web page displaying the list of employees
single library file. It’s also significantly smaller in size than MySQL—the commandline version of SQLite weighs in at under 200KB—and supports all the standard SQL
commands you’re used to. MySQL and SQLite also differ in their licensing policies:
unlike MySQL, SQLite source code is completely public-domain, which means that
developers can use and distribute it however they choose, in both commercial and noncommercial products.
SQLite’s small size belies its capabilities, however. It supports databases up to two
terabytes in size and can actually produce better performance than MySQL in certain
situations. Part of this is for architectural reasons: SQLite reads and writes records
directly from and to database files on disk and so incurs less performance overhead than
MySQL, which operates a client-server architecture that may be affected by network-level
variables.
217
218
PHP: A Beginner’s Guide
NOTE
In the following exercise, boldface type indicates commands that you should enter
at the SQLite command-line prompt. Commands can be entered in either uppercase
or lowercase. Before beginning with the exercise, ensure that you have installed,
configured, and tested the SQLite database system according to the instructions in
Appendix A of this book.
SQLite supports all the standard SQL statements you’ve grown to know and love over
the preceding two sections: SELECT, INSERT, DELETE, UPDATE, and CREATE TABLE.
The following example illustrates, by replicating the MySQL database tables used in the
preceding section using SQLite. Begin by starting up the SQLite command-line client and
creating a new SQLite database file in the current directory, named music.db:
shell> sqlite music.db
If all went well, you’ll see a welcome message and an interactive SQL prompt, like
this:
sqlite>
You can now proceed to enter SQL statements at this prompt. Begin by creating a
table to hold artist information:
sqlite>
...>
...>
...>
...>
CREATE TABLE artists (
artist_id INTEGER NOT NULL PRIMARY KEY,
artist_name TEXT NOT NULL,
artist_country TEXT NOT NULL
);
Unlike MySQL, which offers a wide range of different data types for its fields, SQLite
supports just four types; these are summarized in Table 7-3.
Field Type
Description
INTEGER
A numeric type for signed integer values
REAL
A numeric type for floating-point values
TEXT
A string type
BLOB
A binary type
Table 7-3
SQLite Data Types
Chapter 7:
Working with Databases and SQL
What is more important, SQLite is a “typeless” database engine. This means that fields
in an SQLite database need not be associated with a specific type, and even if they are,
they can still hold values of a type different than what is specified. The only exception to
this rule are fields of type INTEGER PRIMARY KEY: these fields are “auto-number” fields
that generate unique numeric identifiers for the records in a table, similar to MySQL’s
AUTO_INCREMENT fields.
With these facts in mind, go ahead and create the remaining two tables using these
SQL statements:
sqlite>
...>
...>
...>
CREATE TABLE ratings (
rating_id INTEGER NOT NULL PRIMARY KEY,
rating_name TEXT NOT NULL
);
sqlite>
...>
...>
...>
...>
...>
CREATE TABLE songs (
song_id INTEGER NOT NULL PRIMARY KEY,
song_title TEXT NOT NULL,
fk_song_artist INTEGER NOT NULL,
fk_song_rating INTEGER NOT NULL
);
Next, populate the tables with some records:
sqlite>
...>
sqlite>
...>
INSERT
VALUES
INSERT
VALUES
INTO artists (artist_id, artist_name, artist_country)
('1', 'Aerosmith', 'US');
INTO artists (artist_name, artist_country)
('Abba', 'SE');
sqlite>
...>
sqlite>
...>
INSERT
VALUES
INSERT
VALUES
INTO ratings (rating_id, rating_name)
(4, 'Good');
INTO ratings (rating_id, rating_name)
(5, 'Excellent');
sqlite>
...>
sqlite>
...>
INSERT
VALUES
INSERT
VALUES
INTO songs (song_title, fk_song_artist, fk_song_rating)
('Janie''s Got A Gun', 1, 4);
INTO songs (song_title, fk_song_artist, fk_song_rating)
('Crazy', 1, 5);
NOTE
The code archive for this book has a full list of SQL INSERT statements to populate the
three tables used in this exercise. Run these statements and complete building the tables
before proceeding.
219
220
PHP: A Beginner’s Guide
Once you’re done, try a SELECT statement:
sqlite> SELECT artist_name, artist_country FROM artists
...> WHERE artist_country = 'US'
...> OR artist_country = 'UK';
Aerosmith|US
Timbaland|US
Take That|UK
Girls Aloud|UK
SQLite fully supports SQL joins—here’s an example:
sqlite> SELECT song_title, artist_name, rating_name
...> FROM songs, artists, ratings
...> WHERE songs.fk_song_artist = artists.artist_id
...> AND songs.fk_song_rating = ratings.rating_id
...> AND ratings.rating_id >= 4
...> AND artists.artist_country != 'US';
En Las Delicious|Cubanismo|Fantastic
Pray|Take That|Good
SOS|Abba|Fantastic
Dancing Queen|Abba|Good
Retrieving Data
Retrieving records from an SQLite database with PHP is not very different from retrieving
them from a MySQL database. The following PHP script illustrates the process using the
music.db database created in the preceding section:
query($sql)) {
if ($result->numRows() > 0) {
while($row = $result->fetch()) {
echo $row[0] . ":" . $row[1] . "\n";
}
} else {
echo "No records matching your query were found.";
}
} else {
echo "ERROR: Could not execute $sql. " . sqlite_error_string($sqlite>lastError());
}
// close connection
unset($sqlite);
?>
Chapter 7:
Working with Databases and SQL
This script performs the following actions:
1. It opens the SQLite database file for data operations, by initializing an instance of the
SQLiteDatabase class and passing the object constructor the full path to the database
file. If this database file cannot be found, an empty database file will be created with
the supplied name (assuming the script has write privileges to the corresponding
directory).
2. The next step is to create and execute the SQL query. This is accomplished by calling
the SQLiteDatabase object’s query() method and passing it the query to be executed.
Depending on whether or not the query was successful, the function returns true or
false; in the event of a failure, the error code corresponding to reason for failure can be
obtained by calling the SQLiteDatabase object’s lastError() method. The sqlite_
error_string() function converts this error code into a human-readable error
message.
TIP
There’s a close similarity between these steps and the steps you followed to use the
MySQL extension in the preceding section.
3. If, on the other hand, the query is successful and returns one or more records, the
return value of the query() method is another object, this one an instance of the
SQLiteResult class. This object represents the result set returned by the query, and it
exposes various methods for processing the individual records in the result set.
This script uses the fetch() method, which returns the next record in the result set
as an array each time it is invoked. Used in a loop, this method provides a convenient
way to iterate over the entire result set, one record at a time. Individual fields from the
record can be accessed as array elements, using either the field index or the field name.
The number of records in the result set can be retrieved via the SQLiteResult object’s
numRows() method.
4. Once the entire result set has been processed and no further database operations are to
take place, it’s a good idea to close the database handle, and free the memory occupied
by it, by destroying the SQLiteDatabase object.
Retrieving Records as Arrays and Objects
The SQLiteResult object’s fetch() method accepts an additional modifier, which
controls how result set records are fetched. This modifier can be any one of the values
SQLITE_NUM (to return each record as a numerically indexed array), SQLITE_ASSOC
221
222
PHP: A Beginner’s Guide
(to return each record as an associative array), or SQLITE_BOTH (to return each record
as both a numerically indexed and an associative array and the default option). Here’s an
example, which illustrates these modifiers in action while producing output equivalent to
the preceding one:
query($sql)) {
// retrieve record as numeric array
$row = $result->fetch(SQLITE_NUM);
echo $row[0] . ":" . $row[1] . "\n";
// retrieve record as associative array
$row = $result->fetch(SQLITE_ASSOC);
echo $row['artist_id'] . ":" . $row['artist_name'] . "\n";
// retrieve record as object
$row = $result->fetchObject();
echo $row->artist_id . ":" . $row->artist_name . "\n";
} else {
echo "ERROR: Could not execute $sql. " . sqlite_error_string($sqlite>lastError());
}
// close connection
unset($sqlite);
?>
It’s also possible to return each record as an object, by replacing fetch() with the
fetchObject() method. Here’s an example equivalent to the preceding listing, except
retrieving field values as object properties instead of array elements:
query($sql)) {
if ($result->numRows() > 0) {
while($row = $result->fetchObject()) {
echo $row->artist_id . ":" . $row->artist_name . "\n";
}
} else {
echo "No records matching your query were found.";
}
} else {
echo "ERROR: Could not execute $sql. " . sqlite_error_string($sqlite>lastError());
}
// close connection
unset($sqlite);
?>
An interesting feature of the SQLite extension is the ability to retrieve all the
records from the result set at once as a nested set of arrays, via the SQLiteResult
object’s fetchAll() method. A foreach loop can then iterate over this nested
collection, retrieving records one after another. The following example illustrates
this procedure in action:
query($sql)) {
$data = $result->fetchAll();
if (count($data) > 0) {
foreach ($data as $row) {
echo $row[0] . ":" . $row[1] . "\n";
}
} else {
echo "No records matching your query were found.";
}
223
224
PHP: A Beginner’s Guide
} else {
echo "ERROR: Could not execute $sql. " . sqlite_error_string($sqlite>lastError());
}
// close connection
unset($sqlite);
?>
CAUTION
The fetchAll() method returns the complete result set as a nested set of arrays,
which are stored in system memory until completely processed. To avoid running out
of memory, don’t use this method if your query is likely to return a large number of
records.
Adding or Modifying Data
For queries that don’t return a result set, such as INSERT, UPDATE, and DELETE queries,
the SQLite extension offers the queryExec() method. The following example illustrates
it in action, by adding a new record to the artists table:
queryExec($sql) == true) {
echo 'New artist with id:' . $sqlite->lastInsertRowid() . ' added.';
} else {
echo "ERROR: Could not execute $sql. " . sqlite_error_string($sqlite>lastError());
}
// close connection
unset($sqlite);
?>
Depending on whether or not the query succeeded, queryExec() returns true or
false; it’s easy to test this return value and print a success or failure message. If the
Chapter 7:
Working with Databases and SQL
record was inserted into a table with an INTEGER PRIMARY KEY field, SQLite will
have automatically assigned the record a unique identifying number. This number can be
retrieved with the SQLiteDatabase object’s lastInsertRowid() method, as illustrated
in the preceding listing.
CAUTION
For INSERTs, UPDATEs, and DELETEs to work, remember that your PHP script must
have write privileges for the SQLite database file.
When performing an UPDATE or DELETE query, the number of rows affected by the
query can likewise be retrieved via the SQLiteDatabase object’s changes() method.
The following example demonstrates, by updating the song ratings in the database and
returning a count of the records affected:
queryExec($sql) == true) {
echo $sqlite->changes() . ' row(s) updated.';
} else {
echo "ERROR: Could not execute $sql. " . sqlite_error_string($sqlite>lastError());
}
// close connection
unset($sqlite);
?>
Handling Errors
Both the query() and queryExec() methods return false if an error occurs during
query preparation or execution. It’s easy to check the return value of these methods
and retrieve the code corresponding to the error by calling the SQLiteDatabase object’s
lastError() method. Unfortunately, this error code isn’t very useful by itself; so, for a
textual description of what went wrong, wrap the call to lastError() in the sqlite_
error_string() function, as most of the preceding examples do.
225
226
PHP: A Beginner’s Guide
Try This 7-3
Creating a Personal To-Do List
Now that you’ve got a handle on SQLite, how about using it in a practical application:
a personal to-do list that you can update and view through your Web browser. This todo list will allow you to enter tasks and due dates, assign priorities to tasks, edit task
descriptions, and mark tasks as complete. It’s a little more complicated than applications
you’ve worked on so far, as it includes quite a few moving parts; however, if you’ve been
following along until this point, you shouldn’t find it too hard to figure out.
To begin, create a new SQLite database named todo.db, and add an empty table to
hold task descriptions and dates:
shell> sqlite todo.db
sqlite> CREATE TABLE tasks (
...> id INTEGER PRIMARY KEY,
...> name TEXT NOT NULL,
...> due TEXT NOT NULL,
...> priority TEXT NOT NULL
...> );
This table has four fields, one each for the record ID, the task name, the due date for the
task, and the task’s priority.
Next, create a Web form to add new tasks to this database (save.php):
Project 7-3: Creating a Personal To-Do List
Project 7-3: Creating a Personal To-Do List
Add New Task
queryExec($sql) == true) {
echo 'Task record successfully added to
database.
';
} else {
echo "ERROR: Could not execute $sql. " . sqlite_error_
string($sqlite->lastError());
}
// close connection
unset($sqlite);
}
?>
Figure 7-8 illustrates what this Web form looks like.
Figure 7-8
A Web form to add to-do items to the database
Chapter 7:
Figure 7-9
Working with Databases and SQL
The results of adding a new to-do item to the database
When a user submits this form, the data entered is first validated to ensure that all
required fields are present. Values entered into the three date field are also checked with
PHP’s checkdate() function, to ensure that together they form a valid date. The input
is then further sanitized by passing it through the sqlite_escape_string() function,
which automatically escapes special characters in the input, and saved to the database
using an INSERT query.
Figure 7-9 illustrates the output of successfully adding a new task to the database.
So that takes care of adding tasks to the to-do list. Now, how about viewing them? As
you will probably have guessed by now, this is simply a matter of using a SELECT query
to retrieve all the records from the database, and then format the resulting information
such that it is suitable for display on a Web page. Here’s the relevant code (list.php):
Project 7-3: Creating a Personal To-Do List
Project 7-3: Creating a Personal To-Do List
Task List
query($sql)) {
if ($result->numRows() > 0) {
Chapter 7:
Working with Databases and SQL
echo "\n";
echo " \n";
echo "
Description \n";
echo "
Due date \n";
echo "
\n";
while($row = $result->fetchObject()) {
echo " priority) . "\">\n";
echo "
" . $row->name . " \n";
echo "
" . date('d M Y',$row->due) . " \n";
echo "
id . "\">Mark as
Done \n";
}
echo "
";
} else {
echo 'No tasks listed in database.
';
}
} else {
echo 'ERROR: Could not execute query: $sql. ' . sqlite_error_
string($sqlite->lastError());
}
// close connection
unset($sqlite);
?>
Add New Task
Nothing too taxing here: the script merely executes a SELECT query with exec(),
and then iterates over the result set, printing the records found as rows of an HTML table.
Notice that depending on the priority field of each record, the corresponding HTML table
row is color-coded in red, green, or blue.
Figure 7-10 illustrates a sample of the output.
You’ll see something else in the figure: each item in the to-do list comes with an
option to 'Mark as Done'. This option points to yet another PHP script, mark.php,
which is responsible for removing the corresponding record from the database. Look
closely at the URL to mark.php, and you’ll see that the record ID is being passed along as
well, as the variable $id. Within mark.php, this ID will be accessible through the $_GET
array, as $_GET['id'].
(continued)
231
232
PHP: A Beginner’s Guide
Figure 7-10 A Web page displaying to-do list items, sorted by due date
What does mark.php do? Nothing too complex—it simply uses the record ID passed to
it in $_GET to formulate and execute a DELETE query, which removes the record from the
database. Here’s the code (mark.php):
Project 7-3: Creating a Personal To-Do List
Project 7-3: Creating a Personal To-Do List
Remove Completed Task
queryExec($sql) == true) {
echo 'Task record successfully removed from
database.
';
} else {
echo "ERROR: Could not execute $sql. " . sqlite_error_
string($sqlite->lastError());
}
// close connection
unset($sqlite);
} else {
die ('ERROR: Task ID is required');
}
?>
Figure 7-11 illustrates the output of successfully removing a task from the database.
And now, when you revisit list.php, your to-do list will no longer display the item that
you marked done. Simple, isn’t it!
233
234
PHP: A Beginner’s Guide
Figure 7-11 The results of marking a to-do item as complete
Using PHP’s PDO Extension
In the previous sections, you learned how to integrate your PHP application with both
MySQL and SQLite databases. As you will have seen, the MySQLi and SQLite extensions
use differently named methods to do their work; as a result, switching from one database
system to another essentially involves rewriting all your database code to use the new
methods. That’s why PHP also offers the database-neutral PHP Data Objects (PDO)
extension, which offers greater portability and can significantly reduce the effort involved
in switching from one database system to another.
The following sections discuss the PDO extension in greater detail, providing
information on how it can be used to connect to different database systems, perform
queries, process result sets, and handle connection or query errors. Most of the examples
assume a MySQL database system; however, as you’ll see, PDO-based programs require
minimal modification to work with other database systems, including SQLite.
Retrieving Data
PDO works by providing a standard set of functions for common database operations such
as connecting, querying, result set processing and error handling, and internally translating
these functions to native API calls understood by the database in use. To illustrate how it
Chapter 7:
Working with Databases and SQL
works, consider the following example, which executes a SELECT query and displays the
records found:
getMessage());
}
// create and execute SELECT query
$sql = "SELECT artist_id, artist_name FROM artists";
if ($result = $pdo->query($sql)) {
while($row = $result->fetch()) {
echo $row[0] . ":" . $row[1] . "\n";
}
} else {
echo "ERROR: Could not execute $sql. " . print_r($pdo->errorInfo());
}
// close connection
unset($pdo);
?>
As this listing illustrates, using PDO to get data from a database involves steps similar
to those you’ve seen in previous sections:
1. The first step is to initialize an instance of the PDO class and pass the object constructor
three arguments: a Data Source Name (DSN) string indicating the type of database to
connect to as well as other database-specific options, a valid database username, and
the corresponding password. The DSN string varies from database to database; you can
typically obtain the exact format for this string from the database’s documentation.
Table 7-4 lists some common DSN string formats.
Database
DSN String
MySQL
'mysql:host=host;port=port;dbname=db'
SQLite
'sqlite:path/to/database/file'
PostgreSQL
'pgsql:host=host port=port dbname=db user=user
password=pass'
Oracle
'oci:dbname=//host:port/db'
Firebird
'firebird:User=user;Password=pass;Database=db;
DataSource=host;Port=port'
Table 7-4
Common DSN Strings
235
236
PHP: A Beginner’s Guide
If the connection attempt is unsuccessful, an exception will be raised; this exception
can be caught and handled using PHP’s exception-handling mechanism (more details
on exceptions can be obtained from Chapter 10 of this book).
2. Assuming a successful connection, the next step is to formulate an SQL query and
execute it using PDO’s query() method. The return value of this method is a resultset,
represented by a PDOStatement object. The contents of the resultset can be processed
using the object’s fetch() method, which returns the next record in the resultset as an
array (both associative and indexed). Individual fields from the record can be accessed
as array elements in a loop, using either the field index or the field name.
Ask the Expert
Q:
A:
How do I calculate the number of records in my resultset with PDO?
Unlike the MySQL and SQLite extensions, PDO does not offer a built-in method
or property to directly retrieve the number of records in a returned resultset. This is
because not all database systems return this information, and so PDO cannot provide this
information in a portable manner. Should you still require this information, however, the
recommended approach to this task in the PHP manual is to execute a SELECT COUNT(*)
... statement with your desired query and retrieve the first field of the resultset, which
will hold the number of records matching the query. For more information, review the
discussion at www.php.net/manual/en/function.PDOStatement-rowCount.php.
The PDOStatement object’s fetch() method accepts an additional modifier, which
controls how result set records are fetched. Some valid values for this modifier are listed
in Table 7-5.
Modifier
What It Does
PDO::FETCH_NUM
Returns each record as a numerically indexed array
PDO::FETCH_ASSOC
Returns each record as an associative array keyed on the field name
PDO::FETCH_BOTH
Returns each record as both a numerically indexed array and an associative
array (default value)
PDO::FETCH_OBJ
Returns each record as an object with properties corresponding to the
field names
PDO::FETCH_LAZY
Returns each record as a numerically indexed array, associative array,
and object
Table 7-5
Modifiers to PDO’s fetch() Method
Chapter 7:
Working with Databases and SQL
The following listing illustrates these modifiers in action:
getMessage());
}
// create and execute SELECT query
$sql = "SELECT artist_id, artist_name FROM artists";
if ($result = $pdo->query($sql)) {
// retrieve record as numeric array
$row = $result->fetch(PDO::FETCH_NUM);
echo $row[0] . ":" . $row[1] . "\n";
// retrieve record as associative array
$row = $result->fetch(PDO::FETCH_ASSOC);
echo $row['artist_id'] . ":" . $row['artist_name'] . "\n";
// retrieve record as object
$row = $result->fetch(PDO::FETCH_OBJ);
echo $row->artist_id . ":" . $row->artist_name . "\n";
// retrieve record using combination of styles
$row = $result->fetch(PDO::FETCH_LAZY);
echo $row['artist_id'] . ":" . $row->artist_name . "\n";
} else {
echo "ERROR: Could not execute $sql. " . print_r($pdo->errorInfo());
}
// close connection
unset($pdo);
?>
Adding and Modifying Data
PDO also makes it easy to perform INSERT, UPDATE, and DELETE queries with its
exec() method. This method, which is designed for one-off SQL queries that change the
237
238
PHP: A Beginner’s Guide
database, returns the number of records affected by the query. Here’s an example of using
it to insert and delete a record:
getMessage());
}
// create and execute INSERT query
$sql = "INSERT INTO artists (artist_name, artist_country) VALUES ('Luciano
Pavarotti', 'IT')";
$ret = $pdo->exec($sql);
if ($ret === false) {
echo "ERROR: Could not execute $sql. " . print_r($pdo->errorInfo());
} else {
$id = $pdo->lastInsertId();
echo 'New artist with id: ' . $id . ' added.';
}
// create and execute DELETE query
$sql = "DELETE FROM artists WHERE artist_country = 'IT'";
$ret = $pdo->exec($sql);
if ($ret === false) {
echo "ERROR: Could not execute $sql. " . print_r($pdo->errorInfo());
} else {
echo 'Deleted ' . $ret . ' record(s).';
}
// close connection
unset($pdo);
?>
This listing uses the exec() method twice, first to insert a new record and then
to delete records matching a specified condition. If the query passed to exec() is
unsuccessful, exec() returns false; if not, it returns the number of records affected by
the query. Notice also the script’s use of the PDO object’s lastInsertId() method,
which returns the ID generated by the last INSERT command if the table contains an autoincrementing field.
TIP
If no records are affected by the query executed by the exec() method, the method will
return zero. Don’t confuse this with the Boolean false value returned by exec() if the
query fails. To avoid confusion, the PHP manual recommends always testing the return
value of exec() with the === operator instead of the == operator.
Chapter 7:
Working with Databases and SQL
Using Prepared Statements
PDO also supports prepared statements, via its prepare() and execute() methods. The
following example illustrates, using a prepared statement to add various songs to the database:
getMessage());
}
// create and execute SELECT query
$sql = "INSERT INTO songs (song_title, fk_song_artist, fk_song_rating) VALUES
(?, ?, ?)";
if ($stmt = $pdo->prepare($sql)) {
foreach ($songs as $s) {
$stmt->bindParam(1, $s[0]);
$stmt->bindParam(2, $s[1]);
$stmt->bindParam(3, $s[2]);
if ($stmt->execute()) {
echo "New song with id: " . $pdo->lastInsertId() . " added.\n";
} else {
echo "ERROR: Could not execute query: $sql. " . print_r
($pdo->errorInfo());
}
}
} else {
echo "ERROR: Could not prepare query: $sql. " . print_r($pdo->errorInfo());
}
// close connection
unset($pdo);
?>
If you compare the preceding script with a similar script from the previous section on
MySQLi, you’ll see a marked resemblance. Like before, this script too defines an SQL
239
240
PHP: A Beginner’s Guide
query template containing an INSERT statement, containing placeholders instead of actual
values, and then turns this template into a prepared statement using the PDO object’s
prepare() method.
If successful, prepare() returns a PDOStatement object representing the prepared
statement. The values to be interpolated into the statement are then bound to the
placeholders by repeatedly calling the PDOStatement object’s bindParam() method
with two arguments, the position of the placeholder and the variable to bind to it. Once
the variables are bound, the PDOStatement object’s execute() method takes care of
actually executing the prepared statement with the correct values.
NOTE
When using prepared statements with PDO, it’s important to note that the performance
benefits of these statements will only be available if the underlying database natively
supports these statements. For databases that don’t support prepared statements,
PDO will internally convert calls to prepare() and execute() into standard SQL
statements and no performance benefits will accrue in these cases.
Handling Errors
When performing database operations with PDO, errors may occur during either the
connection phase or the query execution phase. PDO offers robust tools to handle both
these types of errors.
Connection Errors
If PDO is unable to connect to the named database using the supplied DSN, username,
and password, it automatically generates a PDOException. This exception can be trapped
using PHP’s standard exception-handling mechanism (discussed in detail in Chapter 10),
and an error message explaining the cause of error can be retrieved from the exception
object.
Query Execution Errors
If an error occurs during query preparation or execution, PDO provides information on
the error via its errorInfo() method. This method returns an array containing three
elements: the SQL error code, a database error code, and a human-readable error message
(also generated by the underlying database). It’s easy to process this array and print the
appropriate elements from it within the error-handling section of your script.
Chapter 7:
Try This 7-4
Working with Databases and SQL
Building a Login Form
Let’s now put PDO through its paces with another practical application, one you’re likely
to encounter again and again in your PHP development: a login form. This application will
generate a Web form for users to enter their usernames and passwords; it will then verify
this input against credentials stored in a database and allow or reject the login attempt. In
the first instance, this application will use a MySQL database; later on, however, you’ll
see just how portable PDO code is, when we switch the application over to an SQLite
database.
Using a MySQL Database
To begin, fire up your MySQL command-line client and create a table to hold usernames
and passwords, as follows:
mysql> CREATE DATABASE app;
Query OK, 0 rows affected (0.07 sec)
mysql> USE app;
Query OK, 0 rows affected (0.07 sec)
mysql> CREATE TABLE users (
-> id int(4) NOT NULL AUTO_INCREMENT,
-> username VARCHAR(255) NOT NULL,
-> password VARCHAR(255) NOT NULL,
-> PRIMARY KEY (id));
Query OK, 0 rows affected (0.07 sec)
At this point, it’s also a good idea to “seed” the table by entering some usernames
and passwords. For simplicity, we’ll keep the passwords the same as the usernames,
but encrypt them so that they’re shielded from casual viewers (and not-so-casual
hackers):
mysql> INSERT INTO users (username, password)
-> VALUES ('john', ' $1$Tk0.gh4.$42EZDbQ4mOfmXMq.0m1tS1');
Query OK, 1 row affected (0.21 sec)
mysql> INSERT INTO users (username, password)
-> VALUES ('jane', '$1$.l5.tR/.$XK1KW1Wzqy0UuMFKQDHH00');
Query OK, 1 row affected (0.21 sec)
(continued)
241
242
PHP: A Beginner’s Guide
Now, all that’s needed is a login form, and some PHP code to read the values entered
into the form and test them against the values in the database. Here’s the code (login.php):
Project 7-4: Building A Login Form
Project 7-4: Building A Login Form
getMessage());
}
// escape special characters in input
$username = $pdo->quote($username);
// check if usernames exists
$sql = "SELECT COUNT(*) FROM users WHERE username = $username";
if ($result = $pdo->query($sql)) {
$row = $result->fetch();
// if yes, fetch the encrypted password
if ($row[0] == 1) {
$sql = "SELECT password FROM users WHERE
username = $username";
// encrypt the password entered into the form
// test it against the encrypted password stored in
the database
// if the two match, the password is correct
if ($result = $pdo->query($sql)) {
$row = $result->fetch();
$salt = $row[0];
if (crypt($password, $salt) == $salt) {
echo 'Your login credentials were successfully
verified.';
} else {
echo 'You entered an incorrect password.';
}
} else {
echo "ERROR: Could not execute $sql. " . print_r
($pdo->errorInfo());
}
} else {
echo 'You entered an incorrect username.';
}
} else {
echo "ERROR: Could not execute $sql. " . print_r
($pdo->errorInfo());
}
// close connection
unset($pdo);
}
?>
Figure 7-12 illustrates what the login form looks like.
(continued)
243
244
PHP: A Beginner’s Guide
Figure 7-12 A Web-based login form
When this form is submitted, the second half of the script comes into play. This performs
a number of steps:
1. It checks the form input to ensure that both the username and the password are present,
and halts script execution with an error message if either one is absent. It also escapes
special characters in the input using PDO’s quote() method.
2. It opens a connection to the database and performs a SELECT query to check if a
matching username is present in the database. If this check returns false, it generates
the error message “You entered an incorrect username.”
3. If the username is present, the script then proceeds to test the password. Because
the password is encrypted using a one-way encryption scheme, this test cannot be
performed directly; the only way to do this is to re-encrypt the user’s password, as
entered in the form, and test the result against the version stored in the database. If
the two encrypted strings match, it implies that the password entered is correct.
Chapter 7:
Working with Databases and SQL
Figure 7-13 The results of entering an incorrect password into the login form
4. Depending on the results of the test, the script then generates either the message 'You
entered an incorrect password.' or 'Your login credentials were
successfully verified.'
Figure 7-13 illustrates the result of entering an incorrect password and Figure 7-14
illustrates the result of entering a correct password.
Figure 7-14 The results of entering a correct password into the login form
245
246
PHP: A Beginner’s Guide
Ask the Expert
Q:
A:
How did you generate the encrypted passwords used in this example?
The encrypted password strings used in this example were generated with PHP’s
crypt() function, which uses a one-way encryption scheme to encrypt any string
passed to it as input. A one-way encryption scheme renders the original password
irrecoverable (hence the term “one-way”). The encryption is based on a unique key
or salt, which can be optionally provided to the function as a second argument; in its
absence, PHP automatically generates a salt.
The original password is no longer recoverable after being passed through
crypt(), and so performing password validation later against a user-supplied value
is a two-step process: first, re-encrypt the user-supplied value with the same salt used
in the original encryption process and then, test if the two encrypted strings match.
That’s precisely what the form processing script in this example does.
Switching to a Different Database
Now, let’s assume that external reasons force you to switch over from MySQL to SQLite.
The first thing you’ll need to do is create a database table to hold all the user account
information. So, fire up your SQLite client and replicate the database created in the
preceding section (name the database file app.db):
sqlite>
->
->
->
->
CREATE TABLE users (
id INTEGER PRIMARY KEY,
username TEXT NOT NULL,
password TEXT NOT NULL
);
sqlite>
->
sqlite>
->
INSERT
VALUES
INSERT
VALUES
INTO users (username, password)
('john', ' $1$Tk0.gh4.$42EZDbQ4mOfmXMq.0m1tS1');
INTO users (username, password)
('jane', '$1$.l5.tR/.$XK1KW1Wzqy0UuMFKQDHH00');
The next step is to update your application’s code so that it communicates with this
SQLite database instead of the MySQL database. Because you’re using PDO, this update
consists of changing one—that’s right, one—line in your PHP script: the DSN passed to
the PDO object constructor. Here’s the relevant segment of code:
getMessage());
}
?>
And now, when you try logging in, your application will work exactly as it did before,
except that now it will use the SQLite database instead of the MySQL database. Try it for
yourself and see!
This portability is precisely why PDO is gaining popularity among PHP developers; it
makes the entire process of switching from one database system to another an extremely
simple one, reducing both development and testing time and the associated cost.
Summary
PHP’s database support is one of the biggest reasons for its popularity, and this chapter
covered all the ground necessary for you to get started with this important language
feature. It began by introducing you to basic database concepts, and teaching you the
basics of Structured Query Language. It then rapidly proceeded to a discussion of PHP’s
most popular database extensions: the MySQLi extension, the SQLite extension, and
the Portable Database Objects (PDO) extension. The discussion included both practical
information and code examples of querying and modifying databases with PHP to get you
started using these extensions in your daily development.
To read more about the topics discussed in this chapter, consider visiting the following
links:
●
Database concepts, at
www.melonfire.com/community/columns/trog/article.php?id=52
●
SQL basics, at www.melonfire.com/community/columns/trog/article.php?id=39
and www.melonfire.com/community/columns/trog/article.php?id=44
●
More information on SQL joins, at
www.melonfire.com/community/columns/trog/article.php?id=148
●
The MySQL Web site, at www.mysql.com
●
The SQLite Web site, at www.sqlite.org
●
PHP’s MySQLi extension, at www.php.net/mysqli
●
PHP’s SQLite extension, at www.php.net/sqlite
●
PHP’s PDO extension, at www.php.net/pdo
247
248
PHP: A Beginner’s Guide
✓
Chapter 7 Self Test
1. Mark the following statements as true or false:
A SQL table joins can only take place between foreign and primary key fields.
B MySQL support is new to PHP.
C The ORDER BY clause is used to sort the fields of an SQL result set.
D PRIMARY KEY fields can hold null values.
E It is possible to override the value generated by SQLite for an INTEGER PRIMARY
KEY field.
F Prepared statements can be used only for INSERT operations.
2. Correctly identify the SQL command for each of the following database operations:
A Delete a database
B Update a record
C Delete a record
D Create a table
E Select a database for use
3. What is database normalization, and why is it useful?
4. Name one advantage and one disadvantage of using a database abstraction library like
PDO instead of a native database extension.
5. Using the PDO extension, write a PHP script to add new songs to the songs table
developed in this chapter. Allow users to select the song’s artist and rating from dropdown form selection lists populated with the contents of the artists and ratings tables.
6. Using PHP’s MySQLi extension, write a PHP script to create a new database table with
four fields of your choice. Then, do the same task with an SQLite database table using
PHP’s SQLite extension.
7. Manually populate the MySQL database tables created in the preceding assignment
with 7–10 records of your choice. Then, write a PDO-based script to read the contents
of this table and migrate the data found therein to the SQLite database table also
created in the preceding assignment. Use a prepared statement.
Chapter
8
Working with XML
249
Copyright © 2009 by The McGraw-Hill Companies. Click here for terms of use.
250
PHP: A Beginner’s Guide
Key Skills & Concepts
●
Understand basic XML concepts and technologies
●
Understand PHP’s SimpleXML and DOM extensions
●
Access and manipulate XML documents with PHP
●
Create new XML documents from scratch using PHP
●
Integrate third-party RSS feeds in a PHP application
●
Convert between SQL and XML using PHP
T
he Extensible Markup Language (XML) is a widely accepted standard for data
description and exchange. It allows content authors to “mark up” their data with
customized machine-readable tags, thereby making data easier to classify and search.
XML also helps enforce a formal structure on content, and it provides a portable format
that can be used to easily exchange information between different systems.
PHP has included support for XML since PHP 4, but it was only in PHP 5 that the
various XML extensions in PHP were standardized to use a common XML parsing toolkit.
This chapter introduces you to two of PHP’s most useful and powerful XML processing
extensions—SimpleXML and DOM—and includes numerous code examples and practical
illustrations of using XML in combination with PHP-based applications.
Introducing XML
Before getting into the nitty-gritty of manipulating XML files with PHP, it’s instructive
to spend some time getting familiar with XML. If you’re new to XML, the following
section provides a grounding in basic XML, including an overview of XML concepts and
technologies. This information will be helpful to understand the more advanced material
in subsequent sections.
XML Basics
Let’s begin with a very basic question: what is XML, and why is it useful?
XML is a language that helps document authors describe the data in a document, by
“marking it up” with custom tags. These tags don’t come from a predefined list; instead,
Chapter 8:
Working with XML
XML encourages authors to create their own tags and structure, suited to their own
particular requirements, as a way to increase flexibility and usability. This fact, coupled
with the Recommendation status bestowed on it by the W3C in 1998, has served to make
XML one of the most popular ways to describe and store structured information on (and
off) the Web.
XML data is physically stored in text files. This makes XML documents very portable,
because every computer system can read and process text files. Not only does this
facilitate data sharing, but it also allows XML to be used in a wide variety of applications.
For example, the Rich Site Summaries (RSS) and Atom Weblog feed formats are both
based on XML, as is Asynchronous JavaScript and XML (AJAX) and the Simple Object
Access Protocol (SOAP).
Ask the Expert
Q:
A:
What programs can I use to create or view an XML file?
On a UNIX/Linux system, both vi and emacs can be used to create XML documents,
while Notepad remains a favorite on Windows systems. Both Microsoft Internet
Explorer and Mozilla Firefox have built-in XML support and can read and display
an XML document in a hierarchical tree view.
Anatomy of an XML Document
Internally, an XML document is made up of various components, each one serving
a specific purpose. To understand these components, consider the following XML
document, which contains a recipe for spaghetti bolognese:
1.
2.
3.
4.
- Beef mince
5.
- Onions
6.
- Red wine
7.
- Tomatoes
8.
- Parmesan cheese
9.
- Spaghetti
10.
11.
12.
Chop and fry the onions.
13.
Add the mince to the fried onions &
continue frying.
251
252
PHP: A Beginner’s Guide
14.
Puree the tomatoes and blend them into the
mixture with the wine.
15.
Simmer for an hour.
16.
Serve on top of cooked pasta with Parmesan
cheese.
17.
18.
This XML document contains a recipe, broken up into different sections; each
section is further “marked up” with descriptive tags to precisely identify the type of data
contained within it. Let’s look at each of these in detail.
1. Every XML document must begin with a declaration that states the version of XML
being used; this declaration is referred to as the document prolog, and it can be seen
in Line 1 of the preceding XML document. In addition to the version number, this
document prolog may also contain character encoding information and Document Type
Definition (DTD) references (for data validation).
2. The document prolog is followed by a nested series of elements (Lines 2–18). Elements
are the basic units of XML; they typically consist of a pair of opening and closing
tags that enclose some textual content. Element names are user-defined; they should
be chosen with care, as they are intended to describe the content sandwiched between
them. Element names are case-sensitive and must begin with a letter, optionally
followed by more letters and numbers. The outermost element in an XML document—
in this example, the element named on Line 2—is known as the document
element or the root element.
3. The textual data enclosed within elements is known, in XML parlance, as character
data. This character data can consist of strings, numbers, and special characters (with
some exceptions: angle brackets and ampersands within textual data should be replaced
with the entities <, $gt;, and & respectively to avoid confusing the XML
parser when it reads the document). Line 13, for example, uses the & entity to
represent an ampersand within its character data.
4. Finally, elements can also contain attributes, which are name-value pairs that hold
additional information about the element. Attribute names are case-sensitive and
follow the same rules as element names. The same attribute name cannot be used more
than once within the same element, and attribute values should always be enclosed in
quotation marks. Lines 4–9 and 12–16 in the example document illustrate the use of
attributes to provide additional descriptive information about the element to which they
are attached; for example, the 'units' attribute specifies the unit measure for each
ingredient.
Chapter 8:
Working with XML
XML documents can also contain various other components: namespaces, processing
instructions, and CDATA blocks. These are a little more complex, and you won’t see them
in any of the examples used in this chapter; however, if you’re interested in learning more
about them, take a look at the links at the end of the chapter for more detailed information
and examples.
Ask the Expert
Q:
A:
Can I create elements that don’t contain anything?
Sure. The XML specification supports elements that hold no content and therefore do
not require a closing tag. To close these elements, simply add a slash to the end of the
opening tag, as in the following code snippet:
The line breaks
The Shining
Stephen King
673
Shutter Island
Dennis Lehane
390
The Lord Of The Rings
J. R. R. Tolkien
3489
Double Cross
James Patterson
308
Ghost Story
Peter Straub
389
Glory Road
Robert Heinlein
489
The Exorcist
William Blatty
301
The Camel Club
David Baldacci
403
Save this file to a location under your Web server’s document root, and name it
library.xml. Then, start up your Web browser, and browse to the URL corresponding
to the file location. You should see something like Figure 8-1.
Chapter 8:
Figure 8-1
Working with XML
An XML document, as seen in Mozilla Firefox
Using PHP’s SimpleXML Extension
Although PHP has support for both DOM and SAX parsing methods, by far the easiest
way to work with XML data in PHP is via its SimpleXML extension. This extension,
which is enabled by default in PHP 5, provides a user-friendly and intuitive interface to
reading and processing XML data in a PHP application.
Working with Elements
SimpleXML represents every XML document as an object and turns the elements within it
into a hierarchical set of objects and object properties. Accessing a particular element now
becomes as simple as using parent->child notation to traverse the object tree until that
element is reached.
257
258
PHP: A Beginner’s Guide
To illustrate how this works in practice, consider the following XML file (address.xml):
13 High Street
Oxfordshire
Oxford
OX1 1BA
UK
Here’s a PHP script that uses SimpleXML to read this file and retrieve the city name
and ZIP code:
city->name . "\n";
echo "Postal code: " . $xml->city->zip . "\n";
?>
To read an XML file with SimpleXML, use the simplexml_load_file() function
and pass it the disk path to the target XML file. This function will then read and parse
the XML file and, assuming it is well-formed, return a SimpleXML object representing
the document’s root element. This object is only the top level of a hierarchical object tree
that mirrors the internal structure of the XML data: elements below the root element are
represented as properties or child objects and can thus be accessed using the standard
parentObject->childObject notation.
TIP
If your XML data is in a string variable instead of a file, use the simplexml_load_
string() function to read it into a SimpleXML object.
Multiple instances of the same element at the same level of the XML document tree
are represented as arrays. These can easily be processed using PHP’s loop constructs. To
illustrate, consider this next example, which reads the library.xml file developed in the
preceding section and prints the title and author names found within it:
book as $book) {
echo $book->title . " is written by " . $book->author . ".\n";
}
?>
Here, a foreach loop iterates over the objects generated from the XML data,
printing each object’s 'title' and 'author' properties.
You can also count the number of elements at particular level in the XML document
with a simple call to count(). The next listing illustrates, counting the number of
s in the XML document:
book) . ' book(s) found.';
?>
Working with Attributes
If an XML element contains attributes, SimpleXML has an easy way to get to these as
well: attributes and values are converted into keys and values of a PHP associative array
and can be accessed like regular array elements.
To illustrate, consider the following example, which reads the library.xml file from
the preceding section and prints each book title found, together with its 'genre' and
'rating':
book as $book) {
echo $book->title . "\n";
echo "Genre: " . $book['genre'] . "\n";
echo "Rating: " . $book['rating'] . "\n\n";
}
?>
259
260
PHP: A Beginner’s Guide
In this example, a foreach loop iterates over the elements in the XML data,
turning each into an object. Attributes of the book element are represented as elements of
an associative array and can thus be accessed by key: the key 'genre' returns the value
of the 'genre' attribute, and the key 'rating' returns the value of the 'rating'
attribute.
Try This 8-2
Converting XML to SQL
Now that you know how to read XML elements and attributes, let’s look at a practical
example of SimpleXML in action. This next program reads an XML file and converts the
data within it into a series of SQL statements, which can be used to transfer the data into
a MySQL or other SQL-compliant database.
Here’s the sample XML file (inventory.xml):
-
Cheddar cheese
3.99
-
Blue cheese
5.49
-
Smoked bacon (pack of 6 rashers)
1.99
-
Smoked bacon (pack of 12 rashers)
2.49
-
Goose liver pate
7.99
-
Duck liver pate
6.49
Chapter 8:
Working with XML
And here’s the PHP code that converts this XML data into SQL statements
(xml2sql.php):
elements
// access child nodes and interpolate with SQL statement
foreach ($xml as $item) {
echo "INSERT INTO items (sku, name, price) VALUES ('" . addslashes($item['sku']) .
"','" . addslashes($item->name) . "','" . addslashes($item->price) . "');\n";
}
?>
This script should be simple to understand if you’ve been following along: it iterates
over all the - elements in the XML document, using object->property notation
to access each item’s
and . The 'sku' attribute of each - is
similarly accessed via the 'sku' key of each item’s attribute array. The values retrieved
in this fashion are then interpolated into an SQL INSERT statement.
This statement would normally then be supplied to a function such as mysql_
query() or sqlite_query() for insertion into a MySQL or SQLite database; for
purposes of this example, it’s simply printed to the output device.
Figure 8-2 illustrates the output of this script.
Figure 8-2
Converting XML to SQL with SimpleXML
261
262
PHP: A Beginner’s Guide
Altering Element and Attribute Values
With SimpleXML, it’s easy to change the content in an XML file: simply assign a new
value to the corresponding object property using PHP’s assignment operator (=). To
illustrate, consider the following PHP script, which changes the title and author of the
second book in library.xml and then outputs the revised XML document:
book[1]->title = 'Invisible Prey';
$xml->book[1]->author = 'John Sandford';
// output new XML string
header('Content-Type: text/xml');
echo $xml->asXML();
?>
Here, SimpleXML is used to access the second
element by index, and the
values of the and <author> elements are altered by setting new values for
the corresponding object properties. Notice the asXML() method, which is new in this
example: it converts the nested hierarchy of SimpleXML objects and object properties
back into a regular XML string.
Changing attribute values is just as easy: assign a new value to the corresponding key
of the attribute array. Here’s an example, which changes the sixth book’s 'rating' and
outputs the result:
<?php
// load XML file
$xml = simplexml_load_file('library.xml') or die ("Unable to load XML!");
// change attribute values
// set new rating for sixth book
$xml->book[5]{'rating'} = 5;
// output new XML string
header('Content-Type: text/xml');
echo $xml->asXML();
?>
Chapter 8:
Working with XML
Adding New Elements and Attributes
In addition to allowing you to alter element and attribute values, SimpleXML also lets you
dynamically add new elements and attributes to an existing XML document. To illustrate,
consider the next script, which adds a new <book> to the library.xml XML data:
<?php
// load XML file
$xml = simplexml_load_file('library.xml') or die ("Unable to load XML!");
// get the last book 'id'
$numBooks = count($xml->book);
$lastID = $xml->book[($numBooks-1)]{'id'};
// add a new <book> element
$book = $xml->addChild('book');
// get the 'id' attribute
// for the new <book> element
// by incrementing $lastID by 1
$book->addAttribute('id', ($lastID+1));
// add 'rating' and 'genre' attributes
$book->addAttribute('genre', 'travel');
$book->addAttribute('rating', 5);
// add <title>, <author> and <page> elements
$title = $book->addChild('title', 'Frommer\'s Italy 2007');
$author = $book->addChild('author', 'Various');
$page = $book->addChild('pages', 820);
// output new XML string
header('Content-Type: text/xml');
echo $xml->asXML();
?>
Every SimpleXML object exposes an addChild() method (for adding new child
elements) and an addAttribute() method (for adding new attributes). Both these
methods accept a name and a value, generate the corresponding element or attribute, and
attach it to the parent object within the XML hierarchy.
These methods are illustrated in the preceding listing, which begins by reading
the existing XML document into a SimpleXML object. The root element of this XML
document is stored in the PHP object $xml. The listing then needs to calculate the
ID to be assigned to the new <book> element: it does this by counting the number of
<book> elements already present in the XML document, accessing the last such element,
retrieving that element’s 'id' attribute, and adding 1 to it.
263
264
PHP: A Beginner’s Guide
With that formality out of the way, the listing then dives into element and attribute
creation proper:
1. It starts off by attaching a new <book> element to the root element, by invoking the
$xml object’s addChild() method. This method accepts the name of the element to
be created and (optionally) a value for that element. The resultant XML object is stored
in the PHP object $book.
2. With the element created, it’s now time to set its 'id', 'genre', and 'rating'
attributes. This is done via the $book object’s addAttribute() method, which also
accepts two arguments—the attribute name and value—and sets the corresponding
associative array keys.
3. Once the outermost <book> element is fully defined, it’s time to add the <title>,
<author>, and <pages> elements as children of this <book> element. This is easily
done by again invoking the addChild() method, this time of the $book object.
4. Once these child objects are defined, the object hierarchy is converted to an XML
document string with the asXML() method.
Figure 8-3 illustrates what the output looks like.
Creating New XML Documents
You can also use SimpleXML to create a brand-spanking-new XML document from
scratch, by initializing an empty SimpleXML object from an XML string, and then using
the addChild() and addAttribute() methods to build the rest of the XML document
tree. Consider the following example, which illustrates the process:
<?php
// load XML from string
$xmlStr = "<?xml version='1.0'?><person></person>";
$xml = simplexml_load_string($xmlStr);
// add attributes
$xml->addAttribute('age', '18');
$xml->addAttribute('sex', 'male');
// add child elements
$xml->addChild('name', 'John Doe');
$xml->addChild('dob', '04-04-1989');
// add second level of child elements
$address = $xml->addChild('address');
Chapter 8:
Figure 8-3
Working with XML
Inserting elements into an XML tree with SimpleXML
$address->addChild('street', '12 A Road');
$address->addChild('city', 'London');
// add third level of child elements
$country = $address->addChild('country', 'United Kingdom');
$country->addAttribute('code', 'UK');
// output new XML string
header('Content-Type: text/xml');
echo $xml->asXML();
?>
This PHP script is similar to what you’ve already seen in the preceding section, with
one important difference: instead of grafting new elements and attributes on to a preexisting
XML document tree, this one generates an XML document tree entirely from scratch!
265
266
PHP: A Beginner’s Guide
Figure 8-4
Dynamically generating a new XML document with SimpleXML
The script begins by initializing a string variable to hold the XML document prolog
and root element. The simplexml_load_string() method takes care of converting
this string into a SimpleXML object representing the document’s root element. Once this
object has been initialized, it’s a simple matter to add child elements and attributes to it,
and to build the rest of the XML document tree programmatically. Figure 8-4 shows the
resulting XML document tree.
Try This 8-3
Reading RSS Feeds
RDF Site Summary (RSS) is an XML-based format originally devised by Netscape to
distribute information about the content on its My.Netscape.com portal. Today, RSS is
extremely popular on the Web as a way to distribute content; many Web sites offer RSS
“feeds” that contain links and snippets of their latest news stories or content, and most
browsers come with built-in RSS readers, which can be used to read and “subscribe” to
these feeds.
Chapter 8:
Working with XML
An RSS document follows all the rules of XML markup and typically contains a list of
resources (URLs), marked up with descriptive metadata. Here’s an example:
<?xml version="1.0" encoding="utf-8"?>
<rss>
<channel>
<title>Feed title here
Feed description here
-
Story title here
Story description here
Story timestamp here
-
...
As this sample document illustrates, an RSS document opens and closes with the
element. A block contains general information about the Web
site providing the feed; this is followed by multiple - elements, each of which
represents a different content unit or news story. Each of these
- elements further
contains a title, a URL, and a description of the item.
Given this well-defined and hierarchical structure, parsing an RSS feed with
SimpleXML is extremely simple. That’s precisely what this next script does: it connects
to a URL hosting a live RSS feed, retrieves the XML-encoded feed data, parses it, and
converts it to an HTML page suitable for viewing in any Web browser. Here’s the code
(rss2html.php):
Project 8-3: Reading RSS Feeds
Project 8-3: Reading RSS Feeds
channel->title; ?>
channel->item as $item) {
?>
Chapter 8:
Working with XML
pubDate; ?>
description; ?>
This script begins by using SimpleXML’s simplexml_load_file() method to
connect to a remote URL—in this case, an RSS feed hosted by NewsVine.com—and convert
the XML data found therein to a SimpleXML object. It then uses SimpleXML’s ability to
loop over node collections to quickly retrieve each news story’s title, URL, timestamp, and
body; marks these bits of information up with HTML; and prints them to the page.
Figure 8-5 illustrates what the output might look like.
Figure 8-5
Parsing an RSS feed with SimpleXML
269
270
PHP: A Beginner’s Guide
Using PHP’s DOM Extension
Now, while PHP’s SimpleXML extension is easy to use and understand, it’s not very
good for anything other than the most basic XML manipulation. For more complex XML
operations, it’s necessary to look further afield, to PHP’s DOM extension. This extension,
which is also enabled by default in PHP 5, provides a sophisticated toolkit that complies
with the DOM Level 3 standard and brings comprehensive XML parsing capabilities
to PHP.
Working with Elements
The DOM parser works by reading an XML document and creating objects to represent
the different parts of that document. Each of these objects comes with specific methods
and properties, which can be used to manipulate and access information about it. Thus,
the entire XML document is represented as a “tree” of these objects, with the DOM parser
providing a simple API to move between the different branches of the tree.
To illustrate how this works in practice, let’s revisit the address.xml file from the
preceding section:
13 High Street
Oxfordshire
Oxford
OX1 1BA
UK
Here’s a PHP script that uses the DOM extension to parse this file and retrieve the
various components of the address:
preserveWhiteSpace = false;
// read XML file
$doc->load('address.xml');
// get root element
$root = $doc->firstChild;
Chapter 8:
Working with XML
// get text node 'UK'
echo "Country: " . $root->childNodes->item(3)->nodeValue . "\n";
// get text node 'Oxford'
echo "City: " . $root->childNodes->item(2)->childNodes->
item(0)->nodeValue . "\n";
// get text node 'OX1 1BA'
echo "Postal code: " . $root->childNodes->item(2)->childNodes->
item(1)->nodeValue . "\n";
// output: 'Country: UK \n City: Oxford \n Postal code: OX1 1BA'
?>
A quick glance, and it’s clear that we’re not in SimpleXML territory any longer.
With PHP’s DOM extension, the first step is always to initialize an instance of the
DOMDocument object, which represents an XML document. Once this object has been
initialized, it can be used to parse an XML file via its load() method, which accepts
the disk path to the target XML file.
The result of the load() method is a tree containing DOMNode objects, with every
object exposing various properties and methods for accessing its parent, child, and sibling
nodes. For example, every DOMNode object exposes a parentNode property, which can
be used to access its parent node, and a childNodes property, which returns a collection
of its child nodes. In a similar vein, every DOMNode object also exposes nodeName
and nodeValue properties, which can be used to access the node’s name and value
respectively. It’s thus quite easy to navigate from node to node of the tree, retrieving node
values at each stage.
To illustrate the process, consider the preceding script carefully. Once the XML
document has been load()-ed, it calls the DOMDocument object’s firstChild
property, which returns a DOMNode object representing the root element .
This DOMNode object, in turn, has a childNodes property, which returns a collection
of all the child elements of . Individual elements of this collection can be
accessed via their index position using the item() method, with indexing starting from
zero. These elements are again represented as DOMNode objects; as such, their names
and values are therefore accessible via their nodeName and nodeValue properties.
Thus, the element , which is the fourth child element under ,
is accessible via the path $root->childNodes->item(3), and the text value of this
element, 'UK', is accessible via the path $root->childNodes->item(3)->nodeValue.
Similarly, the element , which is the first child of the element, is accessible
via the path $root->childNodes->item(2)->childNodes->item(0), and the
text value 'Oxford' is accessible via the path $root->childNodes->item(2)->
childNodes->item(0)->nodeValue.
271
272
PHP: A Beginner’s Guide
DOMDocument
firstChild
childNodes–> item (0)
childNodes–> item (1)
childNodes–> item (2)
childNodes–> item (0)
childNodes–> item (1)
Figure 8-6
childNodes–> item (3)
DOM relationships
Figure 8-6 should make these relationships clearer, by mapping the XML document
tree from address.xml to the DOM methods and properties used in this section.
Ask the Expert
Q:
When I process an XML document using the DOM, there often appear to be extra
text nodes in each node collection. However, when I access these nodes, they appear
to be empty. What’s going on?
A:
As per the DOM specification, all document whitespace, including carriage returns,
must be treated as a text node. If your XML document contains extra whitespace,
or if your XML elements are neatly formatted and indented on separate lines,
this whitespace will be represented in your node collections as apparently empty
text nodes. In the PHP DOM API, you can disable this behavior by setting the
DOMDocument->preserveWhiteSpace property to 'false', as the examples
in this section do.
An alternative approach—and one that can come in handy when you’re
faced with a deeply nested XML tree—is to use the DOMDocument object’s
getElementsByTagName() method to directly retrieve all elements with a particular
name. The output of this method is a collection of matching DOMNode objects; it’s then
easy to iterate over the collection with a foreach loop and retrieve the value of each node.
Chapter 8:
Working with XML
If your document happens to have only one instance of each element—as is the case
with address.xml—using getElementsByTagName() can serve as an effective shortcut
to the traditional tree navigation approach. Consider the following example, which
produces the same output as the preceding listing using this approach:
preserveWhiteSpace = false;
// read XML file
$doc->load('address.xml');
// get collection of elements
$country = $doc->getElementsByTagName('country');
echo "Country: " . $country->item(0)->nodeValue . "\n";
// get collection of elements
$city = $doc->getElementsByTagName('name');
echo "City: " . $city->item(0)->nodeValue . "\n";
// get collection of elements
$zip = $doc->getElementsByTagName('zip');
echo "Postal code: " . $zip->item(0)->nodeValue . "\n";
// output: 'Country: UK \n City: Oxford \n Postal code: OX1 1BA'
?>
In this example, the getElementsByTagName() method is used to return a
DOMNode collection representing all elements with the name in the first
instance. From the XML document tree, it’s clear that the collection will contain only
one DOMNode object. Accessing the value of this node is then simply a matter of calling
the collection’s item() method with argument 0 (for the first index position) to get the
DOMNode object, and then reading its nodeValue property.
In most cases, however, your XML document will not have only one instance of
each element. Take, for example, the library.xml file you’ve seen in previous sections,
which contains multiple instances of the element. Even in such situations, the
getElementsByTagName() method is useful to quickly and efficiently create a subset
of matching nodes, which can be processed using a PHP loop. To illustrate, consider
273
274
PHP: A Beginner’s Guide
this next example, which reads library.xml and prints the title and author names found
within it:
preserveWhiteSpace = false;
// read XML file
$doc->load('library.xml');
// get collection of elements
// for each , get the value of the and <author> elements
// output: 'The Shining is written by Stephen King. \n ...'
$books = $doc->getElementsByTagName('book');
foreach ($books as $book) {
$title = $book->getElementsByTagName('title')->item(0)->nodeValue;
$author = $book->getElementsByTagName('author')->item(0)->nodeValue;
echo "$title is written by $author.\n";
}
?>
In this case, the first call to getElementsByTagName() returns a collection
representing all the <book> elements from the XML document. It’s then easy to iterate
over this collection with a foreach() loop, processing each DOMNode object and
retrieving the value of the corresponding <title> and <author> elements with further
calls to getElementsByTagName().
TIP
You can return a collection of all the elements in a document by calling
DOMDocument-> getElementsByTagName(*).
To find out how many elements were returned by a call to getElementsByTagName(),
use the resulting collection’s length property. Here’s an example:
<?php
// initialize new DOMDocument
$doc = new DOMDocument();
// disable whitespace-only text nodes
$doc->preserveWhiteSpace = false;
Chapter 8:
Working with XML
// read XML file
$doc->load('library.xml');
// get collection of <book> elements
// return a count of the total number of <book> elements
// output: '8 book(s) found.'
$books = $doc->getElementsByTagName('book');
echo $books->length . ' book(s) found.';
?>
Working with Attributes
The DOM also includes extensive support for attributes: every DOMElement object
comes with a getAttribute() method, which accepts an attribute name and returns the
corresponding value. Here’s an example, which prints each book’s rating and genre from
library.xml:
<?php
// initialize new DOMDocument
$doc = new DOMDocument();
// disable whitespace-only text nodes
$doc->preserveWhiteSpace = false;
// read XML file
$doc->load('library.xml');
// get collection of <book> elements
// for each book
// retrieve and print 'genre' and 'rating' attributes
// output: 'The Shining \n Genre: horror \n Rating: 5 \n\n ...'
$books = $doc->getElementsByTagName('book');
foreach ($books as $book) {
$title = $book->getElementsByTagName('title')->item(0)->nodeValue;
$rating = $book->getAttribute('rating');
$genre = $book->getAttribute('genre');
echo "$title\n";
echo "Genre: $genre\n";
echo "Rating: $rating\n\n";
}
?>
What if you don’t know the attribute name but simply want to process all attributes
of an element? Well, every DOMElement has an attributes property, which returns a
collection of all the element’s attributes. It’s easy to iterate over this collection to retrieve
275
276
PHP: A Beginner’s Guide
each attribute’s name and value. The following example demonstrates, by revising the
preceding script to use this approach:
<?php
// initialize new DOMDocument
$doc = new DOMDocument();
// disable whitespace-only text nodes
$doc->preserveWhiteSpace = false;
// read XML file
$doc->load('library.xml');
// get collection of <book> elements
// for each book
// retrieve and print all attributes
// output: 'The Shining \n id: 1 \n genre: horror \n rating: 5 \n\n ...'
$books = $doc->getElementsByTagName('book');
foreach ($books as $book) {
$title = $book->getElementsByTagName('title')->item(0)->nodeValue;
echo "$title\n";
foreach ($book->attributes as $attr) {
echo "$attr->name: $attr->value \n";
}
echo "\n";
}
?>
Try This 8-4
Recursively Processing an XML
Document Tree
If you plan to work with XML and PHP in the future, this next project will almost
certainly come in handy some day: it’s a simple program that starts at the root of the XML
document tree and works its way through to the ends of its branches, processing every
element and attribute it finds on the way. Given the tree-like nature of an XML document,
the most efficient way to accomplish this task is with a recursive function—and given the
wealth of information supplied by the DOM, writing such a function is quite easy.
Assume for a moment that the XML document to be processed looks like this
(inventory.xml):
<?xml version='1.0'?>
<objects>
<object color="red" shape="square">
Chapter 8:
Working with XML
<length units="cm">5</length>
</object>
<object color="red" shape="circle">
<radius units="px">7</radius>
</object>
<object color="green" shape="triangle">
<base units="in">1</base>
<height units="in">2</height>
</object>
<object color="blue" shape="triangle">
<base units="mm">100</base>
<height units="mm">50</height>
</object>
<object color="yellow" shape="circle">
<radius units="cm">18</radius>
</object>
</objects>
And here’s the PHP code to recursively process this (or any other) XML document
using the DOM:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>Project 8-4: Recursively Processing An XML Document
Project 8-4: Recursively Processing An XML Document
childNodes as $n) {
switch ($n->nodeType) {
// for elements, print element name
case XML_ELEMENT_NODE:
echo "$depthMarker $n->nodeName \n";
// if the element has attributes
// list their names and values
if ($n->attributes->length > 0) {
foreach ($n->attributes as $attr) {
echo "$depthMarker attr : $attr->name => $attr->value \n";
}
}
break;
(continued)
277
278
PHP: A Beginner’s Guide
// for text data, print value
case XML_TEXT_NODE:
echo "$depthMarker text : \"$n->nodeValue\" \n";
break;
}
//
//
//
if
if this node has a further level of sub-nodes
increment depth marker
run recursively
($n->hasChildNodes()) {
xmlProcess($n, $depthMarker . DEPTH_CHAR);
}
}
}
// end function definition
// define the character used for indentation
define ('DEPTH_CHAR', ' ');
// initialize DOMDocument
$doc = new DOMDocument();
// disable whitespace-only text nodes
$doc->preserveWhiteSpace = false;
// read XML file
$doc->load('objects.xml');
// call recursive function with root element
xmlProcess($doc->firstChild, DEPTH_CHAR);
?>
.