When developing a PHP project, whether it’s a simple website or a much larger web application, it’s always a good idea to take into account the potential appearance of errors in your PHP code. An error occurs whenever PHP tries to execute an instruction which either results in an impossible outcome, or otherwise prevents the script from executing in the manner intended by the programmer.

Errors range from simple fatal errors, where program execution is halted at the point of the fault - usually a syntax error or a call to a function that doesn’t exist - to more complex errors where the cause of the problem isn’t immediately clear, and an indepth review of the code must be carried out to pinpoint the flaw.

Undefined Variables (and other little glitches)

Dealing with errors in a meaningful and graceful manner is a major consideration when developing PHP code. The default behaviour of PHP when encountering an error is to output a very simple line of text, with very basic formatting. It’s really quite ugly, and not the sort of thing you want your visitors to be seeing:

echo ($hello_world);

Here, we are trying to access a variable $hello_world which has not been defined. The resulting output will be a screen with the following text

Notice: Undefined variable: hello_world in C:\local\myphp.php on line 5

Note: You might not see this appear on screen right away. PHP sometimes is not fully set up to display all errors as they happen. To change PHP’s default behaviour, add the following lines before the echo statement above

1
2

error_reporting(E_ALL|E_STRICT);
ini_set("display_errors", TRUE);

Line 1 tells PHP to report all errors (including “strict” errors, which aren’t included as part of the E_ALL argument). Line 2 sets a PHP configuration variable which instructs PHP to always display errors. This value is also hidden away in the php.ini configuration file, but that’s not always accessible, so this way of setting it is perfectly valid.

One way to get around this error message cropping up in the first place is to make sure you’ve properly defined the variable before you use it. And if you’re uncertain whether or not the variable is defined, you can always place checks before calling it, like so

//the isset function checks if a given variable is defined or not
if(isset($hello_world){
  echo $hello_world;
} else {
  echo "The variable 'hello world' couldn't be located";
}

But that’s not terribly practical when you have to do the same checks for every variable, and the error message displayed still makes it all too clear to the visiting public that something’s gone wrong.

In the next section, we will look at ways of handling these error messages in a much more efficient manner

Procedural programming has many advantages, mainly the ability to store frequently used code within functions, and to encompass complex algorithms within easy-to-remember function names.

In this tutorial, I’ll take things a step further, and introduce you to the concept of Classes and Objects in PHP. To put it simply, an Object in the context of programming languages is a data structure which can contain any number of variables and functions all held together under a Class name. This Class can then be created in the normal scope of the code and stored inside a new variable, and multiple copies of this same class can be created. This allows for an even greater level of code encapsulation, allowing more complexity to be accessed from simple commands.

I mentioned that procedural programming allows us to encapsulate code within functions to be re-used as required. Classes take that a step further, allowing us to encapsulate many functions within a class and to create multiple copies of each class.

Note that, when inside a class definition, functions are referred to as methods, and variables are referred to as members - even though we still use the keyword “function” to define methods.

Methods : “Functions defined inside Classes”

When defining a function within a class, we refer to it as a method, and this method then becomes available to all instances of a class. The following example shows the syntax used to define a class, and also create an instance of the class for use. We will then call the method defined within the class, using this newly created instance

Class MyClass {
   function myFunction(){
      echo "Hello world!";
   }
}
$myObject = new MyClass(); //create an instance of MyClass called $myObject
$myObject->myFunction();  //call the method, myFunction() using the instance

Lets take a step by step look at what’s happening here

• Line 1 : New classes in PHP are defined by the use of the Class keyword, followed by a user defined name to label the class. Here, we’re calling our class MyClass. The body of the class is placed between a pair of braces. Class naming convention is the same as for standard variables and function names, and traditionally class names start with an uppercase letter
• Lines 2-4 : Within the class, we can define a range of variables and functions. Here, we’re defining just one function, in this case, the function myFunction, which serves a single purpose - to print “Hello world!”
• Line 6 : Here’s where the fun begins! After a class has been created, we can then assign instances of the class to variables. Here, we make use of the “new” keyword to create a new copy of the MyClass object. Note the parentheses after MyClass. These aren’t explicitly required here, but later on in the tutorial, I’ll show you how you can place values within these to add extra functionality to your class.
• Line 7 : by the use of the -> operator we can call functions and access variables within the class object. Here, we are calling the myFunction function. This will produce the now-familiar output

  Hello world!

Multiple instances of the same class can be created. This way, we can reuse the functionality of the class without needing to worry about redeclaring variables, or functions

$firstObject = new MyClass();
$secondObject = new MyClass();
$thirdObject = new MyClass();
$firstObject ->myFunction();
$secondObject ->myFunction();
$thirdObject ->myFunction();

Let’s take a step forwards now and add in some variables, or members into our functions. When defining variables within the body of a class, we refer to these variables as members. Here is an example of another class definition with a couple of members, $a and $b defined within its body.

Members : “Variables defined inside Classes”

1
2
3
4
5
6
7
8
9
10
11
12

Class MyClass {
  public $a = 5;
  public $b = 10;
 
  function showValues(){
    echo "a equals $this->a";
    echo " and b equals $this->b";
  }
}
$class = new MyClass;
$class->showValues();
echo "a plus b = ".($class->a + $class->b);

a equals 5 and b equals 10
a plus b = 15

Here, you’ll see much that is familiar from the previous example. We define a class using the “Class” keyword, and inside the class is a function, or method showValues(). But, we’ve got a couple of new things here that need some explaining!

• Lines 2 and 3 : Here, you can see a couple of members $a and $b being defined, in much the same way as we’d define variables within the normal scope of a script, except when defining members inside a class, we must use the public keyword. There are exceptions to this rule though, and they will be explained shortly. Note that it is also acceptable to define members by using the keyword var e.g. var $a = 5; although this usage is a remnant from earlier versions of PHP and is only supported for compatibility reasons. It is better to use public
• Lines 6 and 7 : Now that we have the variables $a and $b defined within the body of the class, we can use these values from within functions. Here, you’ll see another mysterious variable - $this. $this is a very special variable in PHP. When inside a class, or object, $this allows you to refer to the class from within itself. Notice how, when calling a class method from outwith the class definition we use the notation $class->functionName()? When we’re running code from inside the class itself, we can do the same thing, but instead of using the name of the class, we simply use $this. This way we can refer to the class object without needing to know the specific variable name the class has been assigned to.In this case, we’re working with the values of $a and $b from inside the method by referring to them with $this->a and $this->b
• Line 12 : Here we are accessing the values of $a and $b directly. You can see from this example how it’s much cleaner, and compact to use methods from within the class to access variables in this way, since it allows for greater code portability. This code can be improved like so,
  
  

  Class MyClass {
    public $a = 5;
    public $b = 10;
   
    function addValues(){
      return "a plus b = ".($this->a + $this->b);
    }
  }
  $class = new MyClass;
  echo $class->addValues();

Confused? Yes, don’t worry, it can be a little overwhelming at first, but the thing to remember about Object Oriented Programming is that it uses lots of the same principles you’ve been using already, but with a little twist. It’s really about changing the way you think about coding, into a more packaged, compartmentalised view of things.

In the next section, we’re going to take a look at how we can control access to the members and methods contained within a class

The functionality of PHP in terms of image manipulation ranges from very simple resizing of images through to more complex effects and functions using image libraries such as ImageMagick

In this tutorial, I’ll take you through some of the more common uses for PHP when manipulating images, and then introduce you to some of the cooler aspects of this powerful little tool, which could help you to really add a bit of jazz and sparkle to your website!

Let’s start with something simple. We’ll take a particular image, how about, let’s say, an image of a cute puppy and then run some functions on it to determine a few facts about it.

getimagesize()

We’ll start here by determining the image type (is it a jpeg, gif, png?), dimensions (height and width) and a few other things by using the getimagesize() function. Note that for this example, the image we’re using - puppy.jpg - must be in the same directory as the PHP script we’re calling this function from

$info = getimagesize("puppy.jpg");
print_r ($info);

The function returns an array containing all of the relevant information, so the above code will produce

Array (
  [0] => 491 //width
  [1] => 367 //height
  [2] => 2 //this number is a constant representing the image type
  [3] => width="491" height="367"
  [bits] => 8  //number of bits-per-pixel in the image
  [channels] => 3 // 3 = RGB, 4 = CMYK
  [mime] => image/jpeg //determines the filetype
)

From this we can tell the image is 491 by 367 pixels in size, with an 8-bit colour depth, and 3 colour channels. We also have the filetype, stored as the “mime” value of the array - “image/jpeg”.

Another way we can retrieve the type of image used is to make use of PHP’s image_type_to_extension() function which will take, as its argument, the value of the array in index “2″ - in this case a value of 2, which represents the filetype of the image. So, for this value we get

echo image_type_to_extension(2);

which outputs

.jpeg

So, now we have this information, what else can we do with the file? We could try resizing the image, and saving a new copy of it. But first, let’s just try reading in the file data and see what happens

header("Content-Type: image/jpeg");
$image = @imagecreatefromjpeg("puppy.jpg");
imagejpeg($image);
imagedestroy($image);

And behold, a picture of a cute puppy!

• Line 1 : This header value tells the browser to interpret the following data as Jpeg image data
• Line 2 : Read the image data from the file, puppy.jpg using imagecreatefromjpeg(). The @ symbol simply supresses any errors that might occur. This creates a GD Resource $image, which can then be manipulated as required, or sent as output to the browser. Function like this one are part of PHP’s GD2 Library of image manipulation functions. Each function works on, or loads/saves an object representing image data called a GD Resource.
• Line 3 : imagejpeg() is the function that outputs the image data to the browser
• Line 4 : After we have output the image data, destroy the image resource with imagedestroy()

So that’s how we read in and print out simple jpeg data. Similar functions also exist for PNG and GIF filetypes - namely imagecreatefromgif(), imagegif() and imagecreatefrompng(), imagepng()

Resizing and Rotation

What else can we do with the image once we’ve loaded it into memory with imagecreatefromjpeg()? Let’s try resizing the image. Here we will make use of the imagecreatetruecolor() function to create a blank GD resource to copy the resized image into, and the imagecopyresampled() function to perform the copying.

The arguments for imagecopyresampled() are as follows

bool imagecopyresampled  ( resource $dst_image, resource $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $dst_w, int $dst_h, int $src_w, int $src_h )

Which might need a little explanation: The first two are relatively straightforward, $dst_image is the GD resource to copy to, and $src_image is the GD resource to copy from. After these two arguments are 8 parameters that specify (x, y) co-ordinates on both the source and destination images, and width and height values for the source and destination images also.

These points and widths are used to calculate which area of the source image is to be copied based on the top-left (x, y) co-ordinates and the source width and height, and the new width and height of the destination image, as well as the top-left co-ordinate values for the new image to start at

When we call imagecreatetruecolor() we must also specify a width and height for this destination image.

header("Content-Type: image/jpeg");
$image = @imagecreatefromjpeg("puppy.jpg");
$size = getimagesize("puppy.jpg");
$percent = 150/100;
$image_dest = @imagecreatetruecolor($size[0]*$percent, $size[1]*$percent);
imagecopyresampled($image_dest, $image, 0, 0, 0, 0, $size[0]*$percent, $size[1]*$percent, $size[0], $size[1]);
imagejpeg($image_dest);

This will output an image 150% the width and height of the original. You can control the size of the image by changing the value of $percent. With some experimentation you can also try changing the ratio of the width and height to distort the image, and change the values within imagecopyresampled() to change the portion of the image that is resized.

Why not try image rotation by replacing the imagejpeg($image_dest); function call to the following

// 0x000000 is the background colour to use for the blank
// space left after the rotation calculation
$rotate = imagerotate($image_dest, 45.0, 0x000000);
imagejpeg($rotate);

Cute puppy has been rotated 45 degrees. Poor thing

Saving the Image To Disk

Once you’ve manipulated the image enough, you may then want to save it to disk. A common usage for such a function is the use of generated thumbnail images for image upload sites. The idea being that a user would upload an image to a forum, or an image hosting site, and they would be given the option of either linking to the full-size image, or to a small thumbnail of the image.

Such functionality is easy to achieve with the GD2 library, we simply modiy to the code from earlier by adding a new parameter to imagejpeg. This simply saves the GD resource to a file on the disk, as specified by the name given.

$image = @imagecreatefromjpeg("puppy.jpg");
$size = getimagesize("puppy.jpg");
// let's save a 33% thumbnail
$percent = 33/100;
$image_dest = @imagecreatetruecolor($size[0]*$percent, $size[1]*$percent);
imagecopyresampled($image_dest, $image, 0, 0, 0, 0, $size[0]*$percent, $size[1]*$percent, $size[0], $size[1]);
// modify this final line to add an extra parameter to imagejpeg
imagejpeg($image_dest, "puppy_thumb.jpg");

New, smaller thumbnail puppy

This then results in a new file on the disk, smaller in size and dimensions than the original called “puppy_thumb.jpg”. The original file is not overwritten or modified during this action. We have also removed the header() function call from the first line, since we will no longer be writing the image data to the browser window.

Website design with PHP

It’s quite likely you’ve reached this page because you’re interested in learning how to build your first website with PHP, or modify your existing website to make use of PHP. It’s also quite likely, if you’re just starting out with PHP, or programming in general, that you won’t really know what PHP is exactly, or what it does.

PHP is one of the most widely used technologies for building websites. Alongside the database management system MySQL, it powers some of the most popular and heavily visited sites. The role of PHP in these websites is to construct the pages of text and images you see when you navigate these sites, and it can also be used for even more complex operations behind the scenes. PHP can dynamically construct pages based on user input, so that you don’t need to offer visitors static pages of text, but can instead provide them with information based on their specific requirements.

A user might, for example, select from a drop-down list of items in a shop, and be presented with a detailed description of the selected product, or fill in an email form to contact you directly about a service, bypassing the need to provide your email address on a public website.

If you’re already familiar with PHP, you may already have covered most of the topics in the first part of this tutorial. We will cover some of the fundamentals of programming, including for loops, if…else statements and more. Although some people may be well versed in the use of these programming methods, there may still be information of value. Near the end of each section I will look at each subject in more detail, and there may even be one or two nuggets of information which even the more experienced PHP developer will find useful!

This tutorial won’t aim to cover everything though, and doesn’t aim to replace the more comprehensive PHP references out there - including PHP’s own, extremely useful, online library available through php.net

What is PHP?

It is said that the acronym PHP is recursive, and stands for “PHP: Hypertext Preprocessor”, which would no doubt cause some headaches if you attempted to write it out in full. A more sensible explanation is that it stands for “Personal Home Page”, originally from a piece of software developed by Danish programmer Rasmus Lerdorf to maintain his own personal homepage.

These days, PHP is still used to maintain personal homepages. Also business pages, online directories, online shops… the list goes on. It is an extremely versatile language and, while its critics may say it lacks the langauge processing capabilities of Perl, say, or the complexities of C/C++, there’s no arguing that it is a very capable language for use in creating the underlying code and structure of a great number of websites

How PHP Works. Roughly

The basic idea behind PHP is outlined in the image above. PHP code is stored within PHP Files [1], which are then passed through a PHP Parser [2] that then generates the code necessary to display the webpage [3] you see when you visit a specific URL, like http://www.mywebsite.com/index.php

time() or, the Unix Timestamp

One of the simplest date/time functions in PHP is time(). This simple function takes no arguments, and simply returns a numeric value equal to the number of seconds since the “Unix Epoch”, declared as January 1st 1970 at midnight (GMT) - just an arbitrary date chosen to base timing calculations on when working with dates and times. This gives a start time upon which we can base our time calculations

$time = time();
echo $time; //gives us something like 1219075172

PHP’s date() function

This timestamp can then be used as input to the date() function to format it for improved readability. The date() function takes, as its arguments, a string to define how we wish the formatted time to appear and secondly, a Unix timestamp just like the one returned by time(). It is also possible to use date() without specifying a timestamp and it will use the current time as its source.

echo date("F j, Y, g:i a", 1219075172); //produces "August 18, 2008, 4:59 pm"

The string used in the date() function can contain a number of single letters which are then substituted for their human readable counterparts according to the value of the timestamp. In our case, the following substitutions are made

• F: The full textual representation of the month, August in this case
• j: The day of the month, without leading zeros, e.g. 4, 18, 22
• Y: The full year, e.g. 2008
• g: The current hour, in 12-hour format
• i: The current number of minutes
• a: Either am, or pm, depending on the time

A full list of all the codes, and their textual counterparts can be seen on PHP.net’s date() page here. Extra text can be added to the formatted string as required, but remember to escape any characters which date() will interpret as formatting text.

Make time with mktime()

An alternative to the time() function is mktime(). This function is useful when we wish to use a date/time which is not the current time. mktime() takes as its arguments numerical values representing, in this order - hours, minutes, seconds, months, days, years - and a final value to declare whether daylight savings time is to be taken into account.

$date = mktime(10, 15, 0, 12, 12, 1980); //produces 345464100
echo date("F j, Y, g:i a", $date); //produces "December 12, 1980, 10:15 am"

Saving a PHP file

A PHP file is basically a text file containing all the required PHP code to run a specific program. PHP code can be written with the use of a simple text editor, like Windows Notepad, or the more useful Crimson Editor. All you need to do is type in the required PHP code and save the file with the extension .php

You can create a PHP file yourself by creating a blank text file and simply renaming it with the extension .php. You need absolutely nothing else for this to work as a valid PHP file. Although, as I’m sure you’ll realise, a blank file won’t do anything much of use! First of all, we need to enter some valid PHP code into this file

(Important: Don’t use a program such as Microsoft Word, Frontpage or other more complex word processors to create your PHP file. Although the page might look free of formatting when you save the file, there will be other hidden formatting elements within the file itself that will prevent any PHP code from running.)

This is an example of some PHP code

<?php
//this code is saved in a file named e.g. myphp.php and then
//saved in e.g. c:\local\mywebsite\myphp.php or http://www.mywebsite.com/myphp.php
  $x = 1;
  $y = "b";
  echo "Hello world";
?>

This code is the exact same code that will work as a PHP file on a server, and we’ll take a look shortly at how you can create your very own simple PHP file to run as a basic web-page sample. First though, we need to know where to locate our PHP files.

The location of the PHP file on disk

An important thing for us at this point is to know where to save this .php file for it to be recognised as a valid web-page file. Any PHP documents must be placed within the document root of a website server. In simple terms, this means that on your computer, or on the remote computer that you’ve got set up as a website host, are a number of folders and directories. One of these directories will be set up as the document root, and is usually named c:\local if you’re using your own Windows machine to run the code, or something like /htdocs or /html_root if you’re running on a remote server.

The document root is the base directory from which all the website data is served from. Any sub-directories within this main root directory will show up as sub-folders when you type in the URL

e.g. if you have a folder “mysite” within the c:\local\ folder, you’ll be able to access the URL http://localhost/mysite to see the contents of this folder. Any PHP files within this folder can be accessed by adding the PHP filename to the end. e.g. http://localhost/mysite/myphpfile.php

Similarly with a remote host, a folder like htdocs/mysite will be accessible from http://www.mywebsite.com/mysite and any relevant PHP files in the mysite folder will be at http://www.mywebsite.com/mysite/myphpfile.php and so on

Index.php

PHP files can be named anything you want, according to the filename rules of the operating system you’re using (For example, Windows filenames can’t contain certain characters) - you can have “myphpfile.php”, “biscuits.php”, “cheese_on_toast.php”. But a useful name for a PHP file is index.php

The reason behind naming a php file index.php is that the file “index.php” will always be loaded first when visiting a URL that doesn’t specify a filename e.g. http://www.mywebsite.com - in this case, that URL will automatically look for a file named http://www.mywebsite.com/index.php. This is an extremely useful way of defining a main page, or home page for your site.

In the next section, we’ll make a start on generating our first PHP file, and seeing the results in a browser window.

Adding your first few lines of code

After saving a blank PHP file in your chosen location, point your browser to the URL where your file is located, according to the directory structure and the location you saved the file in. E.g. using the address http://localhost/myphp/myphp.php if you saved the file in c:\local\myphp\myphp.php or http://www.mywebsite.com/mysite/file.php if you saved the file file.php on a remote server in the folder mysite).

After entering this URL, you should see a blank screen appear. This is because we’ve not added anything to the file yet!

Return to your text editor, and add the following lines to the file

<?php
echo "Hello world";
?>

Type it out exactly as it’s written above. I’ll explain the symbols used here in just a moment, but return to the web browser now, and reload the page. You’ll see the following output

Hello world

If you see the above text, then everything is going well! You should now have your first working PHP application. If you don’t see the text above appear on the screen, go back and check the file again. You must enter the code exactly as it appears above. Now, I shall explain what’s going on here

• The <?php and ?> tags are the PHP delimeters. They are used to declare where the PHP code starts, and where it ends. This will be of more importance in the next tutorial which deals with the combination of HTML code and PHP. For now, all you need to know is that these symbols are vital to the execution of the code. It is also acceptable to start and stop these PHP delimiters as often as you like. So, for example, the following code is perfectly valid
  
  

  <?php
  echo "Hello world";
  ?>
  <?php
  echo "Hello world again!";
  ?>

  Note that you can also use the symbolds <? and ?> to express the beginning and end of the code, but the use of <?php and ?> is much more widely accepted as the standard, due to the way most servers interpret the code.

• On the second line, you will see a commonly used PHP command, “echo”, which we’ll look at again later. For now, the important thing to note is the semicolon used at the end of the line. It is absolutely vital, in PHP, to terminate any expression or command with this semicolon, otherwise the code will fail.

If you’re coming from an ASP background (another language similar to PHP, not as widely used but still very popular) you can enable PHP to recognise ASP style tags, like so

<% echo "These tags look a bit different"; %>

Using Comments in PHP

Comments are an excellent way to document your code. They allow for a way to place handy notes and thoughts for yourself alongside your code so that you can pick up where you left off when you return to either add new features or debug the script. Comments also provide an effective way for other developers to understand your thoughts and motivations when working on your code.

Comments can be written in one of three ways as the following examples demonstrate

<?php
/* this is a comment
   it can cover multiple lines */
echo "Yes, it is";
//this is also a comment, but only for a single line
#this is also a comment, but not used as much
echo "I never use it anyway";
echo "You can also.."; //..add comments after statements
echo "As well as.."; /*multiline
  comments */ echo "..and another statement after";
?>

Comments may seem a bit counterintuitive at first. If you’re not used to programming, you might wonder what the point is of adding all that extra work if it does nothing useful. In time though, and with experience of larger projects, you’ll find that all those little thoughts and statements become invaluable when you return to debug code days, weeks, months or years later.

Now it’s time to get down to the real task at hand - actually creating a working web-page using PHP. In this tutorial, I’ll show you how to create a simple web-page to demonstrate how to add a little bit of dynamic jazz to an otherwise static site.

Mixing PHP with HTML

I’m assuming, for this tutorial, and throughout the rest of the tutorials, that you have at least a basic knowledge of HTML - enough to be able to use simple tags such as <br/> (newline), <a>, <form> and so on. If not, why not check out any of the decent HTML tutorials around the web - Google for “HTML Tutorial”

HTML PHP is HTML

One thing to realise here is that an HTML page can function as both an HTML page and as a PHP page. Let me explain:

In the previous tutorial, we saw how a PHP file could be created by using the start and end tags, <?php and ?>. We also saw how these tags could start and stop as often as you wished. Within the context of a standard PHP file, this doesn’t make much sense. After all, what’s the point of stopping and starting the PHP code if we’re just going to be executing more of the same PHP?

The answer lies in the fact that, between those PHP tags, we can output HTML content. Take the following code snippet as an example. This is the full text from a PHP file

A sample PHP file<br/>
<?php
 echo "And here is the second line";
?>

Run this, and we see the output

A sample PHP file
And here is the second line

Now, what’s going on here? You might well have guessed by now, the “echo” command is used to output data to the screen. But there’s no echo command on the first line, so how is this text appearing? And more importantly, you might ask, where’s the semicolon? I did say in an earlier tutorial that any PHP code without a semicolon at the end of each statement will fail. But the important thing to note here is that on line 1, before the <?php tag, that’s not PHP code

Huh? What?

PHP files can contain both static text and PHP code, the important thing to realise is that, whenever the code is between the <?php and ?> tags, it will be executed as PHP code

The next page will go into a little more detail

Just as when defining variables, specific naming conventions must be adhered to. A function name can contain letters, numbers and underscores, and must not start with a number. They are also, like variables, case-sensitive. A (very simple) example:

function my_function(){
  echo "Hello world";
  $a = 5;
  echo "The value of \$a is $a";
}
my_function();

Hello world
The value of $a is 5

• Line 1 : The definition of the function. This declares that you, the programmer, have decided to create a function for use called “my_function”. The empty brackets () will be filled in later, but they are important and you cannot leave them out.
• Lines 2-4 : Inside the braces you can place whatever code you desire
• Line 6 : This is a function call and lets PHP know that we want to execute the function at this point. This differs from the function declaration in that we are not using the function keyword to create a function. This function call can occur anywhere within the code, as long as it occurs after the function has been declared

Arrays

There are times in programming where you need to keep track of many variables at once. Maybe the current time of day, the number of items in a package or the name of a certain product. These variables may all be very similar too though, you might, for example, need to keep track of the names of all employees in a company, or the number of items inside each of a large number of packages. Arrays can be used to keep track of these multiple values from within one variable.

Arrays are a special type of data structure in PHP. They are used to hold multiple values, in a way which allows the values held within to be re-arranged, searched or sorted. Values can also be removed or added easily. Arrays are especially useful when you’re dealing with lists of items, or collections of values that need to be sorted into ascending or descending order.

Creating and manipulating arrays

An array is initialised using the language construct array(), and is assigned to a PHP variable name, in exactly the same way as other scalar variables [reference scalar in previous tut]. Arrays can contain any number of values, each of which can be any of the PHP data types. Here is an example of a simple array

$array = array(1, "two", 3.0, "four");

This will initialise the variable $array as an array containing the values 1, “two”, 3.0 and “four”.

An array like this is known as a Non-associative array because the values are not associated with any specific keys but are instead just numbered numerically, like so…

An example of a simple non-associative array

Displaying Arrays

Once this array has been initialised, we can check the contents of the array in certain ways

1
2
3

echo $array;
print_r ($array);
var_dump($array);

This produces

1
2
3

Array
Array ( [0] => 1 [1] => two [2] => 3 [3] => four )
array(4) { [0]=> int(1) [1]=> string(3) "two" [2]=> float(3) [3]=> string(4) "four" }

Echo is not built to handle complex data structures like arrays. Instead we need to turn to our old friend print_r() - but even then, we’re not getting the full picture. Var_dump() produces the most information about our array, giving us the datatype held in each position of the array.

Associative arrays

Note the numbers in square brackets on lines 2 and 3 in the above example. These numbers correspond to the “keys” of each item in the array. Arrays work by assigning each item a “key-value pair” by which to reference each position in the array. In the above example, the keys are generated automatically, in sequence according to the order in which the values were entered. We can over-ride this behaviour though, and specify our own keys for each value

$array = array(4 => 1, 3 => "two", 2 => 3.0, 1 => "four");

Here, we’ve assigned the entries in the array to keys in descending numerical order.

Another example is an array containing a list of employee names, and their associated job titles

Now, you might be asking, what’s the use of this feature in real code? Well, this gives me a good opportunity to introduce a powerful feature of arrays - sorting.

x + 5 = 7;
from this we can deduce that x = 2

In PHP it works in a similar fashion, except we usually know the value of x, and simply assign it a specific value, such as x = 5. We can then use that value to perform calculations using other symbols and numbers. For example

$x = 5  //x now equals 5
$y = $x + 10  /* y now equals 5 + 10 */

These symbols in PHP are known as variables and require you to follow a specific syntax to use them properly. Once you understand the principles behind them, you’ll begin to see how they form a major component of any PHP application, and can be used to store many things other than just numbers. Let us begin though, by guiding you through a few simple examples of the use of variables.

A simple introduction

A very simple example of the use of a variable in PHP is to hold just one number, e.g.

$x = 5;

All variables in PHP start with a dollar sign, followed by a string of numbers, letters (both lower-case and capitals) and underscores. Variables are also case sensitive, meaning that $Variable is not equal to $variable. The only other requirement of variable naming is that the first digit cannot be a number. These are examples of valid variable names

$variable_name = 5; //valid - integer
$VariableName = 25.5; //valid - floating point
$variable3 = 155; //valid
$_variable_number_four = "value"; //valid - string
$_x = "five"; //valid

These are not valid variable names

$1st_variable = 5; //invalid
$Variable.name = 25; //invalid, cannot have dots in names

Variables are assigned values through the use of the equals sign (=) operator. Once a variable has been assigned to a value, that variable symbol can be used in place of the value anywhere in the code. The value of the variable can also be changed at any point during the execution of the code. The same value can also be assigned to multiple variables at the same time, like so

$a = $b = $c = 5;
echo "$a, $b, $c";

This produces the output

5, 5, 5

Flexible Types

The “type” of a variable is defined by the value you’ve assigned to it. PHP supports a wide range of types, including strings, integers and floats.

$string = "This is a string";
$integer = 5; //an integer value;
$float = 4.55; //a "floating point" value

PHP doesn’t explicitly require that you maintain the same type for a certain variable though. If you tried to assign a string value to a variable which previously contained an integer, you’ll encounter no problems. Similarly with any other types, floating point variables can hold integers or strings and so on.

I will go to the cinema if I have $15 or more to spend tonight

if($amount  >= 15){
  echo "I'm going to the cinema";
}

But, what would you do if you didn’t go to the cinema? There’s usually an alternative…

I will go to the cinema if I have $15 or more. Otherwise, I’ll just stay in and watch TV

This would be represented in PHP as

if($amount  >= 15){
  echo "I'm going to the cinema";
} else {
  echo "I'm a bit skint. I think I'll just stay in and watch Friends re-runs again";
}

The first line sets up the proposition, “What’s the value of $amount?” or, “How much money have I got?”. The curly brackets (or braces) are the containers for each of the outcomes (this is an important syntactical feature of PHP).

What we’re saying here is that the echo statement contained within the first pair of braces (line 2) will be executed if the value of $amount is greater than or equal to (>=) 15

The statement within the second set of braces (line 4) is executed when $amount is less than 15. The “else” operator tells PHP that we want one or the other - not both - dependant on the outcome of the “if” statement

True & False

PHP, much like any other language, uses the two boolean values TRUE and FALSE to represent the outcome of logical expressions. The result of a statement like “$amount >= 15″ will equal TRUE if the variable $amount holds a numerical value which is greater than, or equal to 15 and FALSE otherwise. Here are some other examples of boolean expressions

  5 > 3 //TRUE, 5 is greater than 3
  3 < 5 //TRUE, 3 is less than 5
  4 >= 4 //TRUE, 4 is indeed greater than or <i>equal to</i> 4
  5 != 3 //TRUE, 5 is <i>not equal to (!=)</i> 3
  3 != 3 //FALSE, 3 is equal to 3 - the operand "!=" fails here
  5 == 5 //TRUE, 5 does indeed equal 5

These are fairly banal examples. I can’t imagine anyone would get excited about writing a program to prove that 5 equals 5!

Equality operator (==) & Assignment operator (=)

An important thing to note about the last example is the use of equality operator (==) This is not the same as the assignment operator (=) == is used to check if two values are equal, whereas = is used to assign a specific value to a variable. i.e.

$x = 5; // $x now equals 5
$x == 7;  /* 7 doesn't get assigned to $x
 instead, the whole expression equates to false
 since $x doesn't equal 7 */

We can see this more clearly by looking at the value of each expression as a whole using var_dump()

var_dump ($x = 5); /* int(5) */
var_dump ($x == 7);  /*  bool(false)  */

AND & OR

Sometimes you want to base the outcome of a situation on more than one variable, you wish to know, for example, that two certain conditions will be fulfilled before deciding on a choice of action. Expanding on our cinema example from earlier -

If I have $15 or more AND it is not raining, I’ll go to the cinema. Otherwise I’ll stay in and watch TV

becomes…

1
2
3
4
5

if($amount >= 15.00 && !$raining){
  echo "I really want to see the new Indiana Jones film";
} else {
  echo "It's too wet out, and the episode of Friends where they play 'Fireball' is on";
}

Here, we are using the operator “&&” to represent the expression “and” - similarly, we can use the operator “||” to represent “or”.

This statement is based on two things - firstly, the same condition as before - how much money have I got? Secondly, the condition “!$raining”. The exclamation mark before $raining is means that !$raining will equate to TRUE only if $raining equals FALSE. Confusing? Yes, it is a little bit to begin with, but dealing with logical expressions usually can be!

Think of it this way - it can be rewritten as

if($amount >= 15.00 && $raining == FALSE){

Which makes more sense. You may encounter quite a few situations like this in PHP, where things are written in a specific shorthand that somewhat obscures the meaning, but once you get the hang of it you find it quicker and simpler to use the shorthand version. Take the following code snippet…

Elseif

Sometimes it might be the case that there aren’t just two potential outcomes to a situation. Indeed, as with most scenarios in life, there are many more. Consider yet another modifcation to the above scenario.

I’m going to the cinema if it’s not raining, and I have $15 or more. If it is raining, I’ll stay in and watch TV. Otherwise, if it isn’t raining, but I have less than $15, I’ll go and visit my friends

Here, we have three unique outcomes - going to the cinema, staying in, or visiting friends. We can work this out with logic by introducing another choice in our if statement, as follows

1
2
3
4
5
6
7

if($amount >= 15.00 && !$raining){
  echo "Let's go to the cinema";
} elseif ($amount < 15.00 && !$raining){
  echo "I'm going to visit friends";
} else if($amount < 15.00 && $raining == TRUE) {
  echo "I think I'll just stay in tonight";
}

Notice though, in the final case, we’re doing checks for logical conditions that aren’t actually required, given that we can reason, through logical deduction, that if it’s raining, neither of the first cases will match, so the check for $raining == TRUE is redundant. Likewise, because we know that the value of $amount isn’t relevant either, we can safely ignore that too. A more compact way of writing the above code would be

1
2
3
4
5
6
7

if($amount >= 15.00 && !$raining){
  echo "Let's go to the cinema";
} elseif ($amount < 15.00 && !$raining){
  echo "I'm going to visit friends";
} else {
  echo "I think I'll just stay in tonight";
}

Usually, for the final condition in an if…elseif…else statement, we have already checked for all the relevant conditions we’re interested in, and this final “else” is simply the “default case”

Conditional Shorthand using ? and :

echo ($amount >=15 && !$raining)?"I'm going to the cinema":"I'm going to stay in";

Now what on earth is all that about? Well, it’s exactly the same expression as before - only written in an even more shorthand way. This time, we’re using the conditional operators ? and : to express our situation.

An interesting way to view this is to think of the ? in the statement above in exactly the same way as you would view it in a normal sentence. Let’s reword our thoughts about going to the movies…

Is it dry outside, and do I have more than $15? If so, then I’ll head out. If not, then I’ll stay in

We’re asking a question here - the same question in PHP form reads..

$amount >=15 && !$raining?/* if so */"I'm not going to the cinema":/* otherwise */"I am going to the cinema";

(I added in some extra wording in comments to make it clearer - that might not be fully accepted as valid PHP code though)

Here, we’re using the colon (:) to mean “Otherwise”, so the use of the ? and : operators basically amounts to

  (statement which equals either TRUE or FALSE)?Do this if it's true:Do this if it's false;

If you think about it, you can also imagine how you could place other conditional statements within the expressions to be evaluated in either case, to produce even more complex scenarios

Let’s expand again on our cinema example

I’m going to the cinema if it’s not raining, and I have $15 or more. Otherwise I’ll stay in and watch TV. But, if my friends call me up to go along, I’ll head anyway

1
2
3
4
5

if(($amount >= 15.00 && !$raining) || $friends_have_called == true){
  echo "Let's go to the cinema";
} else {
  echo "Nah, let's not bother";
}

Here, the conditional statement in line 1 has expanded to include an “or” (||) condition - either, it’s not raining and I have enough money, or, my friends have called. If my friends have called, it doesn’t matter about the first expression.

Note as well, that the first condition has been placed in brackets, instead of writing

1

if($amount >= 15.00 && !$raining || $friends_have_called == true){

Which is prone to misinterpretation (That could be saying “If I have more than $15, and it’s either not raining or my friends have called…”) There is a feature of programming called operator precedence which defines which operator is considered first, but when in doubt, always use brackets to make your statements clearer - it helps when other people look at your code too

Switch Statements

One other way of providing a conditional response to an expression is to use the switch() function. This function is especially useful when we expect one of a fixed number of outcomes to occur, and we wish to compare a specific variable to each, to find out which value has occured.

The switch() function also uses the keywords case, default and break, and the exact purpose of these can be seen in the example below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$i = 2;
switch($i){
  case 2:
    echo "i is equal to 2";
    break;
  case 3:
    echo "i is three";
    break;
  case 1:
    echo "i is only one here";
    break;
  default:
    echo "i is neither 1, 2 or 3";
    break;
}

The above code will output

i is equal to 2

Here, we are using the case keyword to declare which of the outcomes 1, 2 or 3 we wish to deal with in each case. The switch statement itself is encased within a pair of braces (lines 2 & 15) and each case statement is simply defined by whatever code appears between the colon (:) and the break; statement.

The final case is named “default”, and this is the case which occurs when none of the previous cases is matched. The usage here is similar to the last sentence I wrote in the section above about “elseif” - the last default case is usually the one that requires no extra conditions to be matched.

This switch statement above is identical in functionality to the series of if statements:

1
2
3
4
5
6
7
8
9
10

$i = 2;
if($i==2){
  echo "i is equal to 2";
} elseif ($i==3) {
  echo "i is three";
} elseif ($i==1) {
  echo "i is only one here";
} else {
  echo "i is neither 1, 2 or 3";
}

But the switch statement is arguably more compact, and a bit simpler to code than the equivalent code using “if”

Footnote : An alternate syntax for If…else statements

if…else statements can also be written using the following syntax

<?php
   $result = 0;
  if($a==1 && $b==2){
    echo "Statement 1";
    $result = 1;
  } else if($a==2) {
    echo "Statement 2";
    $result = 2;
  } else {
    echo "Statement 3";
    $result = 3;
  }
 
  //can be rewritten as...
 
  if($a==1 && $b==2):
    echo "Statement 1";
    $result = 1;
  else if($a==2):
    echo "Statement 2";
    $result = 2;
  else:
    echo "Statement 3";
    $result = 3;
  endif;
?>

Note that, in the second code example, there is no need for any braces round each of the results. All the code to be executed based on the logic expression is contained between each of the if:, elseif: and else: statements

Note as well, it’s vitally important to include the “endif;” statement, to replace the final closing brace.

Switch statements can also be written as

switch($i):
  case 1:
    echo "one";
    break;
  default:
    echo "not one";
    break;
endswitch;

And similar syntactical differences can be applied to while loops, for loops and foreach loops

This way of writing if statements can be useful, and slightly tidier, but is slightly more prone to errors, especially when nesting if statements, and can sometimes produce erratic results

Introduction to Loops

Loops in PHP are very useful when you need to perform repetitions of the same code over and over again, or when you need to ensure that you iterate through all possible values of an array, for example. They come in a few different flavours, the most common being “for” loops and “while” loops. There are a few other more obscure ways to create loops, and I’ll cover them at the end, in the extended section.

The three types of loop I will cover in this section are For loops, While loops and Foreach loops

While loops

While loops are the simplest kind of loop in PHP. They’re pretty much just saying “Do something for a while until a certain condition is satisfied”. You could be saying Stay at work until this project is finished or Keep on running this marathon until you get to the end

The general syntax of a while loop is as follows

while(condition = true) {
  do something
}

A real-world code example of this might be

1
2
3
4
5
6
7
8

$miles_completed = 0;
$race_finished = false;
while($race_finished == false) {
  $miles_completed++;
  if($miles_completed >= 26){
    $race_finished = true;
  }
}

I’ll explain some of the symbols and operations going on here…

• Lines 1 and 2 : we initialise the values of $miles_completed and $race_finished. The code wouldn’t work properly otherwise, as $race_completed has to be equal to FALSE initially to satisfy the while loop in line 3
• Line 3 : The while loop will repeat as long as $race_finished is equal to false. A drawback of while loops is that they can loop indefinitely if you are not careful, and this will cause your application to crash - you can see how this would occur if we didn’t increment the value of $miles_completed or set $race_completed to be true. You’d be running that marathon for ever!
• Line 4 : the expression $miles_completed++; is a way of saying $miles_completed = $miles_completed+1; This can also be rewritten as $miles_completed += 1;
• Line 5 : we check the value of $miles_completed on every repetition of the loop. Once $miles_completed becomes greater than 10 (since we are incrementing the value every time round) then $rage_finished is set to TRUE, therefore breaking the condition that keeps the loop going

Another way of writing while loops is to invoke the “do” statement

$miles_completed = 0;
$race_finished = false;
do {
  $miles_completed++;
  if