Now users can easily post LinkedIn jobs ads on their site, and Copia will sort out the more intricate details, needing just the API key and Company ID from the social networking site, and users can set the job title, location, email etc. via the CMS (see below).

This feature appears in the CMS along with the WYSIWYG editor, Google Maps module and News Article features, and is a quick and easy way to post new career opportunities on your site, taking advantage of LinkedIn’s ever increasing popularity.

As you will know, there are a number of reasons you could get an error in PHP. However, sometimes you will want something to be flagged as an error if it’s going to cause problems in how your script works further down the line, and for this we can use the trigger_error() function within an if() statement to bring up an error.

For example, consider the following code:

<?php

numberCheck(20);
numberCheck(6.2);
numberCheck(-10);

Here, the initial function creates a warning (E_USER_WARNING) if the the number isn’t an integer (whole number), and a fatal error (E_USER_ERROR) if the number is negative. The error then gets processed through to the error handler (as discussed in the last post) and is outputted in an easily legible form. Of course, when testing these error handlers, it is important to remember that anything that follows a fatal error will not run. It is also possible to create notices, using E_USER_NOTICE.

I was going to discuss exceptions in this post, however, it’s a fairly big topic and probably warrants its own post, so apologies if this one is a little short, but next time I will go over exceptions, what they are and when to use them.

One thing that becomes clear fairly quickly when learning PHP is that you are going to get errors, and sometimes these can be hard to decipher. PHP comes with an error handling API that can be used to identify and resolve errors.

Errors in PHP come in three basic forms:

• Notices are minor errors that will not break the site, such as an undefined variable, that by default will not display the error the user.
• Warnings are a slightly bigger deal, they will not abort the code but they will display an error message to the user by default. An example of a warning is if you were to try and include() a file that didn’t exist.
• Fatal errors are critical errors, and will abort the code i.e. any code that follows will not be run. Fatal errors can occur when calling a function that does not exist, or if there are syntax errors such as a missing semi-colon.

What’s cool about these errors is that they create a set of variables that are ready to be used in conjunction with the set_error_handler() function to create front end error messages.

In order to do this, you must create a function which determines what to do with the following variables: $type, $msg, $file, $line, $context – all of which are fairly self-explanatory.

So for example, consider the following code:

<?php
set_error_handler('errormsg');
$string = 'this will break the code';

";
echo "Something messed up up, please contact "?><a href="mailto:youname@youremail">me
";
echo "Please quote the following:<br />";
echo "Error code: ".$type."<br />
Error message: ".$msg."<br />
Script name and line number of error: ".$file.":".$line."<br />";
$variable_state = array_pop($context);
echo "Variable state when error occured: ";
print_r($variable_state);
}

Here, the details of the error are pulled and defined by the errormsg() function, and rearranged in a manner that will make (at least some) sense to the user. This works for warnings, but not for fatal errors, which I will go over next time.

XML stands for Extensible Markup Language and is used for encoding-documents in machine-readable form. It is the basis for many languages and programmes that you are likely already familiar with, such as Microsoft Office, RSS and HTML. Like HTML, it is all based around tags, using less-than and greater-than symbols. The key difference is that, in XML, you define your own tags and then work out what to do with them later, and we can do this using PHP 5 and an extension known as SimpleXML.

SimpleXML works by converting XML documents into objects, and turning the elements within the file into object properties, free to be accessed by standard object notation. It is worth noting again that this is an extension of PHP, and therefore your PHP build must support it.

To get you started, here is a basic XML script, let’s call it ‘film.xml’:

<?xml version="1.0"?>
<film>
<title>Apocalypse Now</title>
<setting>the Vietnam War</setting>
<characters>
<protagonist>Captain Willard</protagonist>
<antagonist>Col. Kurtz</antagonist>
</characters>
<release>1979</release>
<director>Francis Ford Coppola</director>
</film>

As previously stated, we can use SimpleXML to pull information from this file, and as the name suggests, it’s really quite simple:

<?php

//access data
echo "Film: ".$xml->title."<br />";
echo "Release date: ".$xml->release."<br />";
echo "The film is about ".$xml->characters->protagonist." and ".$xml->characters->antagonist." in ".$xml->setting;

As you can see above, we first load the xml file using the simplexml_load_file() function, which parses the XML file into a PHP object, with each element becoming a property of that object.

On top of this, it is also to work in the other direction, and write information into the file, like so:

<?php

// write new data into the file
file_put_contents($file, $xml->asXML());

One thing you will need to be sure of is that, since you are using PHP to change a file, the permissions for the file must be set to public (777).

So now you know the basics of how to pull information from an XML file using PHP, and how to put it back in again.

As previously mentioned, phpMyAdmin is an online application for managing your MySQL databases using PHP. It is very powerful, and can create, modify or delete databases, tables, fields or rows of your databases, by generating and executing MySQL statements. The first version to be released was version 0.9.0 in September 1998, and is, at the time of writing, on version 3.4.0 – released in May 2011.

To install phpMyAdmin, first you must download it from the website. Uncompress the folders, including subdirectories, into your webserver’s document root (or your local machine, if you intend to work locally and upload via FTP later). You must ensure that the scripts are set to have the appropriate owner, then you can configure your installation. You can do this by editing the config.inc.php file, but now you also have the option to use an inbuilt setup wizard by creating a folder, config in the phpMyAdmin directory, and then going to http://your-server/where-phpmyadmin-is/setup/ in your browser. After completing the wizard, you should be able to access phpMyAdmin through your browser. Bear in mind that, as of yet, there are no security settings. For more information about securing your databases, see the official documentation.

Now that you have set up phpMyAdmin, you should see a list of your databases down the left hand side, and a main menu at the top. By selecting the databases from the left, you can view or edit them. You can use the SQL tab in the main menu to run MySQL scripts, and use the Export and Import tabs to generate scripts, allowing you transfer data or tables between databases easily, which is can be very useful if you are running multiple sites from the same content management system.

That’s all for phpMyAdmin, but there is a lot more to cover, so I would recommend checking the documentation for further how-tos.

Next time there will be some actual PHP code, I promise.

PHP is a fantastic web programming language, but much in the way that to get the most out of HTML, it’s a good idea to get into CSS, to get the most out of PHP, it’s a good idea to get acquainted with MySQL.

MySQL is a structured query language, a type of language used for managing data in a ‘relational database model’, i.e. a database where both the data and the relationships between the various data is stored in tables. It is the backbone of many sites where content is updated on a regular basis, including social networking sites like Facebook, message boards, and content management systems such as WordPress.

As an example, if you were to create a new post on a WordPress-powered blog, the moment WordPress automatically saves a draft, the content of the post (including the title, tags, categories and post settings) get inserted into the MySQL database. If this post is published, or if you click ‘Preview post’, PHP will request this information from the database and print it out into the browser, using the template set out by the PHP, HTML and CSS.

The tables themselves look like ASCII images, in the sense that they are a drawing made up of text characters:

To interact with the MySQL database, we can embed SQL into our PHP scripts, for example:

<?php

mysql_query("CREATE DATABASE peopledb;

INSERT INTO 'names' VALUES (1, 'John', 'Smith');
INSERT INTO 'names' VALUES (2, 'Joe', 'Bloggs');
INSERT INTO 'names' VALUES (3, 'Jane', 'Doe');
INSERT INTO 'names' VALUES (4, 'Mrs', 'Marple');
INSERT INTO 'names' VALUES (5, 'Homer', 'Simpson');
INSERT INTO 'names' VALUES (6, 'Honey', 'Monster');");

As you may have guessed, the first section of the query is creating the database. MyISAM is the default storage engine used by MySQL. The second section is inputting the information into the table.

There is a LOT more to say about MySQL and using this information alone will not be enough to use it in your project. An extra snippet of code you will need to familiarise yourself is used to connect your site to the database:

<?php
$host = "localhost";
$user = "test";
$pass = "test";
$db = "peopledb";

These variables will depend on how the website is set up, i.e. where the site is hosted, what the username is, what the password is and what the database is called. Fortunately, a variety of open source applications have been set up to make this process a lot easier and next time I will go over one of the best ones, phpMyAdmin.

For this PHP Basics post, I will be borrowing, but editing, some of the code I used in the last post, An introduction to OOP – specifically adding a ‘weight’ property, and an ‘eat’ method, which will come in useful later on.

<?php

$bart = new Character;
$bart->name = "Bart Simpson";
$bart->age = "a kid";
$bart->job = "hell raiser";
$bart->weight = 65;

The addition of these allow the code to adjust the properties within the class to make them more dynamic. For instance, assuming that weight and eating are inextricably linked, it makes perfect sense that if one of our Characters were to eat a certain amount of food, their weight should increase with it. So now, we can make the Characters “eat”:

<?php

// retrieve new weight
echo $homer->name." now weighs ".$homer->weight."lb<br />";
echo $marge->name." now weighs ".$marge->weight."lb<br />";
echo $bart->name." now weighs ".$bart->weight."lb";

What we should get from this is the following:

Homer Simpson weighs 239lb
Marge Simpson weighs 135lb
Bart Simpson weighs 65lb
Homer Simpson is eating 5lb of food
Marge Simpson is eating 4lb of food
Homer Simpson is eating 3lb of food
Bart Simpson is eating 5lb of food
Homer Simpson is eating 10lb of food
Homer Simpson now weighs 257lb
Marge Simpson now weighs 139lb
Bart Simpson now weighs 70lb

It is worth noting that with PHP5, a new concept of visibility was introduced into the object model. You may notice in the class definition that the Character properties are all preceded with the word, public. This allows the calling script into the object instances and manipulate them. There are two other options, private and protected, which prevent the script from manipulating the class. The former meaning that the properties can only be accessed by the class that defines it, and the latter meaning that properties can only be accessed within the class, or by inherited and parent classes. However, this is all fairly complicated so I shan’t go through it just yet.

Next up is an introduction to MySQL databases, a topic which comes with something of a difficulty spike, but is ultimately an incredibly useful tool for PHP programmers, and is essentially what allows many message boards and social networking sites to exist.

Last time I spoke about functions, and while there is still a fair bit to say on the matter, I’m going to move forward a little and talk about OOP, as it’s a fairly important part of programming, especially in PHP 5 onwards. It stands for ‘Object Oriented Programming‘, and is the basis of PHP frameworks such as the Zend Framework.

OOP revolves around classes, objects and methods. A class is a set of program statements that perform a specific tasks, and generally feature both variables and functions. Objects are the specific instances in which classes appear. A method is a predefined function of the object. Once the class has been defined, we can bring it in as much as we like, and each time we bring it in, it is a separate object, and can be affected independently of other objects.

The key point behind object orientated programming is that it is easily updatable and editable. To see OOP in action, see the following example:

<?php

// now we define the methods
public function sleep() {
echo $this->name." is sleeping<br />";
}
public function work() {
echo $this->name." is at work<br />";
}
public function home() {
echo $this->name." is at home<br />";
}
}

Now we can use this class as a template and apply individual characteristics to each object:

<?php

$homer->work();
$homer->sleep();
$marge->home();
$bart->home();
$bart->sleep();

You will notice that there are a few functions that don’t come into play. I will use this same code next time and go over some more things that can be done with object orientating programming.

“Function” is a word that you will have read a lot if you have been reading this series, or if you have been reading up on PHP elsewhere. A great deal of what we do in PHP relies on calling functions. For instance, just last week we used the fopen() function to open a file. They’re easily spotted by the pairs of brackets that sit at the end of them. So it seems odd, then, to do a blog post on functions when we’re already quite well acquainted with them. It seems odd, that is, until you realise that in PHP, we also have the power to create our own functions.

To give the term a proper definition, a function is a set of statements that can be called from anywhere within the program. This is a massive time saver as it means you can reuse sections for common tasks. A very basic function could look something like this:

<?php
function yesYouCan(){
echo "Yes you can!<br />";
}
// now we can call this whenever we want
echo "Can I make my own functions?<br />";
yesYouCan();
echo "Can I kick it?<br />";
yesYouCan();

As I mentioned, this is a very basic function and one that is not of much use to anyone. That is partly down to the fact that all it does is echo out a statement, but it is also because no arguments have been defined. Arguments allow us to bring variables into the equation, and we can also define variables within the function.

For instance, if we were to create a program that said how many biscuits were left in the pack, we could create a biscuits() function like so:

<?php
// define the function, with the variables within the brackets
function biscuits($type, $eaten, $total){
$amount = $total - $eaten;
echo "<strong>$type:</strong><br />
$eaten $type biscuits out of $total have been eaten, there are $amount left<br />";
}

biscuits('Nice', 2, 25);

Naturally, the sky is the limit as to how complex these functions can get (although it is important to remember that the more complex the code is, the slower it will run). These were simple examples, but I will go into detail about more complex functions in the future.

Last time I closed by showing you how to open a file and separate the lines into an array using the file() function, which can potentially be very useful and opens up a lot of possibilities. However, sometimes you don’t want an array but do not want to go through all the effort of opening the file, defining the handle, and reading the file. Thankfully, the file_get_contents() function does exactly this, and is incredibly easy to use, as shown below:

<?php
// set the file
$file = 'file.txt';
// read the file
$contents = file_get_contents($file);
echo $contents;

Where it gets more interesting, however, is with the include() function. These allow you to pull in other bits of code, which can be used multiple times. So for instance, if you were to create a file for the header:

<html>
<head>
<title><?php echo $title ?></title>
<h1><?php echo $title ?></h1>
</head>
<body>

and then a footer file:

<p>Copyright blah blah blah <?php echo date("Y", mktime()); ?></p>
</body>
</html>

and called them header.php and footer.php respectively.

Then we can create a script that can pull these two files in to make a complete page:

<?php
// define the title
$title = 'The include function';
// include the page header
include('header.php');
?>
<p>Then you put your content here</p>
<?php
// include the footer
include('footer.php');

It is worth noting that there are alternatives to the include() function. There is the require() function, which works in much the same way, except for the fact that if it cannot find the file, it was cause a fatal error, whereas include() will continue to run the script. In addition to these, there are include_once() and require_once() which, predictably, are identical to their counterparts with the exception that they ensure that the file is only pulled in once.

We know how to read and open a file, but of course, writing a file is also possible, using the fwrite() function. This works in much the same way as reading a file – first you must define the file, then open it, and then write into it, like so:

<?php
// set file to write
$file = 'newfile.txt';
// open file, and use the 'w' mode to set it to write
$fh = fopen($file, 'w');
// write to file
fwrite($fh, "This file didn't exist before but now it does");
// close file
fclose($fh);

Also like reading a file, there is a shortcut to do so, which was included in PHP 5 – the file_put_contents() function, as shown below:

<?php
// set file to write
$file = 'anotherfile.txt';
// write to file
file_put_contents($file, "I made this file even quicker than the last one!");

That’s all for now, but there is still plenty more you can do with files, such as status checks and uploads which I will go over in the future.