A text file

Assuming you have your server setup as described before, create a text file C:\mywebstuff\htdocs\php-tutorial\file.txt with the following contents:

this is text file
second line of text
and a third

File info

Now let's test a few functions that return information about a file. The functions in question are:

• file_exists() - returns TRUE is the file exists
• filesize() - returns the file size in bytes
• is_dir() - returns TRUE when given a directory
• is_file() - returns TRUE when given a file
• filemtime() - returns a timestamp of when the file was modified
• realpath() - returns the actual path on the machine

Let's see an example - populating an array of file info using those functions.

$file = 'file.txt';

$fileinfo = array(
    'file_exists()' => file_exists($file),
    'filesize()'    => filesize($file),
    'is_dir()'      => is_dir($file),
    'is_file()'     => is_file($file),
    'filemtime()'   => date('Y-m-d h:i:s a', filemtime($file)),
    'realpath()'    => realpath($file),
);
print_r($fileinfo);

This will return:

Array
(
    [file_exists()] => 1
    [filesize()] => 51
    [is_dir()] =>
    [is_file()] => 1
    [filemtime()] => 2007-09-24 12:08:53 am
    [realpath()] => C:\mywebstuff\htdocs\php-tutorial\file.txt
)

Another useful function is pathinfo(), it returns an array of information about the file, based on the path. This function actually works with file locations, regardless if a file exists at this location or this is just a made-up path.

$realpath = realpath($file);
$info = pathinfo($realpath);
print_r($info);

In the code above we called realpath() first, so that we have a more detailed path to pass to pathinfo(). The result will be:

Array
(
    [dirname] => C:\mywebstuff\htdocs\php-tutorial
    [basename] => file.txt
    [extension] => txt
    [filename] => file
)

Reading the contents of a file

A simple function to grab the contents of a file, is called file(). It reads a file and returns an array where each element is a line from the file. The array also contains the end-of-line characters, so if we use var_dump() to print out the contents of the returned array, you'll see that the closing quote for each element is on a second line.

$contents = file($file);
var_dump($contents);

This prints:

array(3) {
  [0]=>
  string(19) "this is text file
"
  [1]=>
  string(21) "second line of text
"
  [2]=>
  string(11) "and a third"
}

You can print individual lines if you wish:

echo "the second line starts...", $contents[1], "...and ends.";

The result:

the second line starts...second line of text
...and ends.

The function trim() comes in handy when you want to strip out the extra end-of-line characters.

echo "the second line starts...", trim($contents[1]), "...and ends.";

The above will print:

the second line starts...second line of text...and ends.

Printing out the file contents

A very simple way to print out the whole file already read by file() is to implode() the array of lines:

echo implode('', $contents);

This prints the whole file:

this is text file
second line of text
and a third

Another way to do the same is by using file_get_contents().

echo file_get_contents($file);

This again prints the whole file.

this is text file
second line of text
and a third

Writing to a file

The corresponding to file_get_contents() function is file_put_contents(). It takes a filename and a string and writes the string into the file.

Let's see an example where we read file.txt into a string, add some more lines to the string (delimited by the new line character \n) and write the result to a new file file2.txt. Finally we print out the contents of file2.txt to validate that everything was written OK.

$cnt = file_get_contents($file);
$cnt .= "\nA forth line";
$cnt .= "\nAnd a fifth line";
file_put_contents('file2.txt', $cnt);
echo file_get_contents('file2.txt');

This prints the new file:

this is text file
second line of text
and a third
A forth line
And a fifth line

Remote files

The functions file() and file_get_contents() that we used to read a file can also be used to read a remote file (if allowed by the PHP configuration). Let's see a short example where we read the page located at yahoo.com and print some random line.

$contents = file('http://www.yahoo.com');
echo htmlspecialchars($contents[123]);

Line 123 happens to be the following at the time of writing this:

<a href="r/0z">Local</a><br>

Older PHP versions

The handy pair of functions file_get_contents() and file_put_contents() were introduced at some point in PHP, but were not there from the very beginning. If you happen to be stuck with an older PHP version, you might need to take a look at these functions to achieve the same:

• fopen(), fread() and fclose() instead of file_get_contents()
• fopen(), fwrite() and fclose() instead if file_put_contents()

Summary

These were only some of the various functions PHP hasd to offer when working with files. For more, point your trusted browser to http://php.net/filesystem

What we have so far

In case you skipped the previous two stages of the Ragtime web-site development, check out here and here and the last demo here.

In the previous implementations we had some PHP scripts (like aboutus.php) that also include common parts of the pages - header, footer, menu. One kind of annoying this is that for every new page, you have to copy/paste some PHP code and repeat it in every page. This is the code that includes header.inc.php and footer.inc.php. Let's improve this.

The new file layout

In the new implementation, we remove any PHP code from all content pages (contact.php, aboutus.php, etc). Since these files now will contain only HTML, it's no longer necessary to have them as PHP scripts, so we'll rename them to *.html. So we'll have these static content pages:

• products.html (was products.php)
• aboutus.html (was aboutus.php)
• contact.html (was contact.php)
• home.html - This is the home page, was index.php

We'll also have the same include files, although they'll be slightly changed:

• header.inc.php
• footer.inc.php
• menu.inc.php

The big changes are in index.php, it will now serve as sort of a controller script that takes user input and decides which files to include. The user input will be received through a GET parameter named "page". So we'll have the following pages with the corresponding URLs:

The content pages

These are now really simple static HTML files.

home.html

<h1>Welcome to Ragtime!</h1>

<p>Select a link from our nice menu</p>

products.html

<h1>Products</h1>

<p>Check out our wide selection of tires. We have:</p>
<ul>
  <li>Winter tires</li>
  <li>Summer tires</li>
  <li>All-season tires</li>
</ul>

contact.html

<h1>Contact Us</h1>

<div id="hcard-Ragtime" class="vcard">
 <a class="url fn" href="http://www.ragtimebg.com">Ragtime</a>
 <div class="adr">
  <span class="locality">Sofia</span>,
  <span class="country-name">Bulgaria</span>
 </div>
 <div class="tel">1-888-123-4567</div>
</div>

aboutus.html

<h1>About Us</h1>

<p>This is the "about us" page, always very popular place.</p>

<p>Our company was found in year 1467 by ...</p>

The index script

This script index.php will do most of the work. The script starts by defining an array calles $pages. This array will hold information about all the pages in the site. It's an associative array and its keys are the page identifiers. Each page identifier has a corresponding array that has the keys title and menu. The title value will be used for the <title> tag and the menu value will be used for the navigation menu. If menu is missing, the value in title will be reused.

<?php
$pages = array(
    'home' => array(
        'title' => 'Welcome to Ragtime!',
        'menu'  => 'Home'
    ),
    'products' => array(
        'title' => 'Products',
    ),
    'contact' => array(
        'title' => 'Contact us',
    ),
    'aboutus' => array(
        'title' => 'About us',
    ),
);

Next, we want to populate a value in a $page variable. This variable will hold the identifier of the page the user has requested. We check if the $_GET['page'] input parameter has a value using the function empty(). If not, we default to the homepage.

// is there a page ID passed in GET
if (empty($_GET['page'])) {
    $page = 'home';
} else {
    $page = $_GET['page'];
}

Now that we have $page defined, let's validate its value. We expect that the regular user will just follow our links and will pass values for the $_GET['page'] parameter such as "home", "products", etc. But there will be users that will try to play with this parameter, passing strange values. "Never trust user input" is the mantra, so we must validate. We do this by simply checking if the page ID passed by the user exists as a key in the pre-defined $pages array. If it does, we're fine, otherwise we reset $page to "home".

// is this a valid page ID
if (empty($pages[$page])) {
    $page = 'home';
}

Finally, we define a $title variable (to be reused in the header.inc.php for the <title> tag) and we include header, footer and the static content page that was requested. If for example the request was index.php?page=aboutus, we end up including aboutus.html

// title of the page
$title = $pages[$page]['title'];

include 'header.inc.php';

include $page . '.html';

include 'footer.inc.php';
?>

Header and footer

The header and the footer contain only repeating parts, common to all pages.

header.inc.php uses the $title variable defined in index.php for the HTML title tag, it also uses the $page variable to set an ID attribute in the HTML body tag (we'll see why in a second). The header also includes menu.inc.php.

Here's the content of the header.inc.php include script

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
  <title>Ragtime &gt; <?php echo $title; ?></title>
  <link rel="stylesheet" href="ragtime.css" type="text/css" />
</head>
<body id="page-<?php echo $page; ?>">

<?php
include 'menu.inc.php';
?>

<div id="content">

footer.inc.php only closes tags.

</div>

</body>
</html>

menu.inc.php

In the menu.inc.php we simply loop through the $pages array (defined in index.php) in order to produce a list of menu items. To make the code a little bit more readable, we have a little template that is used for the LI tags. Then in every iteration of the loop we call the function str_replace() to replace the placeholders {PAGE} and {TITLE} with real values.

<ul id="menu">
<?php

$item_tpl = '<li><a href="index.php?page={PAGE}" id="menu-{PAGE}">{TITLE}</a></li>';

foreach ($pages AS $key => $data) {

    $menu_item = str_replace('{PAGE}', $key, $item_tpl);
    if (!empty($data['menu'])) {
        $menu_item = str_replace('{TITLE}', $data['menu'], $menu_item);
    } else {
        $menu_item = str_replace('{TITLE}', $data['title'], $menu_item);
    }
    echo $menu_item;
} // end foreach
?>
</ul>

After this code is executed, the HTML code for the navigation menu will look like:

<ul id="menu">
  <li><a href="index.php?page=home" id="menu-home">Home</a></li>
  <li><a href="index.php?page=products" id="menu-products">Products</a></li>
  <li><a href="index.php?page=contact" id="menu-contact">Contact us</a></li>
  <li><a href="index.php?page=aboutus" id="menu-aboutus">About us</a></li>
</ul>

Highlighting the current menu item

As you see we defined an id attribute in the body tag (like "page-products") and also an id in the navigation menu. This allows the use of CSS in order to highlight the current menu item by using:

#page-aboutus #menu-aboutus,
#page-home #menu-home,
#page-products #menu-products,
#page-contact #menu-contact {
    background: CornflowerBlue;
}

So the navigation menu item will have a different color but only on the page that has the same id. It's a small trick that can help a lot to have CSS do some work instead of using an if in the PHP code.

Demo and code

• Demo
• Code download

An SEO improvement with .htaccess

The site is very nice now and have a bunch of static files (which can be edited by someone with HTML experience only, no PHP knowledge required). We use dynamic URLs and have a little framework to load the static files per user requested.

A potential issue is that it's believed that some search engines don't like dynamic URLs very much and sometimes ignore everything after the ? symbol. It's not quite clear how much of an issue that is, but why risk the search engine popularity of the site when we can quickly correct this, using URL rewrites.

I'm not going to describe the URL rewrites in detail here, but the idea is that Apache has this ability to turn some publicly visible URLs into others that can be used internally. In our case we want that a request to home.html to be treated the same as a request to index.php?page=home. To achieve this you create an .htacess file with the following contents:

Options +FollowSymLinks
RewriteEngine on
RewriteRule ^(.*).html$ index.php?page=$1

We also need to change the "template" we used in the menu.inc.php in order to produce the new type of URLs:

$item_tpl = '<li><a href="index.php?page={PAGE}" id="menu-{PAGE}">{TITLE}</a></li>';

becomes

$item_tpl = '<li><a href="{PAGE}.html" id="menu-{PAGE}">{TITLE}</a></li>';

The new code and demo:

• Demo
• Code download

A simple array

Let's start by defining a simple array and printing out its contents.

(All examples assume that the code is enclosed in "<pre>" tags)

$a = array(
  'one'   => 1,
  'three' => 3,
  'two'   => 2,
  'four'  => 4
);
// print the array
print_r($a);

The result is simply:

Array
(
    [one] => 1
    [three] => 3
    [two] => 2
    [four] => 4
)

Checking for existence

You can use the function isset() that checks whether a variable (or an array index) is defined.

// key exists
if (isset($a['one'])) {
    echo 'key "one" exists';
}

This will print:

key "one" exists

Using empty() you can check if the key exists (same as isset()) but also if the array value with this key is a non-null value, in other words if something else than 0, "", null or FALSE,

// key exists and its value is not 0, "", null or FALSE
if (!empty($a['one'])) {
    echo 'key "one" exists and has a value';
}

In our example array, array element with key "one" exists and its value is "1", so it's a non-null value. The code above will print:

key "one" exists and has a value

The function in_array() checks if a specified value exists in a given array. Let's check if the value 4 exists in the $a array:

// value exists
if (in_array(4, $a)) {
    echo '4 is a value in the array';
}

The value 4 exists, so the code will print:

4 is a value in the array

Implode, explode

implode() and explode() are two very useful functions that turn an array into a string and vise versa. Let's see how.

implode() takes an array and a string (called delimiter) and returns a new string that has all the elements of the array with the delimiter string between them. Let's use the pipe symbol | as a delimiter:

echo implode("|", $a);

The result is:

1|3|2|4

Now let's see the opposite - we have a string and want to produce an array out of it. In the string "here,there,everywhere" we can use the comma as a delimiter:

$str = 'here,there,everywhere';
$b = explode(",", $str);
print_r($b);

Using explode() will create an array where the first element is "here", the second is "there" and the third is "everywhere". So the result of the code above will be:

Array
(
    [0] => here
    [1] => there
    [2] => everywhere
)

Keys, values, reverse

Continuing with the useful array functions, let's see the functions array_keys(), array_values() and array_reverse().

array_keys() will take an array and return a new (enumerated) array, containing only the keys of the input array. array_values() will do the opposite - return a new array with the values only, so you'll lose the original keys. array_reverse() takes an array and reverses the order pf the elements, the last element becomes first and so on. It keeps the keys pointing to the same values.

// keys only
print_r(array_keys($a));
// value only
print_r(array_values($a));
// reverse the array
print_r(array_reverse($a));

The code above will print:

Array
(
    [0] => one
    [1] => three
    [2] => two
    [3] => four
)
Array
(
    [0] => 1
    [1] => 3
    [2] => 2
    [3] => 4
)
Array
(
    [four] => 4
    [two] => 2
    [three] => 3
    [one] => 1
)

... and counting

The count() returns the number of elements in an array, useful when using for loops for example.

// count the elements
echo count($a); // prints 4

Random stuff

shuffle() takes an array and randomizes its elements.

// shuffle
$b = array_keys($a);
shuffle($b);
print_r($b);

This will produce something like.

Array
(
    [0] => four
    [1] => three
    [2] => one
    [3] => two
)

Another way to get random elements from an array is to use the function array_rand()

Sorting

There are quite a few functions that sort arrays - some sort ascending, some descending, some sort keys, some sort values, some keep the original keys of the array, some "re-key" the input array. There are also 3 functions that let you define custom sorting.

Let's see some of the built-in sorting functions.

sort() orders the elements of the array in ascending order (smallest first) and re-keys the array.

// sort ascending
$b = $a;
sort($b);
print_r($b);

Note that we used a new value $b, this is because sort() will simply return a new modified array, but will actually change the input array, so we lose the original when we pass it to sort(). The code above prints:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
)

rsort() is like sort(), only it sorts the element in descending order. ("r" for "reversed")

// sort descending
$b = $a;
rsort($b);
print_r($b);

The code above prints:

Array
(
    [0] => 4
    [1] => 3
    [2] => 2
    [3] => 1
)

"k" stands for "key". So ksort() is like sort() but it sorts keys of the array.

// sort keys
$b = $a;
ksort($b);
print_r($b);

Array
(
    [four] => 4
    [one] => 1
    [three] => 3
    [two] => 2
)

Since "k" is "key" and "r" is "reverse" what would be the function to sort the elements in descending order, ordered by key? Mhm, krsort().

Summary

So you get the idea, there are tons of array functions, some you'll use quite often so that you'll memorize their names and attributes. Other functions you'll use less often, but the PHP manual is always there for you to consult.

There are different ways for a web page to accept input from the user, the most common being through GET and POST requests.

What's in a request

When a user clicks on a link or types in the address bar, he/she requests a page (a file, a resource) from a remote server. This is done through the use of the HTTP protocol, so we say that the user makes an HTTP request. The resources out there are identifiable by their URL.

Let's take a URL:
http://www.w3clubs.com/w3clubs-examples/ragtime2/index.php

What we have here:

• The whole thing is a URL
• http identifies the protocol
• www.w3clubs.com is the host name
• /w3clubs-examples/ragtime2/index.php identifies where the resource is located

Just for information, here's how an HTTP request may look like:

GET /w3clubs-examples/ragtime2/index.php HTTP/1.1
Host: www.w3clubs.com
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.7) Gecko/20070914 Firefox/2.0.0.7
Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive
Referer: http://www.w3clubs.com/w3clubs-examples/ragtime2/
Cache-Control: max-age=0

To see the HTTP headers being exchanged when you request and receive pages, I'd recommend using the Firefox extensions LiveHTTPHeaders or the Net panel of Firebug. For IE and other browsers on Windows you can also use Fiddler.

GET

Notice the word GET in the request above? It specifies the request method.

Now let's check this URL:
http://www.w3clubs.com/w3clubs-examples/ragtime2/index.php?key=value

The part after the question mark is called a query string, it allows you to pass parameters when making a request. You can have several query parameters, divided by an &

http://www.w3clubs.com/w3clubs-examples/ragtime2/index.php?key=value&something=else

The cool thing is that in your PHP script you have access to those parameters and can do different things, for example branch the page execution, based on different values being passed in the query string.

You can access the query string parameters (let's call them GET parameters) through the array $_GET which PHP defines for you. Let's see an example.

Example

Create the script C:\mywebstuff\htdocs\php-tutorial\get.php (how to setup here) with the following contents:

<pre>
<?php
print_r($_GET);
?>
</pre>

Now load this script in the browser, like http://localhost/php-tutorial/get.php

The result might be slightly disappointing, but it does illustrate something important - that the $_GET array is always defined. The result is:

Array
(
)

Now let's change the URL of the request to:
http://localhost/php-tutorial/get.php?key=value

The result:

Array
(
    [key] => value
)

And how about http://localhost/php-tutorial/get.php?key=value&something=else

Array
(
    [key] => value
    [something] => else
)

Never trust user input

You just learned how to get user input and now I'm telling you not to trust it. What gives?

Not trusting user input is an important lesson (that many have learned the hard way) and cannot be over-emphasized.

Let's say you have the following script:

<?php
echo 'Hello ', $_GET['user'], '!';
?>

When you request is like http://localhost/php-tutorial/user.php?user=stoyan, this is a friendly little page that greats me:

Hello stoyan!

But as a malicious user I can try adding HTML tags in my username and nothing in the script will stop me:
http://localhost/php-tutorial/user.php?user=<b>stoyan</b>

This will result in:

Hello stoyan!

So what? So far, not so bad. But why stop here? I can also pass javascript as a parameter.
http://localhost/php-tutorial/user.php?user=<script>location='http://www.phpied.com'</script>

What will happen? As soon as you load the page, you're redirected to my blog at http://www.phpied.com, because the script printed whatever was passed as 'user' parameter, so the HTML looks like:

Hello <script>location='http://phpied.com'</script!>

Redirecting to a page is bad enough, but could be worse. With javascript you have access to the browser cookies, so a malicious user can not only redirect to a new page, but also send your cookies to this page and this way steal your session. Imagine PayPal doing such a mistake. A hacker can get your session ID and put it in his browser cookies, this way logging in as you and making some payments. Scary stuff.

The take-home message here is:
When you accept user input, expect the unexpected. If you ask for example for a phone number from the user, don't assume you'll only be receiving numbers, be also prepared to deal with all kinds of characters, HTML and JavaScript strings.

What's the fix to the vulnerability above? Surprisingly simple, just use function htmlspecialchars(), it will make all > and < into > and < and the script will never be executed.

<?php
if (!empty($_GET['user'])) {
    echo 'Hello ', htmlspecialchars($_GET['user']), '!';
}
?>

The result displayed in the browser will be:

Hello <script>location='http://phpied.com'</script>!

because the HTML code generated will be:

Hello <script>location='http://phpied.com'</script>!

print_r()

print() is a language construct, almost the same as echo and can be used instead of echo to print strings. print_r() on the other hand is a function that prints a variable recursively, meaning that it can print all elements of an array, even if it consist of other arrays.

Let's see an example:

$a = array(1, 2, 3, array(4, 5, 6));
echo $a; // prints "Array", not useful at all
print $a; // same as above
echo '<pre>'
print_r($a); // the good stuff
echo '</pre>'

So echo and print will output "Array", that's the best they can do, because they accept string input, not arrays. print_r() will output the array very nicely in a readable format, so that you know exactly what's the contents of the array. The output from the print_r() in the code above will be:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => Array
        (
            [0] => 4
            [1] => 5
            [2] => 6
        )

)

Very useful when at some point in the development, you're no longer sure what exactly is in this array.

If you give a string or a number to print_r() instead of an array, it will act as a normal print call.

var_dump()

Similarly to print_r() you can get an idea of the contents of an array by using var_dump(). In addition to what print_r() gives, it will also report the size of an array (or sub-array) and will report the type of each value.

An example use of var_dump():

$a = array('one', true, 3.14, array(4, 5, 6));
echo '<pre>'
var_dump($a);
echo '</pre>'

The result is:

array(4) {
  [0]=>
  string(3) "one"
  [1]=>
  bool(true)
  [2]=>
  float(3.14)
  [3]=>
  array(3) {
    [0]=>
    int(4)
    [1]=>
    int(5)
    [2]=>
    int(6)
  }
}

Given scalar data (not an array), var_dump() will behave similarly.

var_dump('one'); // string(3) "one"

You can pass as many values or variables to var_dump() as you want.

var_dump('one', 'two', 3);

The above will print:

string(3) "one"
string(3) "two"
int(3)

var_export()

var_export() is similar to var_dump() and print_r(), but with one significant difference - it produces valid PHP code. You can take the output and put it a PHP script as a normal PHP code.

$a = array('one', true, 3.14, array(4, 5, 6));
echo '<pre>'
var_export($a);
echo '</pre>'

The result is:

array (
  0 => 'one',
  1 => true,
  2 => 3.14,
  3 =>
  array (
    0 => 4,
    1 => 5,
    2 => 6,
  ),
)

Quick example

// define an array
$myarray = array('one', 'two', 'three');
// loop
foreach ($myarray as $tmp) {
    echo $tmp, '<br />';
}

This code will print:

one
two
three

Let's see what we've got here:

• First there's the construct foreach followed by something in brackets.
• Then just like the for loop we have a block of code, enclosed in curly brackets. This code is executed on every iteration.
• How many iterations there would be? As many as the elements in the array being looped.
• In the parentheses after foreach we have the array followed by the construct "as", followed by another variable. On every iteration, the value of next element in the array will be assigned to the new variable.

In the example above, at the first iteration $tmp will have the value "one", in the second iteration, the value of $tmp will be "two", the third iteration - "three".

Note that $tmp lives after the end of the loop. After the loop $tmp will still be defined and will have the value of the last array element, in this case "three".

Access to the keys while looping

OK, so in the example above we printed out the values of the array elements, but what about their keys?

To access the keys of an array while in a loop, you can use the following variant of the foreach construct:

foreach($array as $key => $value) {...}

On every iteration $key will contain the key of the next array element, and $value will hold the value.

Let's see the example above, slightly modified to print the keys.

// define an array
$myarray = array('one', 'two', 'three');
// loop using $k (as in "key") and $v as "value"
foreach ($myarray as $k => $v) {
    echo 'Key: ', $k, ', value: ', $v, '<br />';
}

This code will print:

Key: 0, value: one
Key: 1, value: two
Key: 2, value: three

Associative arrays example

So far we only used enumerated arrays, but the associative arrays can be looped over the same way.

// define an array
$myarray = array(
    'name' => 'Hendrix',
    'first' => 'Jimi',
    'song' => 'Foxy Lady'
);
// loop using $k (as in "key") and $v as "value"
echo 'Now playing:';
foreach ($myarray as $k => $v) {
    echo $k, ': ', $v, '<br />';
}

This will print:

Now playing:
name: Hendrix
first: Jimi
song: Foxy Lady

Updating the array while in the loop

This code won't change anything in the array:

$myarray = array(1, 2, 3, 4, 5);
foreach($myarray as $k => $v) {
    $v = $v * 2;
}

This simply changes the $v variable, but not the value in the original array. To change the array, we can address its elements using the current key:

$myarray = array(1, 2, 3, 4, 5);
foreach($myarray as $k => $v) {
    $v = $v * 2;
    $myarray[$k] = $v;
}

After this code executes, you'll have an updated array that looks like this:

array(2, 4, 6, 8, 10)

Loop 10 times

Let's see a simple example of a loop.

for ($i = 0; $i < 100; $i++) {
    echo "This punishment is not boring and pointless.<br />";
}

If you execute this, it will write down the sentence a hundred times. Let's see what the loop consists of.

• The part in curly brackets is the block of code to be executed at every iteration (every time the loop "ticks").
• The part after the word "for" in the brackets is setting up the loop properties. It consists of three expressions, divided by semi-colons.
  1. $i = 0; - this part is initializing the loop, here you can set up some variables. This part is always executed. Usually it's used to set a "counter" variable, by convention named $i
  2. $i < 100 - this part is a condition (similar to an if-else condition) that has to evaluate to TRUE, otherwise the loop stops. This is the place where usually you define the boundary condition, after which the loops is no longer executing. In the case above, we set that after 100 repetitions, the loop should exit
  3. $i++ - this part is executed at the end of every iteration. Often it simply increments the $i counter variable

More examples

Let's print the numbers from 1 to 10, using the $i counter variable that we increment on every iteration.

for ($i = 1; $i <= 10; $i++) {
    echo $i, '<br />';
}

You can use several statements in the expressions divided by semi-colons. Let's see two ways of printing the numbers from 1 to 10 ascending and descending.

$k = 10;
for ($i = 1; $i <= 10; $i++) {
    echo $i, ' -- ', ($k - $i +1), '<br />';
}

This will print something like:

1 -- 10 // $i is 1, so 10 - 1 + 1 is 10
2 -- 9 // $i is 2 and 10 - 2 + 1 is 9
3 -- 8
4 -- 7
5 -- 6
6 -- 5
7 -- 4
8 -- 3
9 -- 2
10 -- 1 // $i is 10 so 10 - 10 + 1 is 1

The same can be achieved by moving the initialization of $k inside the initialization part of the loop and moving the little calculation we had in the third expression of the loop, together with $i++. The calculation can actually be a simple decrement. This keeps the block of code simpler.

for ($i = 1, $k = 10; $i <= 10; $i++, $k--) {
    echo $i, ' -- ', $k, '<br />';
}

As you can see, when you need to do two or more things inside a for expression, you use comma as a separator.

Skipping an iteration

You can use continue to skip a step. When you use it, the rest of the code in the block is not executed. Usually you use continue conditionally. The following prints only even numbers.

for ($i = 1; $i <= 10; $i++) {
    if ($i % 2 != 0) {
        continue;
    }
    echo $i, '<br />';
}

In this example we tested $i in every loop iteration and if we discover it's not an even number, we skip the rest.

BTW, the same can be done easier, but the aim was to see how continue; works. Here's the easier solution, it shows that the increment expression doesn't necessarily need to increment only by one.

for ($i = 2; $i <= 10; $i += 2) {
    echo $i, '<br />';
}

Breaking out of the loop

You can use break; inside the body of the loop to exit at any time. Usually the break is also conditional.

//  loop ends when $i is 100
for ($i = 2; $i <= 100; $i += 2) {
    echo $i, '<br />';
    if ($i == 10) {
        // exit prematurely when $i is 10
        break;
    }
}

The result of executing this code is printing only the numbers 2, 4, 6, 8, 10.

Nested loops

You can nest loops within each other. The following example prints the multiplication table from 1 to 10.

<?php
for($i = 1; $i <= 10; $i++){
    echo '<h2>Multiplication by ', $i, '</h2>';
    for($j = 1; $j <= 10; $j++) {
        echo $i, ' * ', $j, ' = ', ($i*$j);
        echo '<br />';
    }
}
?>

Here's a demo of this script in action.

Looping through an array

Let's say we have the array $a = array(1, 3, 5, 7, 9);. Let's print all the elements.

First we need to know when the loops should end. We figure that out using the count() function which returns the number of elements in the array. Another important thing to remember is that array keys start from 0, so you loop from 0 to the number of elements minus 1.

$max = count($a);
for($i = 0; $i < $max; $i++) {
    echo $a[$i], '<br />';
}

This code will print all the elements of the $a array.

Associative arrays

Associative arrays are different than the enumerated arrays in the fact that their keys are more flexible, they can be strings, not only numbers. So you can think of the associative arrays (also called hash arrays) as tables that have a column for keys and a column for the corresponding values. If you want to access the value of an array element, you address it by its key, just like with the enumerated arrays.

The following code represents this table as a PHP associative array:

$dude = array(
    'name' => 'Man',
    'first_name' => 'Super',
    'occupation' => 'Superhero'
);

As you see in the example, the keys and the values are divided by the => symbol. The keys are enclosed in quotes.

If you want to use this array to print a sentence, you can do something like:

// prints "SuperMan is a superhero"
echo $dude['first_name'], $dude['man'], ' is a ', $dude['occupation'];

Case sensitive keys

Array keys are case sensitive and also allow spaces and numbers, so these are all valid keys:

$arr = array(
    'FirstName' => 'Super',
    'firstname' => 'Duper',
    'First name' => 'Ultra',
    '1st name' => 'Mega',
);

Adding to an array

You can add to an array at any time, just by specifying the key in square brackets.

// define an empty array
$ar = array();

// add some elements
$ar['name'] = 'Superman';
$ar['powers'] = 'Super';

Note that in this case you use the normal assignment operator (=), not the => one.

Modifying elements

Modifying an element has exactly the same syntax as adding.

// define an empty array
$ar = array();

// add an element
$ar['name'] = 'Superman';

// update the 'name' element
$ar['name'] = 'Batman';

Removing any element

Similarly to the enumerated arrays, you use the unset() function to delete an element.

$ar = array('one' => 1, 'two' => 2);
unset($ar['two']);
echo $ar['one']; // prints 1
echo $ar['two']; // prints nothing, a notice when E_ALL

Mixing associative and enumerated arrays

The two types of arrays are quite similar, actually both are defined using array(), so there's no explicit way to say "I want an associative array". It all depends on the keys you use (or don't use).

• If you don't specify any keys, you're creating an enumerated array and the keys are set behind the scenes to auto-incrementing integers.
• If you specify numeric keys, even if you use quotes, you're creating enumerated arrays.
• If you specify string keys, you're creating an associative arrays.

On top of that, both array types can be mixed, the result is an associative array with some enumerated behavior when you add to it. This is rarely useful, but still possible.

// define an empty array
$a = array();

// set key 1
$a['1'] = 1;

// set key 2
// the previous line created a numeric index 1
// so the next available auto-increment is 2
$a[] = 2;

// adding an associative key
$a['three'] = 3;

// again a numeric index
// the last numeric key was 2 so the new key will be 3
$a[] = 4;

// associative key using the empty string as a key
$a[''] = 'empty';

// skipping some numbers and setting key number 100
$a[100] = 100;

// the last numeric key was 100
// so the next key is 101 if we don't set it ourselves
$a[] = 101;

// you can use variables as keys
$next_key = 'some_key';
$a[$next_key] = 'Some value';

Forgetting the quotes

What if you create an associative array but you forget the quotes when you specify keys? Well, a string in the code that doesn't look like a variable or function or a quoted string is most likely a constant. And if you use an undefined constant, its assumed value is the name of the constant. In the following example $arr1 and $arr2 end up being the same. With the difference that $arr1 will throw a Notice if you have error reporting set to E_ALL.

$arr1 = array(
    mykey => 'my value',
);
$arr2 = array(
    'mykey' => 'my value',
);

As you know already, you should aim at writing code that doesn't throw any notices, so the take-home message here is "Don't forget the quotes".

Enumerated lists

An array is a list of values. The values in the list can be of any type, including other arrays. Here's one array - it's a list of odd numbers.

$myarray = array(1, 3, 5, 7, 9);

As you can see, in order to define an array, you use the language construct array(), which looks just like a normal function. Elements inside an array are separated by commas.

In order to access an individual element of the array, you use square brackets and in the brackets you specify the position of the element you want, starting from zero.

echo $myarray[0]; // prints 1, the first element
echo $myarray[1]; // prints 3, the second element
echo $myarray[4]; // prints 9, the fifth (4 + 1) element

The elements of the list are identifiable by their key, this is the number you put in square brackets. The keys are automatically created starting from zero and incrementing. The first element has key 0, the second has key 1 and so on. Let's see a little table that illustrates the array we used above.

Adding an element to an array

To add a new element at the end of the array, just use square brackets without a value, like so:

// array with three elements
$a = array(1, 2, 3);
// adding a fourth element
$a[] = 4;
// adding one more element
$a[] = 5;
echo $a[4]; // prints the fifth element, value 5

Instead of using empty brackets, you can also specify an exact index when you add to an array, or modify an element.

// array with three elements
$a = array(1, 2, 3);
// adding a fourth element
$a[3] = 4;
// adding the hundredth element
$a[99] = 100;

It's not an error to skip indexes, but maybe not very practical most of the times.

If you attempt to use an element with a non-existing key, you'll get a PHP notice that this key doesn't exist.

// array with three elements
$a = array(1, 2, 3);
echo $a[88]; // throws a notice

Removing elements

You can remove elements from an array, using the unset() function.

// array with three elements
$a = array(1, 2, 3);
unset($a[1]); // remove the second element
echo $a[0]; // prints 1
echo $a[1]; // Notice: undefined offset,
            // meaning that this element doesn't exist
echo $a[2]; // prints 3

BTW, the unset() function can also be used to unset variables, as if they were never defined.

$a = 1;
echo $a; // prints 1
unset($a);
echo $a; // Notice: undefined variable $a

Mixed values

In the examples above we only stored integers in the arrays, but you can store any type of data.

$a = 1;
$b = "b";
$myarray = array(
  $a,
  $b,
  99.99,
  "Ninja!",
  array(11, 22, array(9, 8, 7));
);
// let's print!
echo $myarray[0]; // prints 1
echo $myarray[1]; // prints b
echo $myarray[2]; // prints 99.99
echo $myarray[3]; // prints Ninja!
echo $myarray[4][0]; // prints 11
echo $myarray[4][1]; // prints 22
echo $myarray[4][2][0]; // prints 9
echo $myarray[4][2][1]; // prints 8
echo $myarray[4][2][2]; // prints 7

Using two pairs of square brackets [][] you can access arrays contained within arrays. This way you can nest arrays as deep as you need.

Here's for example an array structure that contains a 3 by 3 grid of a tic-tac-toe game;

$ttt = array(
  array('x', 'x', 'o'),
  array('o', 'x', 'o'),
  array('x', 'o', 'x'),
);
// getting the cell in the middle
echo  $ttt[1][1]; // prints x

Note on syntax - it's OK to have a trailing comma after the last element, it's not an error (as long as it's only one comma).

$a = array(1, 2, 3); // this is OK
$a = array(1, 2, 3,); // this is OK
$a = array(1, 2, 3,,); // parse error

Summary

1. Arrays are important, you'll see much more examples of their use in the following articles.
2. An array is a list of values, values are indexed by keys
3. You can store anything in an array, including other arrays

What if?

Think about this expression - If I reach the train station before 8:30 I'll catch the train, otherwise I'll have to wait for the next one. In some sort of programspeak pseudo-language this will look like:

if time less than 8:30
  catch the train
else
  wait the next one
endif

The "time less than 8:30" part is called a condition. A condition returns a boolean value - either TRUE or FALSE. If it returns TRUE, the next statement "catch the train" is executed. If the condition returns (evaluates to) FALSE, the else part ("wait for the next one") is executed.

A PHP example

Let's see an example with real PHP code.

$a = 5;
if ($a > 1) {
    echo 'a is positive';
} else {
    echo 'a is negative or 0';
}

The syntax is that the condition is placed in brackets and the statements are in curly brackets.

Comparison operators

We already discussed some operators, but not all. Let's introduce some more, the so-called conditional operators.

• $a == $b returns TRUE if $a and $b are equal
• $a === $b returns TRUE if $a and $b are equal and are of the same type. For example if we have $a = 1 (integer) and $b = "1" (string), then $a == $b will return TRUE, but $a === $b will return FALSE
• $a != $b returns TRUE if $a and $b are NOT equal
• $a !== $b returns TRUE if $a and $b are NOT equal or not of the same type. Again if we have $a = 1 (integer) and $b = "1" (string), then $a != $b will return FALSE, but $a !== $b will return TRUE. Yes, think about it for a minute.
• $a > $b returns TRUE if $a is greater than $b
• $a < $b returns TRUE if $a is less than $b
• $a >= $b returns TRUE if $a is greater than or equal to $b
• $a <= $b returns TRUE if $a is less than or equal to $b
• $a $b returns TRUE if $a is either greater or less than $b, or in other words $a and $b are NOT equal (same as !=, rarely seen in practice)

The == operator is easily confused with the simple assignment =. When you use assignment in an if-condition, it's not an error, and in most cases you'll get the condition evaluated to TRUE, simply because the assignment was successful. For example:

$a = 5;
if ($a = 1) {
    echo $a;
} else {
    echo "A is not 1";
}

This code will print "1", because in the condition part instead of using == to check if $a is 1, we used assignment and gave $a the value 1. If we use comparison operator, the result will be "A is not 1".

$a = 5;
if ($a == 1) {
    echo $a;
} else {
    echo "A is not 1";
}

The block

The code enclosed in curly brackets { and } is called a block. It's an important concept in PHP (also in C, Java). We'll see more use of the blocks further on, for example in functions and loops.

One note on syntax - when you have an if codition and a block is only one line, the brackets are optional. So this is valid:

$a = 123;

// checking a
if ($a == 3)
  echo 'A is three';

// moving on
$a = 321;

A good practice is to use the brackets, even if they are not needed. This makes it easier to understand the code, no need to think about it. Also makes a bit easier to come to the code later and add a second line of code, in this case the brackets are required and they would already be there.

Conditions

Sometimes a simple check like $a == $b is all you need, but other times you'll need a more specific set of checks. It's OK to have as many checks as you want in a single condition.

if ($a > 10 && $a < 100) {
    echo "A is between 10 and 100";
}

&& means AND. Its opposite is || which means OR. So the condition above can be read as "if a is greater than 10 and less than 100".

Here's another example, it can be read "if a is equal to 10 or to 100"

if ($a == 10 || $a == 100) {
    echo "A is either 10 or 100";
}

If you use || and at least one of the sub-conditions is TRUE, then the whole thing is TRUE. With && it's the other way around - all individual sub-conditions have to be TRUE, otherwise the whole condition is FALSE. This has a performance impact, because PHP is smart enough to give up if at some point during the evaluation of the separate sub-conditions, the end result becomes clear. For example:

$a = 1;
if ($a == 5 && $a > 10 && $a < 1) {
    // some code
}

In this case after the first check $a == 5 evaluates to FALSE, it becomes clear that the whole condition has no chance of being TRUE, so PHP will not execute all the following checks.

The performance lesson here is - put the most likely sub-conditions first, this might save some processing.

You can also mix && and || in the same condition. If you find yourself writing a longer condition consisting of sub-conditions, use brackets to make the code easier to follow.

// hard to understand
if ($a == 5 && $b == 5 || $a == 10 && $b == 10) {}
// much better
if (($a == 5 && $b == 5) || ($a == 10 && $b == 10)) {}

else and elseif

As you see in some of the examples above, the else clause is not required, it's optional.

There is also elseif which you can use for a better execution control.

if ($a == 1) {
  echo 'A is 1';
} elseif ($a == 2) {
  echo 'A is 2';
} else if ($a == 3) {
  echo 'A is 3';
} else {
  echo 'I give up';
}

Both elseif and else if are OK.

Truthy and falsy

You can use conditions like if ($a) {...}. The result of the condition will depend on the value in $a. Most of the values are "truthy" and the condition will evaluate to TRUE, except the following which are all "falsy":

• "" (empty string). Note that a string with even a single space is truthy.
• FALSE
• NULL
• 0