I’m just starting to experiment with Expression Web 3 as a site editor (specifically for editing PHP, CSS and Javascript files) and the first stumbling block was how to set it up so that I can edit my remote files directly without having to create a local version. This is necessary because I don’t have PHP/MySQL and Apache installed on my Windows machine.

Despite the fact that this doesn’t appear to be mentioned in the application help, it’s actually very simple. Just go to File, Open and, in the address bar, type your FTP address. You’ll then be prompted to type in your login details and, assuming this has worked successfully, you’ll then be presented with an Explorer view of your site from which you can pick your file. Simple.

PHP gets a bad press from time to time, largely because its very flexibility is seen as laxness by the tight sphincter brigade. However, just because PHP doesn’t force “best practice” on programmers doesn’t mean you can’t adopt said best practice.

Object oriented programming is much talked about and has many advantages over the old-school line-based procedural code. You’re probably familiar with functions (blocks of code called independently: they used to be called subroutines in the old days). Objects are groups of function which are, to some degree, “self aware”. By this I mean that values can be passed within the objects to allow the object to take the appopriate actions.

Enough of theory, I want to give a concrete example of how using objects can be, in a very practical, sense a timesaver. I’m going to show you how to create a very useful database object which can be used to make connecting to the database, retrieving and storing data much simpler.

Right, open up your favourite editor: mine is PHPDesigner although a good free alternative is PSPad. I’m assuming you have a working MySQL database and want to connect to it. If you’re at all familiar with interacting with MySQL, you know that there are three stages involved in retrieving information: connecting to the database, running the query and processing it. Let’s start by dealing with the first of these and automating the connection.

Create a blank PHP file and give it a name. I tend to use a two part convention: the first part of the name describes the purpose of the class, the second indicates the author. So, in this case, we might call it DbaseSB .php (SB=Scribbleit).

Here’s the inital code:

< ?php
//DATABASE CONNECTION/MANIPULATION OBJECT
//AUTHOR: KEVIN PARTNER
class DbaseSB
{
	private $DB_HOST="localhost";
	private $DB_NAME="mydbname";
	private $DB_USER="mydbuser";
	private $DB_PASSWORD="mydbpassword";
	private $connection;

You can see that we begin with the keyword “class” followed by the name of the class. This MUST be the same as the name of the PHP file. Following this is a series of variable definitions. private indicates that these variables are only accessible within the object: this is for security reasons and because these variables are only needed by the database object.

The variable names should be self explanatory except for $connection which is a variable I’m going to use to store the database connection once it’s made.

Now for the next bit:

function __construct()//CONSTRUCTOR FUNCTION WHICH IS RUN WHEN THE OBJECT IS CREATED
	{
		$this->connection = mysql_connect($this->DB_HOST, $this->DB_USER, $this->DB_PASSWORD) or die("unable to connect to database");

		$db_select=mysql_select_db($this->DB_NAME,$this->connection);

		if(!$db_select)
		{
			die("Database selection failed: ".mysql_error());
		}
	}

This code immediately follows the first block. The __construct magic method is run automatically when the object is created (we’ll see how to do that in a bit) so what this code achieves is to create a database connection automatically using the details you’ve supplied. This connection is then stored in the $connection variable for use later.

You’ll notice that $connection is expressed as $this->connection. The identifier $this represents the current object so what it’s saying is “my copy of $connection” since you could have many objects running at once based on a single class.

Moving right along, this code immediately follows the last block:

	function query($query)
	{
		$querydata=mysql_query($query);
		$this->confirm_query($querydata);
		return($querydata);
	}

	function confirm_query($result_set)
	{
		if (!$result_set) {
			die("Database query failed: " . mysql_error());
		}
	}

The first method (functions are called methods when they’re inside an object, go figure) wraps up any MySQL query and runs it. confirm_query checks to see that a valid result was achieved and, if not, echoes out the error returned.

Now, this might seem like a lot of work just to do some database stuff but the beauty is that you only have to do it once (and you can, after all, copy and paste it from here). This class can now connect to a database and execute a query. All that’s left now is to add some general purpose queries that will shield you from having to remember the MySQL code.

So, let’s now add one such general purpose method:

	function fetchfield($table,$indexname,$indexvalue,$fieldname)
	{
	    $query="SELECT * FROM $table WHERE $indexname=$indexvalue";
	    $querydata=$this->query($query);
	    $fielddata=mysql_fetch_assoc($querydata);
	    return $fielddata[$fieldname];
	}
}
?>

As its name suggests, fetchfield will pull out a single field from a single row of a database.

Ok, that completes our class for now: let’s look at how we would use that in a PHP script. So, create a script (for example “index.php”) in the usual way. For now, I suggest putting it in the same folder as the class but that’s not generally a good idea as it’s best to have your classes all together.

< ?php
require_once("DbaseSB.php");
$dbobject=new DbaseSB();

$userid=1001;

$firstname=$dbobject->fetchfield("users","userid",$userid,"firstname";
echo($firstname);
?>

In the first line, we include the php class file. The second line shows how to create an object from the class. A “class” is the blueprint, the definition of the object. Just as you can build many houses from one blueprint, you can create as many objects as you like from one class and each can have its own variable values etc. Most often, you’ll just create a single copy as here.

Important note:Remember that, in creating (“instantiating”) our object, it automatically connects to the database: you don’t have to carry out that step.

We then define a variable for testing purposes. On the next line, you can see how we access our object’s single method, fetchfield. In this case, the table name is “users”, the index we’re using to identify the row containing the field is called “user id”, the actual value of userid is $userid and the field we want to fetch is “firstname”.

A very simple but powerful example. Now that the object is created, we can use it anywhere on this page without recreating it. Adding new methods makes it progressively more powerful, allowing you to use MySQL without using MySQL, if you see what I mean. That single line of code has replaced at least 7 lines if you don’t include the connection. The more complex the method, the greater the time saving.

Furthermore, each time you add a method it becomes available across your whole site AND you can up and move your entire library to a new site for a new project and all you need to change is the connection information. Convinced yet?

If you’re a web developer or designer you should get yourself over to www.visibone.com. VisiBone sell paper-based, cut down references for designers and developers including everything from colour charts to MySQL commands.

I ordered the “Everything Book” on the 1st April, it arrived (from the US) 2 working days later and it’s one of those products you didn’t know you needed until you saw it. This book contains a colour reference chart on the front cover, HTML character codes, HTML and CSS reference, JavaScript, PHP and MySQL all printed on heavy paper and wire-bound.

The product has been put together beautifully and thoughtfully with the most commonly required stuff at the front. No more endless searching for colour values and HTML entities: it’s all here. I speak as an experienced web developer: I know my PHP and MySQL but I often need my memory jogged and this product now occupies a permanent place on my desk.

When you’re creating a website with lots of pages all using the same look and feel, headers, CSS etc, it obviously makes sense to create a simple template.

Begin by creating a page in XHTML/HTML that looks and works exactly as you wish. Now cut and paste the header into a new file and put it into a folder called /includes/ on your server. This should be saved as something like header.php. Don’t worry that it’s not actually PHP code, that doesn’t matter. Do the same thing for your main navigation (the navigation that will remain the same throughout). You could put that in header.php but I like to keep it separate just in case there are rare cases where the navigation isn’t needed on a particular page. If you have subnavigation that changes section by section isolate that and put it in its own php file and finally, do the same thing for your footer.

You should now have an HTML file with just the content in it. Assuming you’ve used the same file names and structure as me, you’ll need to add the following code to the top of your HTML pages:

<?php
require($_SERVER['DOCUMENT_ROOT'].”/includes/header.php”);
require($_SERVER['DOCUMENT_ROOT'].”/includes/subnav_home.php”);
require($_SERVER['DOCUMENT_ROOT'].”/includes/navigation.php”);
?>

This approach ensures that, whatever the structure of your site, your script can find the php/HTML files it needs to include.

Right at the end of your page add these lines:

<?php
require($_SERVER['DOCUMENT_ROOT'].”/includes/footer.php”);
?>

You should rename the file so that it has a .php extension rather than .html so that your server will process it as PHP.

Test it to see that it still looks the same as the original file and, if it works, you can now create new web pages by simply adding the indicated lines at the beginning and end and then just writing content using standard XHTML between them. The big advantage is that, when you change your site navigation or anything else that appears in those included files, you only have to do it once.

Let’s say that you want to add a file upload facility to your website via PHP. The key to this is to ensure that the permissions on the folder you are copying up to allow PHP to do the copying. This is a classic Gotcha that can waste a whole load of time.

The first thing you need to know is that the folder you’re copying up to must be “Owned” by “Apache” rather than the site owner. In other words, you need to set the permissions on the folder to be owned by Apache. This then leads onto the other question “what is the Apache OwnerID?”.

I spent a good couple of hours trying to find an answer to this question. The owner Id can be found in the configuration files but a MUCH easier way is to create a PHP file containing the line:

<?php
 echo phpinfo();
?>

Run this file in your browser, scroll down to the “apache2handler” section and you’ll see “User/Group” listed. The numbers next to this show first the OwnerId and then the GroupId (usually both the same). Use a tool such as BitVise Tunnelier to log into your web server and set the Owner and Group to this number and PHP will then be able to copy to that folder. Take care only to change ownership of those folders you specifically want to be able to upload files to.

I’ve been using PHP seriously for a while now, and overall I think it’s the most productive programming language I’ve ever encountered. However, one of the things, as a PHP programmer, you need to do on a regular basis is to output HTML to the browser in order to draw web pages.

The problem is that HTML uses the ” (quote) character and so does PHP so, if you want to use a bit of HTML like this:

<p class=”indentedbody”>Here is some text.</p>

you need to handle them specially in PHP.

The simplest way is:

<?php echo(“<p class=’indentedbody’>Here is some text.</p>”);?>

…in other words to replace quotes with single quotes. The main disadvantage is that it means if you want to use a variable in the html (eg to replace the “Here is some text”) you need to concatenate (glue) them together like this:

<?php
$thetext=”Here is some text”;
echo “<p class=’indentedbody’>”.$thetext.”</p>”;
?>

…note the “.” character which concatenates strings. It may not look like too much of a problem but the more variables that need to be inserted, the messier and harder to understand it becomes.

Another option is to “escape” the html quotes like this:

<?php
$thetext=”Here is some text”;
echo “<p class=\”indentedbody\”>$thetext</p>”;
?>

..so the \ has been used to tell PHP that the ” is a literal quote, not the end of a string of characters. Again, this works for small blocks of text but is a major pain in the backside for complex HTML. I’ve worked around this in the past by doing a “search and replace” in my programming environment, swapping all ” characters for \” pairs.

But there’s an easier way and it’s been around for ages. It’s just that almost no-one uses it. Here it is

<?php
$thetext=”Here is some text”;
echo <<<MYHTML
<p class=”indentedbody”>$thetext</p>
MYHTML;
?>

Bascially, what’s going on is that the string “MYHTML” replaces the quotes as the delimiter: in other words, instead of putting ” at the start and end, we put MYHTML. This means that, as long as we don’t use the characters “MYHTML” within the string, we can use double quotes as we like so the whole thing is much more readable and easy to edit.

The heredoc syntax as applied to PHP is a bit fussy so check the manual but this is going to be a major timesaver for anyone using either of the other two techniques.

It seems that my endless search for the ideal PHP IDE has finally…er…ended. phpDesigner 2008 is the most promising environment I’ve seen and even though I’ve only just started using it, it’s already seen Zend Studio Pro and the treacle-like Zend Studio Eclipse confined to the recycle bin.

Remarkably, phpDesigner is the work of one man, Michael Pham from Denmark who’s put it together (perhaps even more remarkably) in Delphi. phpDesigner has lots of productivity tools designed to make coding more efficient, it incorporates tools for editing related technologies such as HTML, CSS and JavaScript and is one of the few tools that, through its excellent syntax tools, built in manuals and code snippets, helps newcomers to learn PHP.

And perhaps the best news is the price (less than forty quid including VAT). There’s a trial version available at http://www.mpsoftware.dk and the product is being actively developed with a beta version currently downloadable for all registered users.

It’s not often that I come across a piece of software that blows me away with its quality and value. I’ve been struggling with Zend’s reasonably featured but unresponsive products and had switched to the (also excellent) Ultraedit but phpDesigner looks like being my IDE of choice, at least for now.

Chart Director is the tool I’ve used for the past year or so for displaying charts and graphs. It can be a little fiddly to get to grips with but the documentation is extensive and you can usually get started by adapting an example. Shown here is a Radar Chart I’ve used for my latest project: it allows for two sets of 6 data points, all scored between 1 and 9 to be overlaid on each other to show differences.

If you create registration forms and the like, you’ll often need to make sure that HTML tags are removed from anything your user types in just in case they’re attempting to be naughty.

What’s needed is a simple way to iterate through all the POSTed values and strip these tags out. It would be even better if some tags (such as <b>) were allowed.

Here’s how to do it:

foreach($_POST as $key=>$value)
{
$_POST[$key]=strip_tags($value,”<strong><b><i><br>”);
}

The specific function is called strip_tags and it takes two values. The first is the string to be stripped and the second is a list of allowable html tags. I’m using the foreach construct to iterate through the POSTed variables and pulling out the key for each array element along with its associated contents. These are then stripped of HTML and then the key value is used to replace the existing array element with the stripped one.

Short and sweet, just like this review, if you want to learn MySQL you need “MySQL Crash Course” by Ben Forta. A little gem. Its ISBN is 0-672-32712-0 or click the image to order.