Chapter 1

Getting Started on the Server

In This Chapter

Introducing server-side programming

Testing your installation

Inspecting phpinfo( )

Writing HTML with embedded PHP

Understanding various types of quotation

Managing concatenation and interpolation

Using heredocs to simplify coding

Welcome to the server-side programming portion of the book. In this minibook, you discover all the basics of PHP and how you can use PHP to make your pages dynamic and relevant in today's Internet.

In this chapter, you read about getting your server set up and ready to go. I walk you through the process as painlessly as possible, and by the end, you'll be up and running, and ready to serve up your own web pages in a test environment. (I talk about making them available to the rest of the world in Book VIII.)

Introducing Server-Side Programming

I begin with an introduction to server-side programming. This is a bit different than the client-side programming you may have done in JavaScript.

Programming on the server

Server-side programming is what you use to create pages dynamically on the server before sending them to the client. Whereas client-side programming is executed on the client's machine, server-side programming all happens on the server before the web page is even sent to the user.

Client-side programming (as done in JavaScript) does most of the work on the individual user's machine. This has advantages because those machines have doohickeys such as mice and graphics cards. Client-side programs can be interactive in real time.

The client has a big problem, though. Programs written on the client usually have a form of forced amnesia (no long-term memory). For security reasons, client-side applications can't store information in files and can't interact with other programs on the computer. Also, you never know exactly what kind of setup the user has, so you can't really be sure whether your program will work.

This is where server-side programming comes in. In a pure server-side programming environment, all the action happens on the web server. The user thinks she's asking for a web page like normal, but the address really goes to a computer program. The program does some magic and produces a web page. The user sees a web page, perhaps never knowing this wasn't a regular web page, but a page that was produced instead by a program.

A program running on a web server has some really nice advantages, such as

• A server-side program can access the local file system. Asking a server program to load and save files on the server is no problem at all.
• A server-side program can call external programs. This is a very big deal because many web applications are really about working with data. Database programs are very important to modern web development. See Book VI for much more on this.
• All the user sees is ordinary HTML. You can set up your program to do whatever you want, but the output is regular HTML. You don't have to worry about what browser the user has, or whether he has a Mac, or what browser version he's using. Any browser that can display HTML can be used with PHP.

Serving your programs

When using a browser to retrieve web pages, you send a request to a server. The server then looks at the extension (.HTML, .php, .js, and so on) of your requested file and decides what to do. If the server sees .HTML or .js, it says, “Cool. Nothing doing here. Just gotta send her back as is.” When the server sees .php, it says, “Oh, boy. They need PHP to build something here.”

The server takes the page and hollers for PHP to come along and construct the requested web page on the fly. PHP goes through and looks at the programmer's blueprint and then constructs the working page out of HTML.

The server then takes that page from PHP and sends back plain HTML to the client for the browser to display to the user.

When you write PHP programs, a web server must process the form before the browser can see it. To test your PHP programs, you need to have a web server available and place the file in a specific place on your computer for the server to serve it. You can't run a PHP file directly from your desktop. It must be placed in a special place — often, the htdocs or public_html directory under the server.

Picking a language

There are all sorts of different ways to go about dynamically creating web pages with server-side programming. Back in the day when the Internet was still in diapers, people used things like Perl and CGI scripting to handle all their server-side programming. Eventually, people placed more and more demand on their websites, and soon these technologies just weren't enough.

The prevalent languages today are

• ASP.NET: Microsoft's contender
• Java: The heavyweight offering from Sun Microsystems
• Python: Python is becoming a popular alternative, but it has not yet surpassed PHP in popularity as a server-side language.
• PHP: The popular language described in this minibook

ASP.NET

ASP.NET is event-driven, compiled, and object-oriented. ASP.NET replaced the ’90s language ASP in 2002. Microsoft repurposed it for use with the .NET framework to facilitate cross-compatibility with its desktop applications (apps) and integration into Visual Studio (although you can write ASP.NET apps from any text editor). ASP.NET runs on Microsoft's Internet Information Services (IIS) web server, which typically requires more expensive servers than most of the other technologies. Although ASP.NET is an excellent technology, I don't recommend it for cost-conscious users.

Java

Java has been a strong contender for a long time now. The language is indeed named after coffee. If you work for a banking company or insurance company, or need to build the next eBay or Amazon.com, you might want to consider using Java. However, Java can consume a lot of time, and it's hard to figure out. You may have to write up to 16 lines of code to do in Java what could take a mere 4 lines of code in PHP. Java is absolutely free, as is the Apache Tomcat web server that it uses to serve its web components. Java was originally created to write desktop applications and is still very good at doing that. If you're comfortable with C/C++, you'll be very comfortable with Java because it's very similar. It's fully object-oriented and it's compiled. Java is powerful, but it can be challenging for beginners. It'd be a great second language to work with.

Python

The Python language is used in a number of contexts, including server-side programming. Although Python has become much more popular as of late, it still isn't used as frequently as PHP for this purpose.

PHP

PHP was born from a collection of modifications for Perl and has boomed ever since (in a way, replacing Perl, which was once considered the duct tape and bubble gum that held the Internet together).

PHP works great for your server-side web development purposes. Media Wiki (the engine that was written to run the popular Internet encyclopedia Wikipedia) runs on PHP, as do many other popular large-, medium-, and small-scale websites. PHP is a solid, easy-to-learn, well-established language (it was introduced in 1994). PHP can be object-oriented or procedural: You can take your pick. PHP is interpreted rather than compiled.

The current stable version of PHP used in this book is PHP5.5. This might confuse you because there are several references to PHP6 on the Internet. There is indeed a PHP6, but it has been discontinued for several years, with the most important improvements moved to the PHP5 engine. Examples in this book will work on any version of PHP past PHP5.3, which is what's most likely to be on your server.

Installing Your Web Server

For PHP to work usefully, you have to have some other things installed on your computer, such as

• A web server: This special program enables a computer to process files and send them to web browsers. I use Apache because it's free and powerful and works very well with PHP.
• A database backend: Modern websites rely heavily on data, so a program that can manage your data needs is very important. I use MySQL (a free and powerful tool) for this. Book VI is entirely dedicated to creating data with MySQL and some related tools.
• A programming language: Server-side programming relies on a language. I use PHP because it works great and it's free.

There are two main ways to work with a web server:

• Install your own, using the free XAMPP software. Download from www.apachefriends.org/en/xampp.html. Book VIII, Chapter 1 has complete instructions on installing XAMPP.
• Work on a remote server that somebody has already set up. Most low-cost web servers (and even some free ones) support PHP and MySQL right out of the box.

Please check out Book VIII, Chapter 1 for complete information on both techniques. After you have your machine set up or you have an account somewhere with PHP access, come back here. I'll wait.

Inspecting phpinfo()

Using your shiny new server is really quite simple, but a lot of beginners can get confused at this point.

One thing you have to remember is that anything you want the server to serve must be located in the server's file structure. If you have a PHP file on your desktop and you want to view it in your browser, it won't work because it isn't in your server. Although, yes, technically it might be on the same machine as your server (if you're using XAMPP), it is not in the server.

So, to serve a file from the server, it must be located in the htdocs directory of your server install. If you've installed XAMPP, go to the folder where you installed XAMPP (probably either c:/xampp or c:/Program Files/xampp) and locate the htdocs directory. This is where you'll put all your PHP files. Make note of it now.

If you're using a remote server, you'll need to use your host’s file management tools or FTP (both described in Book VIII, Chapter 1) to transfer the file. Often you'll have specially designated folders for placing your web content, usually related to your domain name. You may need to check with your server host to be certain.

To get the hang of placing your files in the correct place and accessing them, create a test file that will display all your PHP, Apache, and MySQL settings.

To test everything, make the PHP version of the famous “Hello World!” program. Follow these steps to make your first PHP program:

1. Open a text editor to create a new file.

   PHP files are essentially plain text files, just like HTML and JavaScript. You can use the same editors to create them.

2. Build a standard web page.

   Generally, your PHP pages start out as standard web pages, using your basic HTML template. However, start with a simpler example, so you can begin with an empty text file.

3. Add a PHP reference.

   Write a tag to indicate PHP. The starting tag looks like <?php, and the ending tag looks like ?>. As far as HTML is concerned, all the PHP code is embedded in a single HTML tag.

4. Write a single line of PHP code.

   You'll learn a lot more PHP soon, but one command is especially useful for testing your configuration to see how it works. Type the line phpinfo();. This powerful command supplies a huge amount of diagnostic information.

5. Save the file to your server.

   A PHP file can't be stored just anywhere. You need to place it under an accessible directory of your web server. If you're running XAMPP, that's the htdocs directory of your xampp directory. If you're running a remote server, you'll need to move the file to that server, either with your host's file transfer mechanism, an FTP program, or automatically through your editor. (See the nearby sidebar “Picking a PHP editor” for information on remote editing in Komodo.)

6. Preview your page in the browser.

   Use your web browser to look at the resulting page. Note that you cannot simply load the file through the file menu or drag it to your browser. If you have XAMPP installed, you need to refer to the file as http://localhost/fileName.php. If the file is on a remote server, use the full address of the file on that server: for example, http://myhost.freehostia.com/fileName.php.

Your code from Steps 3 and 4 should look like this:

  <?php
    phpinfo();
?>

Hmm. Only three lines of code, and it doesn't seem to do much. There's precious little HTML code there. Run it through the browser, though, and you'll see the page shown in Figure 1-1.

If you see the actual PHP code rather than the results shown in Figure 1-1, you probably didn't refer to the page correctly. Please check the following:

• Is the file in the right place? Your file must be in htdocs or on a remote server (or in a subdirectory of these places).
• Did you use the .php extension? The server won't invoke PHP unless the filename has a .php extension.
• Did you refer to the file correctly? If the URL in the address bar reads file://, you bypassed the server, and PHP was not activated. Your address must begin with http://. Either use http://localhost (for a locally stored file in XAMPP) or the URL of your remote hosting service.

This phpinfo page of Figure 1-1 is critical in inspecting your server configuration. It displays all the different settings for your server, describing what version of PHP is running and what modules are active. This can be very useful information.

You generally should not have a page with all the phpinfo() information running on a live server because it tells the bad guys information they might use to do mischief.

This test.php program shows one of the most interesting things about PHP. The program itself is just a few lines long, but when you run it, the result is a complex web page. Take a look at the source of the web page, and you'll see a lot of code that you didn't write. That's the magic of PHP. You write a program, and it creates a web page for you.

Don't panic if you don't understand anything in the page that gets produced with the phpinfo() command. It contains many details about how PHP is configured on your server, which may not mean much now. If you have trouble with PHP and ask me for help, however, it's the first thing I'll ask you for. An experienced developer can do a lot of troubleshooting by looking over a phpinfo so it's a handy skill to know.

The basic flow of PHP programming works like this:

1. You build a standard page, and you include PHP code inside it.
2. When the server recognizes the PHP code, it calls the PHP interpreter and passes that code to it.

PHP programs are almost always designed to create HTML code, which gets passed back to the user. The user will never see PHP code because it will get translated to HTML before it gets to the browser.

By default, Apache will load index.HTML or index.php automatically if you type a directory path into the web browser. If you're using XAMPP, there's already a program in htdocs called index.php. Rename it index.php.off. Now, if you navigate to http://localhost/, you'll see a list of directories and files your server can run, including test.php. When you have a live site, you'll typically name one file index.HTML or index.php so the user doesn't have to type the entire filename. See Book VIII, Chapter 1 for more information on how to set up your server to make it easiest to use.

Building HTML with PHP

In PHP, you aren't actually printing anything to the user. Instead, you're building an HTML document that will be sent to the browser, which will interpret the HTML and then print that (the HTML) to the user. Therefore, all your code gets interpreted twice: first on the server to generate the HTML and then on the user's machine to generate the output display.

If you've used HTML, CSS, and JavaScript, you might have been frustrated because all these environments run on the client, and you have no control of the client environment. You don't know what browser the user will have, and thus you don't know exactly how HTML, CSS, and JavaScript will run there. When you program in PHP, you're working on a machine (the server) that you actually control. You know exactly what the server's capabilities are because (in many cases) you configured it yourself.

It's still not a perfect situation, though, because your PHP code will generate HTML/CSS pages (sometimes even with JavaScript), and those pages still have to contend with the wide array of client environments.

The first program you ever write in any language is invariably the “Hello World!” program or some variant thereof. Follow these steps:

1. Create a new PHP file in your editor.

   I prefer using Komodo Edit because it has great support for PHP and remote file access.

   If you're using some other text editor, just open a plain text file however you normally do that (often File ⇒ New) and be sure to save it under htdocs with a .php extension. If you're using a remote server, transfer your file to that server before testing.

2. Create your standard HTML page.

   PHP code is usually embedded into the context of an HTML page. Begin with your standard HTML template. (See Book I, Chapter 2 for a refresher on HTML.)

3. Enter the following code in the body:

     <?php
   print “<h1>Hello World!</h1>”;
   ?>

   Depending on your installation of Apache, you may be able to use the shorter <? ?> version of the PHP directive (instead of <?php ?>). However, nearly all installations support the <?php ?> version, so that's probably the safest way to go.

   Note that you're not just writing text, but creating an HTML tag. PHP creates HTML. That's a really important idea.

4. Save the file.

   Remember to save directly into htdocs or a subdirectory of htdocs. If you're using a remote server, save remotely to that server (with Komodo) or save it locally and transfer it to the server to view it.

5. View the file in a web browser, as shown in Figure 1-2.

   The address of a web page begins with the http:// protocol and then the server name. If the page is on the local machine, the server name is localhost, which corresponds directly to your htdocs directory. If you have a file named thing.php in the htdocs directory, the address would be http://localhost/thing.php. Likewise, if it's in a subdirectory of htdocs called project, the address would be http://localhost/project/thing.php. If the page is on a remote server, the address will include the server's name, like this:

   http://www.myserver.com/thing.php

So, what is it that you've done here? You've figured out how to use the print statement. This allows you to spit out any text you want to the user.

Note that each line ends with a semicolon (;), just like JavaScript code. PHP (unlike JavaScript) is pretty fussy about semicolons, and if you forget, you're likely to get a really strange error that can be hard to figure out.

For all the other examples in this book, you can look at the program running on the companion website and view the source to see what is happening. That won't work with PHP code because the PHP is converted to HTML by the time it gets to the browser. So on my website, I've provided a special source listing for each PHP program so you can see the code before it is passed through the interpreter.

Coding with Quotation Marks

There are many different ways to use print. The following are all legal ways to print text, but they have subtle differences:

      print ("<p>Hello World!</p>");
    print ("<p>Hello World!<br />
    Hello Computer!</p>");
    print '<p><a href="http://www.google.com">Hello Google!</a></p>';

Any way you cut it, you have to have some form of quotations around text that you want printed. However, PHP is usually used to write HTML code, and HTML code contains a lot of quote marks itself. All those quotations can lead to headaches.

What if you want to print double quotation marks inside a print statement surrounded by double quotation marks? You escape them (you tell PHP to treat them as literal characters, rather than the end of the string) with a backslash, like this:

    print "<a href="link.HTML">A Link</a>";

This can get tedious, so a better solution is discussed in the “Generating output with heredocs” section, later in this chapter.

This backslash technique works only with text encased inside double quotes. Single quotes tell PHP to take everything inside the quotes exactly as is. Double quotes give PHP permission to analyze the text for special characters, like escaped quotes (and variables, which you learn about in the next section of this chapter). Single quotes do not allow for this behavior, which is why they are rarely used in PHP programming.

Working with Variables PHP-Style

Variables are extremely important in any programming language and no less so in PHP.

A variable in PHP always begins with a $.

A PHP variable can be named almost anything. There are some reserved words that you can't name a variable (like print, which already has a meaning in PHP), so if your program isn't working and you can't figure out why, try changing some variable names or looking at the reserved words list (in the online help at www.php.net) to find out whether your variable name is one of these illegal words.

PHP is very forgiving about the type of data in a variable. When you create a variable, you simply put content in it. PHP automatically makes the variable whatever type it needs. This is called loose typing. The same variable can hold numeric data, text, or other more complicated kinds of data. PHP determines the type of data in a variable on the fly by examining the context.

Even though PHP is cavalier about data types, it's important to understand that data is still stored in one of several standard formats based on its type. PHP supports several forms of integers and floating-point numbers. PHP also has great support for text data. Programmers usually don't say “text,” but call text data string data. This is because the internal data representation of text reminded the early programmers of beads on a string. You rarely have to worry about what type of information you're using in PHP, but you do need to know that PHP is quietly converting data into formats that it can use.

Concatenation

Concatenation is the process of joining smaller strings to form a larger string. (See Book IV, Chapter 1 for a description of concatenation as it's applied in JavaScript.) PHP uses the period (·) symbol to concatenate two string values. The following example code returns the phrase oogieboogie:

  $word = "oogie ";
$dance = "boogie";
 
Print $word . $dance

If you already know some JavaScript or another language, most of the ideas transfer, but details can trip you up. JavaScript uses the + sign for concatenation, and PHP uses the period. These are annoying details, but with practice, you'll be able to keep it straight.

When PHP sees a period, it treats the values on either side of the period as strings (text) and concatenates (joins) them. If PHP sees a plus sign, it treats the values on either side of the plus sign as numbers and attempts to perform mathematical addition on them. The operation helps PHP figure out what type of data it's working with.

The following program illustrates the difference between concatenation and addition (see Figure 1-3 for the output):

  <?php
    //from helloVariable.php
    $output = "World!";
    print "<p>Hello " . $output . "</p>";
    print "<p>" . $output + 5 . "</p>";
?>

The previous code takes the variable output with the value World and concatenates it to Hello when printed. Next, it adds the variable output to the number 5. When PHP sees the plus sign, it interprets the values on either side of it as numbers. Because output has no logical numerical value, PHP assigns it the value of 0, which it adds to 5, resulting in the output of <p>5</p> being sent to the browser.

Interpolating variables into text

If you have a bunch of text to print with variables thrown in, it can get a little tedious to use concatenation to add in the variables. Luckily, you don't have to!

With PHP, you can include the variables as follows (see Figure 1-4 for the output):

  <!DOCTYPE html>
<html lang = “en-US”>
 
<head>
  <meta charset = "UTF-8" />
  <title>helloInterpolation</title>
</head>
<body>
<?php
  $firstName = "John";
  $lastName = "Doe";
  print "<p>Hello $firstName $lastName!</p>";
?>
</body>
</html>

This process is called interpolation. Because all PHP variables begin with dollar signs, you can freely put variables right inside your string values, and when PHP sees a variable, it will automatically replace that variable with its value.

Interpolation works only with double-quoted strings because double quotes indicate PHP should process the string before passing it to the user.

Building HTML Output

The output of a PHP program is usually an HTML page. As far as PHP is concerned, HTML is just string data, so your PHP program often has to do a lot of string manipulation. You'll often be writing long chunks of text (HTML code) with several variables (generated by your PHP program) interspersed throughout the code. This type of text (HTML output) will often stretch over several lines, requires carriage returns to be preserved, and often contains special characters like quotes and <> symbols. The ordinary quote symbols are a little tedious if you want to use them to build a web page. Here's an example.

Say you wanted to create a program that could take the value of the $name and $address variables and put them into a table like this:

  <table style = "border: 1px solid black">
   <tr>
    <td>name</td>
    <td>John</td>
  </tr>
  <tr>
    <td>address</td>
    <td>123 Main St.</td>
  </tr>
</table>

There are a few ways to combine the PHP and HTML code as shown in the following sections.

Using double quote interpolation

Using regular double quotes, the code would look something like this:

  $name = "John";
$address = "123 Main St.";
$output = "";
$output .= "<table style = "border: 1px solid black"> ";
$output .= "   <tr> ";
$output .= "    <td>name</td> ";
$output .= "    <td>$name</td> ";
$output .= "  </tr> ";
$output .= "  <tr> ";
$output .= "    <td>address</td> ";
$output .= "    <td>$address</td> ";
$output .= "  </tr> ";
$output .= "</table> ";
 
print $output

However, using quotes to generate HTML output is inconvenient for the following reasons:

• The $output variable must be initialized. Before adding anything to the $output variable, give it an initial null value.
• You must repeatedly concatenate data onto the $output variable. The .= operator allows me to append something to a string variable.
• All quotes must be escaped. Because double quotes indicate the end of the string, all internal double quotes must be preceded with the backslash ().
• Every line must end with a newline ( ) sequence. PHP creates HTML source code. Your PHP-derived code should look as good as what you write by hand, so you need to preserve carriage returns. This means you need to end each line with a newline.
• The HTML syntax is buried inside PHP syntax. The example shows PHP code creating HTML code. Each line contains code from two languages interspersed. This can be disconcerting to a beginning programmer.

Generating output with heredocs

PHP uses a clever solution called heredocs to resolve all these issues. A heredoc is simply a type of multiline quote, usually beginning and ending with the word HERE.

The best way to understand heredocs is to see one in action, so here's the same example written as a heredoc:

  <?php
$name = "John";
$address = "123 Main St.";
print <<<HERE
<table style = "border: 1px solid black">
   <tr>
    <td>name</td>
    <td>$name</td>
  </tr>
  <tr>
    <td>address</td>
    <td>$address</td>
  </tr>
</table>
HERE;
?>

Figure 1-5 illustrates this code in action.

Heredocs have some great advantages:

• All carriage returns are preserved. There's no need to put in any newline characters. Whatever carriage returns are in the original text will stay in the output.
• Heredocs preserve quote symbols. There's also no need to escape your quotes because the double quote is not the end-of-string character for a heredoc.
• Variable interpolation is supported. You can use variable names in a heredoc, just like you do for an ordinary quoted string.
• The contents of a heredoc feel like ordinary HTML. When you're working inside a heredoc, you can temporarily put your mind in HTML mode, but with the ability to interpolate variables.

The following are some things to keep in mind about heredocs:

• A heredoc is opened with three less-than symbols (<<<) followed by a heredoc symbol that will act as a “superquote” (instead of single or double quotation marks, you make your own custom quotation mark from any value that you want).
• A heredoc symbol can be denoted by almost any text, but HERE is the most common delimiter (thus, heredoc). You can make absolutely anything you want serve as a heredoc symbol. You probably should just stick to HERE because that's what other programmers are expecting.
• You need only one semicolon for the whole heredoc. Technically, the entire heredoc counts as one line. That means that the only semicolon you need is after the closing symbol.
• A heredoc must be closed with the same word it was opened with.
• The closing word for the heredoc must be on its own line with no other symbols or spaces, just the word followed by a semicolon.
• You can't indent the closing word for the heredoc; there can't be any spaces or tabs preceding or following the closing word.

By far, the most common problem with heredocs is indenting the closing token. The HERE (or whatever other symbol you're using) must be flush with the left margin of your editor, or PHP won't recognize it. This usually means PHP interprets the rest of your program as part of a big string and never finishes executing it.

Heredocs have one disadvantage: They tend to mess up your formatting because you have to indent heredocs differently than the rest of the code.

When writing a heredoc, don't put a semicolon after the first <<<HERE. Also, don't forget that the last HERE; can't have any whitespace before it — it must be alone on a new line without any spaces preceding it. An editor that understands the heredoc rules highlights all the code inside the heredoc and saves you lots of grief. Komodo does this automatically, as does Aptana (if you've installed the PHP plug-in). Notepad++ also has this feature.

Switching from PHP to HTML

There's one more way to combine PHP and HTML code. The server treats a PHP document mainly as an HTML document. Any code not inside the <?php ?> symbols is treated as HTML, and anything inside the PHP symbols is interpreted as PHP.

This means you can switch in and out of PHP, like the following example:

  <?php
    $name = "John";
    $address = "123 Main St.";
    // switch 'out' of PHP temporarily
?>
<table style = "border: 1px solid black">
   <tr>
    <td>name</td>
    <td><?php print $name; ?></td>
  </tr>
  <tr>
    <td>address</td>
    <td><?php print $address; ?></td>
  </tr>
</table>
<?php
  //I'm back in PHP
?>

This option (switching back and forth) is generally used when you have a lot of HTML code with only a few simple PHP variables. I prefer the heredoc approach, but feel free to experiment and find out what system works for you.