PHP is an excellent choice for Web programming. It has many advantages over other languages, including other Web-oriented languages. To get a very general understanding of how the common Web programming languages compare, let’s compare them.

ASP is Microsoft’s Web programming environment. (It’s not a language itself because it allows the programmer to choose from a few actual languages, such as VBScript or JScript.) ASP is simple, but too simple for programs that use complex logic or algorithms.

TIP

An algorithm is a formula-like method for accomplishing a particular task. Here’s a simple example: Some bank accounts use the last four digits of a person’s Social Security number as his PIN number. An algorithm could be formed to create this PIN number based on the already-known Social Security number.

Besides ASP’s over-simplicity, many companies find it hard to budget for the expense of Microsoft licenses. Without even considering hardware costs, a Microsoft server could cost thousands of dollars in licensing, whereas a comparable Unix-based operating system running PHP could be free.

TIP

Many people new to open source software find the idea of free software hard to believe. However, once you’ve spent some time looking into it, you realize how much open source software makes sense. In addition to open source software being free, it is generally updated and patched more frequently, and it’s usually easy to find help from other users and even from the developers of the software.

You may be interested in visiting http://www.OpenSource.org for more information.

Another language well known for its use on the Web is Sun Microsystems’ Java. Java is praised for being platform-independent (a program written in Java can be run on virtually any computer without having to make any modifications to the program).

NOTE

The term platform means the same thing as operating system. Some examples include Windows, Solaris, Linux, FreeBSD, and NetWare.

Although Java does have its advantages, it has serious downsides in development time, development cost, and execution speed. Java development is time-consuming because projects in Java must follow strict rules (imposed by Java) that require extensive planning. In addition to high development time, the cost is also high because Java developers are expensive to hire. The cost is therefore potentially much higher than it would be if the project were done in another language. Even after the project is built, a program written in Java takes longer to run than one written in one of the other languages to which we’re comparing.

Overall, when compared to Java, PHP comes out with flying colors. It is not unheard of for a Java project to take two or three times the time to develop compared to a similar project in PHP. On top of that, the final program runs on a wide array of platforms (like Java), except the PHP program runs faster.

Another language commonly used for writing Web programs is Perl (practical extraction and report language). Perl, like PHP, is an open-source project developed to run on many platforms. In fact, Perl has been around longer than PHP. Before PHP, Perl was generally accepted as the best Web programming language. However, during the past few years, PHP has earned a reputation for being better than Perl for Web programming because PHP provides a vast number of features as part of PHP itself, whereas you would have to download separate modules to get the same functionality in Perl. This leads to problems when programs are transferred from one system to another because the modules have to be downloaded from Perl’s exhaustive (and confusing) module archive known as CPAN.

The last language to compare PHP to is C. C has been around for a long time; it has been used in a variety of computers, from mainframes to consumer PCs. The problems creating a Web program in C are obvious if you know C. To develop a Web program in C, you have to develop all of the basic functionality of Web programming (such as collecting the data from HTML forms) before you can even begin to think about the actual task at hand. Since PHP provides for all the common (and many uncommon) Web programming tasks, writing such a program in PHP allows the programmer to get straight to the point.

You could write volumes on PHP’s advantages over other programming languages when it comes to Web programming. There are many, many articles on the Internet comparing PHP to Java, Perl, ASP, and others. Once you’ve earned some experience programming in PHP, you might find yourself trying to convince your client or employer to allow you to use it instead of another language. If that problem arises, you should find plenty of helpful information by doing a Web search.

PHP has an unlimited number of uses. The original version was used solely to track who was viewing the creator’s résumé. Over time, however, that simple tracking program evolved into a language of its own.

TIP

If you’re interested in knowing how PHP came to be what it is today, I recommend visiting http://php.net/manual/en/intro-history.php, where you will find a brief history of the language.

PHP’s primary use certainly isn’t to track résumés anymore; it has grown to be able to do that and just about anything else. To giveyou a better idea of what PHP can do, here are some of its common uses:

Feedback forms

Shopping carts and other types of e-commerce systems

User registration, access control, and management for online subscription services

Guest books

Discussion and message boards

When you write a program, your main goal is to translate your idea into a language that the computer can understand. For example, if you were teaching a person how to cook hamburgers, you would first describe the process of forming the ground beef into patties. Then, you would tell the person how to put the burgers on the grill, how long to leave them there, and finally how to remove them.

Of course, just because you can describe the process of making hamburgers doesn’t mean PHP is going to be cooking anything for you anytime soon. The point is, if you can describe a process like I just described making hamburgers, you can write a program.

Writing a PHP program is simply the process of describing to PHP how to do something. By the time you’ve finished reading this book, you will understand all the concepts behind writing a PHP program. Those concepts are like the words and sentences used to describe hamburgers. The more you read this book, the more “words” you will understand, and the better you will be able to “describe” your task to PHP. Thus, you will learn to write PHP programs to suit whatever need or idea you have, and soon it won’t be any more intimidating than telling someone how to cook hamburgers.

Some programming problems might be very complex when examined as a whole. For example, creating a shopping cart is definitely not a simple task. However, a shopping cart can be broken into a few smaller tasks. Those tasks might include adding and removing items, which are both tasks that can break into even smaller tasks. You will find that any task, no matter how complex, can be broken into smaller ones until each task is simple enough that breaking it down further is unnecessary. This process is explained in more detail when you begin creating programs with more complexity (especially in Chapter 17, “Putting It All Together,” when we walk through the whole process of creating a complex program step-by-step).

Unlike creating an HTML page, creating a PHP program requires that you actually work with the source code of the file as opposed to a “what you see is what you get” (WYSIWYG) approach. If you’re used to using a WYSIWYG program (such as Microsoft FrontPage, Macromedia Dream Weaver, or Microsoft Word), it may take you some time to get used to looking at the source code.

The good news is there’s no reason that you can’t continue to use a WYSIWYG editor to create an HTML design for your program. However, you may be disappointed to find that many WYSIWYG editors mangle or even delete vital PHP code from your files. For this reason, it is important to find out how your particular editor handles PHP code. If you want to test your WYSIWYG to see how it handles PHP code, create a new file, naming it with a .php extension. Then, switch to your editor’s source view or open the file in a separate program, such as Notepad and enter the program shown in the first example later in the chapter, making sure not to make any mistakes.

When you’re finished, save the file and switch back to the WYSIWYG editor. If you see your PHP code, work around it and type a few lines of text. If you want, add some common elements that you include in your Web pages, such as tables and images. Save the file again and close all the open editors.

Now, open the file in Notepad and look at the PHP code. Look for any changes, including changes in the way the code is formatted, special characters that have been converted into codes (such as < to <), and code that has been completely removed.

You will probably find that the PHP code has been changed in some way. Because PHP is sensitive to some of the changes a WYSIWYG editor might make, it's almost impossible to use a WYSIWYG editor once you've started adding PHP code. The PHP community won't tell you that using a WYSIWYG editor is a sign of weakness; doing so can speed things up a lot sometimes.

For now, try using a plain-text editor when you're reading and experimenting with the examples in this book. When you're comfortable with that, feel free to try it with whatever editor you want. By that time, you'll be able to recognize code that the editor has mangled, and you'll have an easier time finding what works best for you.

Regardless of how your current editor handles PHP code, if you are using a WYSIWYG editor, I suggest that you use an editor such as Notepad or one of the many free syntax-highlighting editors out there. Using one of these programs will ensure that your code stays just as you typed it (WYSIWYG editors tend to reformat things as they see fit, which isn't desirable when coding PHP). Even if your editor passed the test, if it's not a strictly text-based (not WYSIWYG) editor, you might find yourself running into problems later.

Here is the process you might use in creating and viewing an HTML file:

Create your HTML file (add text, tables, images, or sounds).

Save your HTML file as filename.html.

Use an FTP program to upload your file to the Web server.

Point your browser to the address of the file on your Web server (for example, http://www.example.com/filename.html).

The process you would use to create a PHP program is much the same:

Create your HTML file (containing text, tables, images, or sounds) and insert PHP code where desired.

Save your PHP file as filename.php.

Use an FTP program to upload your file to the Web server.

Point your browser to the address of the file on your Web server (such as http://www.example.com/filename.php).

The process of creating a PHP program isn't much different from the process you follow to create a regular HTML page.

CAUTION

Many FTP servers (primarily those on Unix-based systems) require you to use a certain FTP "mode": either binary (for images, sounds, and other non-ASCII files) or ASCII (for plain-text files, such as HTML, PHP, and TXT).

Although the FTP transfer appears to be successful, a program transferred in binary mode may not run at all. If this happens, you will receive a "500 Internal Error" response from the server.

Now that you've seen the overall process, let's take a look at our first PHP program. After reading the following example, you'll learn what separates it from a normal HTML file, how to upload it to your Web server, and what the page should look like viewed in your browser.

<!-- File: ch01ex01.php -->
<html>
<head><title>PHP By Example :: Chapter 1 :: Example 1</title></head>
<body bgcolor="white" text="black">
<h4>PHP By Example :: Chapter 1 :: Example 1</h4>
<?php
/* Display a text message */

echo "Hello, world! This is my first PHP program.";

?>

</body>
</html>

This file looks a lot like a regular HTML file. Notice that the file has HTML tags typical of those you would find in any HTML file. In fact, if you disregard everything between the tags, you might as well rename this file with an .html extension.

However, this file does contain PHP code, so it must be named with a .php extension. The PHP code lies between the PHP tags () as shown in Figure 1.1. The command between the PHP tags is echo (PHP’s word for “add the following text to the page”) followed by the text to display. The output, which will be shown soon, looks just as if the text after echo had been in an HTML file itself and no PHP code ever existed.

Figure 1.1. This diagram shows the different parts of a basic PHP program.

Before we look at the output, let’s upload this file to a Web server and run it. Follow the process outlined previously to write the program, save it as a PHP file (with a .php extension), and upload it to your Web server.

CAUTION

Don’t forget you shouldn’t be typing the previous code into a WYSIWYG program such as Microsoft Word or FrontPage. If you do, the code will probably show up in your Web browser just as it appeared previously. Instead, use a plain-text editor such as Notepad.

Once your program is uploaded to your Web server, type its address into your browser. You should get a page back that looks very similar to the screenshot in Figure 1.2.

Figure 1.2. This is what you should see in your browser when you go to the address of your new program.

Programming Syntax
When you accessed the program you just uploaded with your browser, the PHP program went through a process before it was returned to the browser. The process performed the PHP commands within the file; in this case, that was a single echo statement. Figure 1.3 shows what happens when a request is made for a PHP file.

Figure 1.3. Unlike HTML files, PHP files are routed through a special process that performs the PHP commands within the file before it is returned.

The PHP interpreter (or parser) is the program that performs the processing mentioned previously. It reads the PHP program file and executes the commands it understands. (If PHP happens to find a command it doesn’t understand, it stops parsing the file and sends an error message back to the browser.)

NOTE

Just as “interpreter” and “parser” are interchangeable terms to refer to the PHP interpreter, “interprets” and “parses” may be used interchangeably to refer to the process PHP performs when it processes a PHP file.

TIP

If you are an administrator for the Web server you’re using, you may be interested in knowing that the executable file you installed (a Windows EXE or DLL, or an Apache module or CGI binary on Unix-based systems) is the PHP interpreter.

Every time a request for a particular PHP file is made to a Web server, the PHP interpreter must process the file prior to returning anything to the browser. Because PHP must interpret a PHP program every time that program runs, it is known as a scripting language.

This is quite different from a compiled language, such as C or C++, which is only interpreted from a human-readable form once; a C program is simply translated into machine code (code that is processed directly by the computer’s processor).

TIP

In a very strict sense, parsing is the process of splitting commands into smaller segments, whereas interpreting is the process of actually comparing those segments to known commands in order to actually perform the correct command.

Since PHP has to interpret the commands included within a program, the commands must be given in such a way that PHP understands them. For example, if someone walked up to you and asked you in German for the time, you probably wouldn’t know what he was talking about (unless you know German or the person pointed to his wrist). Likewise, if I walked up to you and said, “Is time it what?” you probably wouldn’t know what I was talking about, even though I used English words.

PHP has similar limitations. A statement (the construction of commands and certain characters to make a sentence that PHP will understand) must be given using the correct commands. For example, the command show text has no meaning in PHP; you must instead use a command PHP recognizes, such as echo. Also, just as you must put your words in the correct order to talk to another person in English, you must format the statements you give PHP so that they follow the format PHP expects.

Syntax, then, is the process of putting together statements that PHP will be able to interpret and carry out. Examples of this are PHP’s opening and closing tags. PHP only parses code that is between PHP tags. Anything else in the file is returned as part of the HTML page, just as seen earlier in the first example.

Here’s another example. The following statement does not work, even though the command is part of PHP’s language:

echo "This won't work."

The statement won’t work because it doesn’t follow a basic syntax rule that requires all statements to be terminated with a semicolon. Some special statements must have the semicolon left out, but not many. (The ones that do will be pointed out as we come to them.) For now, just remember that statements should end with a semicolon. The following statement is a corrected version of the preceding line of code:

echo "This works!";

You may notice that leaving the semicolon off a single statement doesn’t cause PHP to display an error message. This is a feature of PHP to make it easier to insert a single echo statement. To see the error when you try to run the first echo statement, copy the statement to two separate lines so it looks like this:

echo "This won't work."
echo "This won't work."

The code will not run and PHP will return an error because there isn’t a semicolon separating the statements.

Good Style: Using Whitespace and Comments
You may be curious why PHP requires a semicolon at the end of every statement. The answer is that semicolons allow other aspects of PHP code to be more flexible. By signaling the end of a command with a semicolon instead of a new line, new lines can be added or taken out of the code without affecting the code itself. In fact, new lines are only a portion of what can be changed without changing what the interpreter sees when it processes the file.

Whitespace— all spaces, tabs, and line breaks—is left to be used at the discretion and preference of the programmer. This may seem trivial at first, but think about the difference the indentation in an outline makes; the indentation divides topics into subtopics and even subtopics under the subtopics into separate sections. Take a look at the following example, which contains no whitespace.

<?php
/* ch01ex02.php – an example of code with no whitespace */
echo"Hithere.";echo"Thisprogramhasnowhitespace";echo"It'salmostimpossibletoread.";
?>

NOTE

Although the line with all of the echo statements contains no whitespace, the program file as a whole does. The line breaks have been left to separate the PHP tags, the comment, and all the echo statements so at least the purpose of the program is easily decipherable.

You can see how hard it would be to read line after line of code like that. This code should be split into separate lines, with one for each echo statement.

By placing curiouscode on the same line, a new line, or a few blank lines apart, a programmer can group certain parts of his code together and separate other parts. This helps him keep up with how he divided a certain task into smaller, simpler tasks.

Spaces or tabs can be used in PHP to create the same kind of clarity and organization found in an outline as mentioned before. The following example demonstrates this principle:

<?php
/* ch01ex03.php – program to show usefulness of indenting */

if ($gotPHP) {
echo "Got PHP?";

if ($PHPMustache) {
echo " :)";
}
}

?>

Even though you haven’t really learned anything about the statements this program uses, you can easily see how everything follows a form similar to that of an outline. Also, the separation of

echo "Got PHP?";

and

if ($PHPMustache) {

by a blank line signifies that the statements serve two different purposes.

As you curiousread this book, keep whitespace in mind. Think about what makes code easy to understand or hard to understand. Read the statements in each example as it is presented and then go back and look at how it’s formatted. Good style in coding PHP is just as important as knowing the syntax; if your code is formatted into logical sets of statements, no one will have to break it down on his own as he reads it.

The other curiousvery useful element of style is commenting. Comments are descriptions, notes, and other information enclosed in a special character sequence that tells the parser to ignore whatever is within. Therefore, comments are treated the same way as whitespace; they are completely ignored by PHP.

Comments can be done either of two ways: single line or multiline. The one you pick depends on what you want to comment out. The following example is a file header using multiline comments that might be found in a PHP program file:

<?php
/*
All this is comments+-------------------------------------------------+ */

echo "This is Example_Program 1.0";

?>

As demonstrated in this example, to create a multiline comment, the programmer must enclose all of his comment text within /* and */.

TIP

Multiline comments can be used to comment out a block of code you don’t want PHP to evaluate. Simply place a /* before the code and a */ after the code and PHP will ignore it.

The other comments that are available are single-line comments. These comments are used to comment out everything from the comment marker, which is //, to the end of the line.

CAUTION

Although single-line comments may appear within a block of commented-out code, multiline comments are not allowed within multiline comments. Doing so would cause PHP to stop ignoring the commented text immediately after the first */ instead of after the second one, as the programmer intends.

You can find a few different examples of single line comments in the following code:

<?php
// File: example_file.php

echo "This is an example file!"; // Show some text

/* Don't plead insanity anymore

// Plead insanity
echo "This program did not consciously commit the crime, therefore it pleads insanity.";
*/

?>

The first comment found is a very short file header that tells the file’s name. Following it there is a comment describing the action taken by the first echo command. Comments such as this can help clarify things, but use them with discretion. The comment has no good use in this case because it doesn’t say anything we can’t pick up directly from the statement. Generally, use a comment if you (or someone else who might read your code) don’t immediately understand the code when you look at it.

Following that we have a multiline comment that is commenting out a block of code that we wanted to stop from being processed by PHP. PHP will therefore ignore the last echo statement. Notice that it’s perfectly legal to have a single-line comment within multiline comments.

Take note of how comments are used and make use of them in your own code. It’s much easier to read a comment and know what something does rather than having to read the code and figure it out step-by-step. With that in mind, use comments liberally to explain what your programs are doing.

How Embedded Programming Works
Before now, I’ve only mentioned that PHP code must be enclosed in the PHP tags. Using tags to separate PHP code and HTML code within the same file allows programming code to be mixed directly with information that is going to be sent to the browser just as it is. This makes PHP an embedded programming language because PHP code is embedded directly in HTML code.

This concept is relatively new: Before languages like PHP, programs had no real need to display data using a structured formatting language as complex as HTML. Information displayed on the screen was usually just letters, numbers, and spaces, without many colors, sizes, or other formatting markups.

Since PHP was made for Web programming, it is intended to be used with HTML, which significantly increases the amount of information that has to be sent back to the browser. Not only does PHP have to send back the information the user sees, but also the markup tags required to format the information correctly.

To make the mixing of information and markup tags simpler, PHP code is embedded directly in the HTML page where the information is desired. The example at the beginning of this chapter demonstrates this concept quite clearly; the program is mostly regular HTML code, but PHP is also used to insert some information.

Embedded programming will make your job as a programmer much easier; you can add programming where you need it and use regular HTML the rest of the time. However, be sure to enclose your PHP code in PHP tags or your code will not be parsed, but rather displayed on the HTML page.

The following program provides another example of embedded programming:

<?php
/* File: hello_world.php – displays "Hello, World!" */
?>

<html>
<head><title>Hello, World!</title></head>
<body bgcolor="white" text="black">

Hello,
<?php
// Send "World!" to the visitor's browser
echo "World!";
?>

</body>
</html>

When this file is accessed through a Web server, the PHP interpreter will process the file line by line from the top to bottom. Thus, the information before the opening PHP tag is sent to the browser, along with the result of the echo statement. The Web browser receives an HTML file that looks like this:

<html>
<head><title>Hello, World!</title></head>
<body bgcolor="white" text="black">

Hello, World!

</body>
</html>

The browser then displays the file just as it would any other HTML file.

TIP

As mentioned before, a single echo statement doesn’t have to be terminated with a semicolon to be understood by PHP. However, you may want to come back and add more statements later. For this reason, it’s a good idea to consistently include the semicolon, regardless of its necessity.

However, a few languages are processed by the browser after it receives the page. This is called client-side processing. The most common example of this is JavaScript.

TIP

Despite the similarity in their names, Java and JavaScript are far from being the same. Many Web developers are familiar with JavaScript, but this does not make them Java programmers. It’s important to remember that these languages are not the same.

This can lead to an interesting problem with logic. The following example demonstrates what I mean:

<script language="JavaScript">

if (testCondition())
{
<?php
echo "<b>The condition was true!</b>";
?>
} else {
<?php
echo "<b>The condition was not true.</b>";
?>
}

</script>

Many times the programmer of such a segment expects only one of the echo statements to execute. However, both will execute, and the page will be left with JavaScript that will generate errors (because the information in the echo statements is not valid JavaScript code). If this is a little unclear, read on; the following demonstration should clear things up for you.

NOTE

If you’re not familiar with JavaScript, don’t worry. The important concept behind this discussion is that PHP, being a server-side language, will be evaluated before the JavaScript, which is a client-side language. This won’t be an issue if you don’t use a client-side scripting language like JavaScript.

The resulting code from the previous snippet follows; notice that the JavaScript has been left intact and untouched, but the PHP code has been evaluated. PHP ignores the JavaScript code completely:

<script language="JavaScript">

if (testCondition())
{
<b>The condition was true!</b>
} else {
<b>The condition was not true.</b>
}

</script>

As you can see, this code will cause JavaScript errors when executed. Be cautious when combining PHP and JavaScript code: It can be done, but it must be done with attention to the fact that the PHP will always be evaluated without regard for the JavaScript. To successfully combine the two, it’s generally necessary to output JavaScript code with PHP.

The following example does just that:

<script language="JavaScript">

if (testCondition())
{
<?php
echo "document.write('<b>The condition was true!</b>');";
?>
} else {
<?php
echo "document.write('<b>The condition was not true.</b>');";
?>
}

</script>

As you can see, doing this gets complicated very quickly, so it’s best to avoid combining PHP and JavaScript. However, the resulting code below shows you that this will work.

<script language="JavaScript">

if (testCondition())
{
document.write('<b>The condition was true!</b>');
} else {
document.write('<b>The condition was not true.</b>');
}

</script>

If your program doesn’t display “Hello, World!” in your browser, go through the next section and try to eliminate reasons why the program might not run.

TIP

A good directory structure should use general categories and narrow those categories through subdirectories. Such a directory structure, if followed consistently, will keep you from ever searching for a file. You will be able to find a file in less than thirty seconds every time.

Mirroring your directory structure on your Web server is also a good sign of organization. The idea is to create a “web root” folder on your hard drive and have it mirror the root public directory on your Web server. Doing this enables you to transfer a copy of your whole Web site between your server and hard drive without worrying about the files being organized differently.

What If It Didn’t Work?
There are quite a few things that could be going wrong, but this section provides a comprehensive list of reasons why your program may not be running. The following is a list of things that might have gone wrong; find the one that describes the behavior of your problem and jump ahead to the appropriate heading.

A Save As dialog box appears.

The page comes up, but the PHP code doesn’t appear to have executed.

The PHP code appears directly in the browser.

A “404 File Not Found” or a “CGI Error—The specified CGI application misbehaved by not returning a complete set of HTTP headers” message appears.

A “Parse error” message appears.

A Save As Dialog Box Appears
If this occurs, PHP is not installed correctly or the file is misnamed. It occurs because the Web server doesn’t recognize the file as a PHP file, but rather as an unknown file type. Since most unknown file types (Zip files, for example) are to be downloaded and not processed, the server is sending the file just as it is to be downloaded by the browser. This surely isn’t the behavior we want.

To fix this, first check to make sure you named your file with a .php extension. If you didn’t, rename it with the Rename command in your FTP client. If you chose to rename the copy on your local hard drive, make sure you transfer the file to the server. Try accessing the page again and see if the problem is solved; if not, repeat the process with .php3, .php4, and .phtml.

It is very possible that none of those will work. In that case, the problem is most likely that your Web server doesn’t have PHP installed or PHP is configured incorrectly. Get in touch with the server administrator to find out if PHP is installed, and, if so, what the correct extension is. If the extension is one that you’ve already tried, explain to the administrators that the extension isn’t working and see if they can help you find out why.

If you are your server administrator, you may need help with checking your configuration; first check the PHP manual (http://www.PHP.net/manual/). If you still have trouble, you may find help on the PHP installation mailing list. Send an email to php-install@lists.php.net including information about your server such as operating system, Web server, and the version of PHP you’re trying to install. The list members will be happy to help.

The PHP Code Doesn’t Appear to Have Executed
If this is the case, you will see only the parts of the page that were outside of the PHP tags. Specifically, you will see “Hello,” printed on the page, but “World!” will be missing. If you use your browser’s View Source command, you will notice that the PHP code appears in your HTML source just like it did in your editor. This means that the file was returned just like a normal HTML file (without any server-side processing).

Check to make sure that your file is named with an appropriate extension (such as .php); this is the most common reason the PHP code wouldn’t execute.

If that fails, read through the section describing what to do if the Save As dialog box appeared; the problem must be that .php isn’t associated with PHP in the Web server’s configuration. That section will help you straighten out your Web server’s configuration.

The PHP Code Appears Directly in the Browser
This is because you entered the code into a WYSIWYG editor such as FrontPage or DreamWeaver. As you entered the code, the editor converted key parts of it (such as the

To correct this, enter the code in a text-only editor, such as Notepad or PHPEd. (See Appendix A for more information about editors.)

A “404 File Not Found” or “CGI Error” Message Appears
The first of these may seem obvious, but it’s not always so obvious if you use Notepad to create your PHP file. One of the problems with using Notepad is its preference for .txt extensions; even if you give your file a .php extension, Notepad adds a .txt.

When the Web server tries to find the .php file you requested, the file isn’t there because it’s really named .php.txt. In most cases, the server would then return a “404 File Not Found” error, but if PHP is installed as a CGI filter, you might get the latter message about incomplete HTTP headers being returned.

In either case, rename the file to .php and try again.

A “Parse Error” Message Appears
This message, mentioned briefly before, means PHP doesn’t know how to interpret something inside of the PHP tags. This isn’t at all uncommon.

For the example shown previously, it probably means you mistyped something. Go back and check to make sure the files match exactly, line for line. Check to ensure that the same quotes are used (double quotes are not the same as two single quotes).

The parse error will be accompanied by a helpful message explaining exactly why your program isn’t running. Check the line that PHP mentions for possible errors, and then check the lines around it.

In the next chapter, you will begin with discussions of variables, variable types, and constants. With this new knowledge, you will be able to store any information you want in the computer’s memory in order to manipulate it and send the results back to the browser, which we will discuss in the coming chapters.

Thus, you have seen one basic use for variables and constants. Any data that a program works with is stored in variables and constants. So, as we explore the way your program will work with data in this chapter and the chapters ahead, we’ll start with variables and constants, the storage units for all data.

This chapter teaches you the following:

How to declare variables and constants

Naming techniques

Types and type casting

Scope

References

For example, take a look at an echo statement found in Chapter 1, “Welcome to PHP”:

echo "World!";

This statement performs the echo command (which we know inserts text) using the literal value given after it (”World!”).

NOTE

A literal is a value that you give explicitly within a program. For example, 5, 5.5, and “World!” are all literals.

The point of a program isn’t to say “World!” all the time. That could be accomplished with a regular HTML page. The whole point of writing a program is to have a uniform task performed with whatever information is specified. For example, you might want it to be able to say “Earth” instead of “World.”

Let’s consider what you’re planning to do. You know the program should output something, either way. Thus, you know you want the program to do something like this:

echo something;

You just don’t know what something is. To specify what something is, use a variable. A variable is a name that represents a value. The value of a variable may change throughout a program, or it may stay the same once it’s set.

For example, you might use a variable called $strText to insert whatever text is being used for a particular execution of the program.

NOTE

The name $strText is preceded by a dollar sign because that’s how PHP recognizes it as a variable.

Also, if you’re curious, the str prefix is an abbreviation for “string” (the type of data will be character string); it’s purpose is a matter of style, only.

Don’t worry about it right now; we’ll discuss data types and style conventions related to variables later in this chapter.

The following program uses the variable $strText, instead of a literal:

TIP

For now, don't be too distracted by the line that says:

$strText = $HTTP_GET_VARS['strText'];

This statement takes whatever value is specified in the URL and stores it in $strText; since it’s more related to program input, we won’t discuss it further until Chapter 3, “Program Input and Output (I/O).”

Try running this program with the following URLs (replacing www.example.com/path/ with the appropriate address for this program):

http://www.example.com/path/ch02ex01.php?strText=World

http://www.example.com/path/ch02ex01.php?strText=Earth

http://www.example.com/path/ch02ex01.php?strText=PHP%20Programmer

The output changes each time you run the program, depending on what URL you specify. Although this program is very basic, it shows the definite usefulness of variables.

TIP

The URLs shown aren’t as complex as they might seem; we’ll pick these apart and discuss them in Chapter 3. For now, notice that in each URL, a different value is specified for strText, and when you enter each URL, the program displays the corresponding value.

It is important to note that although variables and constants serve the same purpose, they aren’t at all identical.

Whereas, the value of a variable might change any number of times throughout the execution of a program, constants are values that will never change (and in fact can’t change) during the execution of the program.

Constants are often used to set program options. For instance, a constant named DEBUG might be used to determine how much information should be given to the visitor if something goes wrong—either a simple error message to tell the visitor there’s a problem or a detailed error message to help the programmer resolve problems within the script.

Declaring Variables
Declaring a variable is quite simple—all you have to do is assign something to it. If, for example, you wish to assign the number five to a variable named $intFive, you would use the following:

$intFive = 5;

The dollar sign in the variable name isn’t part of the variable name, per se. Instead, it’s how PHP knows you’re referring to a variable named intFive. Whenever you use a variable, you must precede it with a dollar sign.

Variable names in PHP must follow the following requirements:

Any combination of letters, numbers, and underscores can be used.

Names can be as short as one character and can be of any length.

Names can begin only with a letter or an underscore; variable names cannot begin with a number.

As you already know, just because PHP understands a variable following the requirements seen previously doesn’t mean you and the people who read your code will. To improve style, variables should be named according to these style guidelines:

Keep variable names meaningful. For example, don’t use $x to store a visitor’s age; instead, use $intVisitor_age.

If you come back to make changes or fixes in your program a month from when you first write it, you will be confused with variable names like $x because $x doesn’t mean anything, whereas $intVisitor_age says exactly what it contains.

Variable names should be reasonably short. Typing a 25-character variable name just a few times will become a bit tedious and frustrating. Try abbreviating; just be sure your abbreviation makes sense.

For example, instead of $strWebPageFormFieldForEmailAddress, it would obviously be just as clear if it were named $strVisitor_Email.

Prefix a variable type abbreviation to the variable name. Although variable types are explained a little later in the chapter, you should recognize now that the variables suggested so far in this list have been preceded by int or str.

All variables should be prefixed as follows: int for integers, flt or dbl for floating-point numbers or doubles, str for strings, and arr for arrays.

Format your variable names in a hierarchical fashion, separating major divisions with underscores. For example, if you have a visitor’s first name, last name, and e-mail address, it’s better to use $strVisitor_first, $strVisitor_last, and $strVisitor_email instead of $strFirstName, $strLastName, and $strEmail because you may find later in the script that you want to refer to another e-mail address or another person’s name. Although the underscore-divided names are a little bit longer, it’s worth it to keep conflicts and confusion from arising later in the script. You don’t want to find yourself asking, “Whose e-mail do I have in $strEmail?”

Following these conventions makes your programs easier to understand to anyone that has to work with them, especially you.

Assigning Variables
There are two ways a variable can be assigned: in the script itself, or by the PHP interpreter. For now, let’s focus on variables that are created (declared and assigned) by the script itself. Variables assigned automatically by the PHP interpreter (such as the $HTTP_GET_VARS variable found in the first example of this chapter), will be discussed in Chapter 3.

Assignment, as you’ve already learned, occurs when a value is stored in a variable. Whenever you assign a value to a variable, you must keep in mind the order in which the assignment will be processed. For example, the following two statements are not equivalent:

$intFive = 5;
5 = $intFive;

As a rule of thumb, read assignments from right to left—the first would read, “the number 5 should be assigned to the variable $intFive.” Reading assignments in this fashion will become more and more important as your programs and statements grow in complexity.

Now, take a look at the second assignment—”the variable $intFive should be assigned to the number 5.” The latter doesn’t make sense; it will definitely not work. In fact, if you were to use this statement in a program, PHP would stop with a parse error.

Declaring a Constant
Declaring a constant is done using the define function (more will be discussed about functions in Chapter 11, “Classes and Objects”). The following example demonstrates the declaration of a constant, EXAMPLE, with a value of 5:

Notice that EXAMPLE is not preceded by a dollar sign in either statement. The dollar sign is reserved for use only with variables; constants should never be preceded by a dollar sign.

Just as variables have naming requirements that must be followed, so do constants. The following guidelines will ensure that you always use a valid name for a constant:

A constant’s name should not be preceded by a dollar sign.

The name should begin with a letter or underscore, but never a number.

Constants cannot be redefined; that is, the value of EXAMPLE cannot be changed after it has already been defined. After all, that’s why it’s defined as a constant instead of a variable.

As with variables, constants should also be subject to naming conventions for clarity and good style. Adhered to consistently, the following guidelines improve the style of your code:

Keep names short enough to be convenient. This rule is followed less strictly than most; because constants are generally only used for setting options, they aren’t usually mentioned as frequently as variables. Therefore, it’s generally acceptable to make a constant’s name longer.

Constants should always be named using all uppercase. This helps distinguish that you’re intentionally using the word without quotes. Thus, as soon as you see a word in your program written in all caps, you know you can probably look for a constant being defined with that name.

Separate words with underscores. Since constants don’t have the ability to switch case (capitalizing the first letter of every word and using lowercase for the rest), underscores are necessary to keep the separate words in a name easily distinguishable.

Name constants in a hierarchical fashion. As with variables, if you have several constants that are related in some way (they all describe the program, for instance), it would be good to prefix them with PROGRAM. Thus, you’ll end up with PROGRAM_VERSION, PROGRAM_AUTHOR, and PROGRAM_LAST_UPDATE, which are a lot less ambiguous than VERSION, AUTHOR, and LAST_UPDATE, which could describe a number of different things.

Also, by using a hierarchical form (as opposed to just separating words, which would lead to names like PROGRAM_VERSION and LAST_PROGRAM_UPDATE), the constants are grouped into a related set. Because they all begin with PROGRAM_, we know they’re related. If, however, we used a name such as LAST_PROGRAM_UPDATE, although it is clear, we don’t know just from looking at it that it is related to the other two constants.

NOTE

Although a variable type prefix is very useful in variables, it isn’t necessary in constants. The purpose and type of a constant never change (and can’t change), so it’s safe to assume that a variable is whatever type it is defined to be when it’s first defined.

TIP

It’s a good idea to define all constants at the beginning of your program. If you get halfway through and need to define another constant, scroll back up and put it at the top of the file instead of just putting it wherever you currently are in the program. This will make it much easier to find out what the value of the constant is; looking through hundreds of lines of code in multiple files is quite a task if constants aren’t defined at the top of the program.

Deciding Whether to Use a Variable or Constant
If you find wondering whether to use a variable or a constant, think about how the information will be needed within the program.

If the value might be modified sometime during the program’s execution, always use a variable. Using a constant completely prevents the value being modified.

Conversely, if you want to intentionally keep a value from being modified, use a constant. This is a built-in feature of the language so you can protect certain values from accidentally being changed, either by you or by another programmer who isn’t as familiar with your program.

If you’re not sure whether to use a variable or a constant, use a variable. If you use a variable where a constant might have been a better choice, it’s not really a big problem; however, if you use a constant where a variable would have been better, changing it to a variable throughout the script can give you quite a headache.

Related:

More PHP Tutorials

PHP recognizes a value as belonging to a certain data type depending on the characteristics of the value. The following sections describe certain characteristics and behaviors for each data type.

Integers
An integer is any numeric value that does not have a decimal point, such as the following:

5 (five)

–5 (negative five)

0123 (preceded by a zero; octal representation of decimal number 83)

0×12 (preceded by 0x; hexadecimal representation of decimal number 18)

The last two values on the list are somewhat advanced topics and are rare. They are presented for your information so you know what you’re dealing with if you ever encounter this notation. It is important, however, for you to know that preceding a number with a zero (which may seem insignificant) is going to produce unexpected results. The previous example, for instance, proves this point: 123 is much different than 83 (which is 0123 octal).

NOTE

PHP does have limitations within the integer type. On 32-bit platforms, integers are limited to be 32-bit numbers (–2,147,483,648 to 2,147,483,648); on 64-bit platforms integers are limited to be 64-bit numbers (–9,223,372,036,854,775,808 to 9,223,372,036,854,775,808). This generally doesn’t become a problem, but if you attempt to handle extremely large values (negative or positive), you might find that results aren’t as expected. This is a limitation of all programming languages and there is information on the PHP Web site for using larger numbers, should you have the need.

Floating-Point Numbers
A floating-point number (commonly referred to simply as a float or double, which, in PHP, are exactly the same thing) is a numeric value with a decimal point.

The following are all floating-point values:

5.5

.055e2 (scientific notation for .055 times 10 to the second power, which is 5.5)

19.99

The second example is a float represented in scientific notation. The e, as is often the case on graphing calculators, means “times 10 to the”. It is followed by whatever power 10 should be raised to in order to put the decimal wherever you want it. Thus, .055e2 is the same as .055 times 100, which is 5.5.

Floats also have limitations—floats are accurate enough for general-purpose use, but if you need to store a number with an extremely long decimal value, you will need to look into the arbitrary precision math functions (BCMath or GMP) on the PHP Web site.

Also, because of these limitations, you must realize that a float isn’t always exactly what you think it is. For example, 1/3 can only be represented as .33333333… in the computer’s memory; the 3’s repeat forever, so it’s impossible to be completely accurate. It’s best to decide on how much precision you desire (for instance, if dealing with money, you’d choose 2 decimal places) and keep in mind that your decimals are no more accurate than that. Thus, you will reduce your chances for strange results when doing calculations (which is discussed in Chapter 4, “Arithmetic”).

Arrays
Arrays are a little different than the numeric data types discussed so far. Arrays can be thought of as lists of variables, all contained within one variable. These variables can contain values of any data type, including being arrays themselves. For example, if five people are involved in a task, their names could be stored in a five-element array, with one element for each person. The people on the task, represented collectively by the array, would each have their information stored in separate variables within the array.

Array Indexing
The names could then be retrieved using array indexing—adding a subscript (or location within the array) to the end of an array’s name to retrieve the value of that element. (An element is a single variable contained within an array.)

The following example demonstrates the construction of an array containing five names, then printing each name on a separate line:

<?php
/* ch02ex03.php – demonstration of arrays */

$namesArray = Array('Joe', 'Bob', 'Sarah', 'Bill', 'Suzy');

echo "$namesArray[0]
";
echo "$namesArray[1]
";
echo "$namesArray[2]
";
echo "$namesArray[3]
";
echo "$namesArray[4]
";

?>

NOTE

The
tags are given here to separate each element of the array on a separate line.

It’s important to notice that the first element of an array is given by the subscript 0 and not 1. While this may seem awkward, it is fairly common in programming languages because of the way arrays are handled in memory.

TIP

Why is the first index of an array always 0? In many languages, namely C (because most of the other languages that do it are based off C), there’s a very good reason. An array would be given an area of memory when it was created, and in that area of memory, the array’s elements are stored in order. The array name only contains the address of the first element of the array. Thus, the index given would be the offset from the address; that is, the index shows how many positions to move ahead in memory.

So, the first element of the array would be indexed at its address plus 0, the second would be indexed at the address of the first plus 1, and so on. This behavior has made its way into most of today’s languages.

Arrays can be constructed as shown previously, or alternatively by assigning a value to a new element, which can either be automatically added to the end or inserted at an explicitly specified index within the array.

The following example demonstrates the use of empty brackets after an array to add new elements and also explicitly defines a certain element in an array:

$namesArray = Array('Joe', 'Bob', 'Sarah', 'Bill', 'Suzy');
$namesArray[] = 'Rachel'; // adds 'Rachel' as $namesArray[5]
$namesArray[3] = 'John'; // replaces 'Bill' with 'John'

Generally, the Array() function is used to create an array for which all values are hard-coded; the empty brackets construct is used when the array will have an unknown number of variables added to it; and the specific subscript method is used whenever a specific value needs to be accessed or changed.

Strings
Strings are values that contain text—anything from one character to a whole string of characters (hence the name). For example, a sentence such as “This is a string” is a string value.

There are two types of strings: those that are single-quoted and those that are double-quoted.

Single-quoted strings are always interpreted just as they are. For example, to use “My variable is called $myVariable” as a string, use the statement found in the following example:

<?php
/* ch02ex04.php – shows use of single-quoted strings */

echo 'My variable is called $myVariable';

?>

The output from this example is

My variable is called $myVariable

As you may have noticed from the echo statements found earlier in this chapter, double-quoted strings are interpreted so that variables are expanded before they are actually stored as a value. Consider the following example:

<?php
/* ch02ex05.php – shows use of double-quoted strings */
// Do single-quote assignment and output result
$myVariable = 'My variable is called $myVariable';
echo $myVariable;

// Move to new line
echo '
';

// Do double-quote assignment and output result
$myVariable = "My variable is called $myVariable";echo $myVariable;

?>

The output from this example is

My variable is called $myVariable
My variable is called My variable is called $myVariable

The first assignment works just as the single-quoted assignment earlier: The text is assigned just as you see it. Thus, the first line of output shows the string just as it appears in the code.

However, the second assignment uses a double-quoted string, so the string is interpreted before it is stored in the variable. Thus, $myVariable is expanded using its current value (that of the first assignment), and then the new value is stored in the variable, yielding the string found on the second line of output.

Character Escaping
Some characters, such as the dollar sign, have special meaning within strings. In addition, sometimes you need to include quotes within your strings, which would typically signal the end of the string.

To avoid this, we use character escaping, which tells PHP to interpret a character as a literal part of the string instead of a special character (one that would signal a variable or the end of a string).

To escape a character, precede it with a backslash, like this:

\char

Here, char is any single character, such as a dollar sign or quote.

The following example uses character escaping to include $strSmall’s name and its contents surrounded by quotes inside the string $strBig:

<?php
/* ch02ex06.php – demonstrates character escaping */
$strSmall = "John Smith";

$strBig = "The name stored in \$strSmall is \"$strSmall\".";
echo $strBig;

?>

Take time to study the assignment of $strBig, as it demonstrates both the escaping of the dollar sign and of quote characters, both of which are interpreted literally as part of the string when encountered in their escaped form.

Thus, the output of the above program is

The name stored in $strSmall is “John Smith”.

String Indexing
Strings have an indexing feature that makes them much like an array of letters. To find the letter at a given position, use the following syntax:

$string{index}

Here, $string should be any string variable and index should be a position within that string for which you want the letter.

For example, take a look at the following program:


<?php
/* ch02ex07.php – demonstrates string indexing */

// Assign a name to $strName
$strName = "Walter Smith";

// Output the fifth letter of the name
echo $strName{4};

?>

NOTE

The index for the fifth letter is actually 4 because indexing of strings, like that of arrays, begins with 0.

Objects
Objects are a powerful method of program organization. They are essentially what people are talking about when they refer to OOP or Object-Oriented Programming. Objects (and their definitions, called classes) are discussed in depth in Chapter 12, “Using Include Files (Local and Remote).”