OOP: she did it again

There is still much debate about Object Orientated Programming (OOP) with PHP, largely because PHP wasn’t developed as an OOP language, and it works perfectly well as a procedural language for most web applications or websites that you are creating. On top of that, on face value, OOP can seem daunting and overly-elaborate, with many more lines of code needed to achieve something simple, compared to the procedural way.

That said, OOP PHP can become really useful on a community level, because generic-purpose classes can be created with all sorts of uses, such as easily creating word documents, creating pdfs, flash interaction, image/audio manipulation, and, well, basically anything you could dream of.

To get a picture of the power of php classes, you could maybe take a moment to look around the aptly named www.phpclasses.org, where anyone can use or contribute their own php classes with each other, creating a repository far more powerful than a single brain could muster.

So, it’s worth understanding the OOP principals and syntax within PHP, whether you want to start adhering to strict OOP protocols in the future, or if you simply want to understand the basics of OOP in order to be able to dabble into other people’s classes when it takes your fancy.

For this tutorial we’re going to introduce PHP classes, creating a simple class that prints out a reusable, customisable textbox for a website.

The PHP Class

The class is the crux of OOP, and in simple terms is a collection of variables and functions that are related to each other. Here is an example of a lovely PHP class:

And to access the data inside this class, you can use the following syntax:

Here we create a new infobox instance, and then we can echo the variables inside it with the rather exciting “right arrow”, which will become your new OOP best friend. Of course, classes can become a lot more complex, and a lot more useful, but this principle, that the class is grouping two variables together in a family, is the basis for all OOP.

Now we are going to make a class that has a little more purpose. We want to make a class that will print out a textbox with a header and a body text, which has default colours that can be changed using functions.

First of all, we’ll set up some CSS, just to make things look pretty. Note that we’re not defining the infobox’s width or background colour, or the h2 element’s text colour. These will be defined by the PHP class.

Now that this is out the way, we can create a class. The variables of this class will define what can be customised by the user, in this instance, the width of the infobox, the background colour, and the text colour of the infobox’s heading.

Now we need to create a function within this class that will print out an infobox every time it is invoked. Let’s have a look at that:

We are greeted with a new syntax here, “$this->variable.” When operating functions within a class, you can access all the variables that belong to the class with this syntax. So here we use “$this->colour”, to access the variable $colour from the top of the class.

The function output() simply creates an echoed string that contains a div, an h2 tag and a p tag. The tags contain some user defined variables. It also sets the colours and width of the infobox using the default, set variables of the class. Let’s see how we can use this.

Here, we create a new instance of the class, $infobox, and we access the function output() in the same manner as we access the variables of the class, with a right arrow. We pass two variables into the function, one for the title, one for the body, and we end up with an output like this:

Now, what if we want to change the default variables within this class? We can create some new functions that will make this happen.

If we put this into our class, we have a new function to access, that will set the $width variable of the class to our new variable. So we could run:

And now, instead of having the default 300 pixels wide infobox, we have an infobox that is 500 pixels wide. We can create similar functions to alter the background and text colours, and end up with a class like this:

Now we have a class with default settings, and the ability to change all three settings with a function, and then a main function for outputting the data, so whenever an infobox is needed to be echoed into your application you can make it happen from one class. Let’s give it a test run:

Here we output three infoboxes. The first has the default settings, the second has the width changed to 500, and the third has the colours changed to greys and blacks.

And there we have it, your first introduction to php OOP, using the php class to create something practical for your site development. Of course this is very simple and doesn’t even start to touch on the complexity of classes and their power, but it does explain the benefits and theory behind the PHP class, and why it can be more useful than simple procedural methods.

If there’s one thing that the internet has taught us in the twenty or so years it’s been alive, it’s that everybody loves rectangles with rounded edges. It all stems from the age old human condition that we need things in boxes- we need order and division, organisation and categorisation, but at the same time we’re not quite willing to accept our brains are like this. We want to pretend we can “think outside the box,” that we are maverick, free thinking non-comformists.

Che Guevera in a rounded box. "Look Mom, I am an individual!"

We want to pretend we are not putting things in boxes, that we are doing things are own way. The rounded corner is a symbol of our imaginary human individualism, screaming to the world that we are not conforming, we haven’t been forced into the box. But, when all’s said and done, the box remains.

Erm, anyway, pop-psychology out of the way, rounded edges are so successful in web design because computers and design code mean we have to use a grid-based layout of some kind, with divs and spans all in rectangles, and all these boxes start to look tired and dull on the eye. Rounded edges are a nice, quick way to spruce up boxes whilst still being able to maintain the sensible, grid based structure such geometries require.

How do we do it then?

As with everything in web design, there are many ways to achieve your goal here. The old way was to use four corner divs for every box, and use a .png of each corner segment as a background image. I spent many hours in the olden days using this method, only for the client to say they want a different shade of blue for the boxes and I would have to crank up Photoshop and make some more.

Nowadays, with css3 becoming (almost) mainstream, life is simpler. The css mark-up is as so:

So, we see it’s not quite homogenised yet, and to be sure you’re better off putting all four of these lines into your css file. And even then, we have problems with Internet Explorer. My recommended solution for this is the awesome javascript creation CurvyCorners.js. This javascript file will auto-detect if the browser being used can deal with CSS3, and if it can’t it will invoke curved corners on all elements in your CSS file that have border-radius defined.

This is good news, because all you have to do is link the .js file in your header, and do nothing else.

In this day and age we shouldn’t have to worry about rounded corners. If you keep this method in your head you won’t have to worry about it any more. Sooner or later the javascript won’t even be needed as all browsers will be CSS3 compatible, but until that day, use these two easy steps.

Very often we need to take data from an array and display it on a page. And how better to present this than with alternately coloured boxes? They can fit in with the style of your site, break up the data, and make readability that much better. Here we’ll take a look at the best ways to make this happen.

First of all, we’ll style our unordered list with some css, and then create a class for the alternative colour. Here, the regular list item is a lovely shade of pink, and the alternative class is a rather fetching grey.

Next we need to write a loop in php that will take all items from a php array (here named rather aptly $array). There’s many ways to do this, but I’ll be using my favourite method, the foreach statement.

So what’s going on there? First of all, we need to set up a variable called $count, which will count how many times the loop has been made:

As we’re putting this before any loops have been made, we set it at zero. This will be incremented every time the loop is passed. Then we need to wrap everything up in ul tags (for our unordered list), and then create a loop that takes each item from the array as a new variable, called $item. Let’s look at that:

The foreach loop is expanding the array named $array and creating a variable called $item. Next, we create a conditional statement for inside the loop that will check if $count is currently an even number.

This snippet checks to see if $count divides by two. If it does, we will echo a li with class “alt”. If it doesn’t divide by two, we will echo out a standard li tag. Next, we can echo the current array item, with the variable $item, and then close the li tag.

And finally, we need to add one to the variable $count, so that it doesn’t stay on 0.

This is a short way of writing “add one to the variable” and is very useful to remember for php development.

Other methods

Like almost all solutions in php, this is only one of many. There are hundreds of methods that all lead to the same conclusion, but it’s worthwhile picking one now, and sticking with it. It can save time and effort in the future if you have snippets saved up for general tasks like this, and if there is homogeneity amongst your application code it will be quicker to write and easier to edit in the future.
Now then, it’s probably a good time to mention the shortest possible method out there for alternative colour rows in php:

The principle is exactly the same as our detailed method, but it has been shrunk down using shortcodes and concatenation. The $count variable has also been changed to a Boolean so that it can be flipped from true to false in less characters. If you know of a faster way, be sure to comment.

Moving your WordPress site from one domain to another can be a tricky affair if you aren’t overly familiar with MySQL and database handling. Here, I’ll go through a simple way to make it happen, by exporting and editing your MySQL data using phpmyadmin and a text editor.

phpMyAdmin is usually provided by most hosting companies and acts as a nice and easy way to access your MySQL data without having to actually code any, or get your hands dirty.

Step One: Export Your Existing Database

To get your database exported from your existing server or localhost and into a specific file on your computer, you must first log in to your phpMyAdmin area and select the export tab on your database. There’s a heap of options there, but don’t be daunted, as the defaults will be fine. Make sure, however, you check “Save as file”. This will save a file onto your computer containing every single bit of data from your WordPress database. Now you can make the necessary changes to the file.

Step Two: Find/Replace All Occurrences of the Old Domain Name

Open up the .sql file in any text editor. For this you can use Dreamweaver, Notepad, TextMate, Text Edit or anything at your disposal. The only thing to be wary of is that the file size on large sites will be large, heavy and cumbersome on some computers, because of the sheer amount of text involved. If your computer starts wheezing, try and bare with it!

Using the find/replace feature on your text editor, type in your old domain name, and in the ‘replace’ section, put in your new domain name. It might take a little time to complete, depending on your computer, and it normally replaces a few hundred occurrences of your old domain name.

Step Three: Find/Replace All Occurrences of the Absolute Path

Next up is to change the Absolute Path of your WordPress site. This can be a bit baffling,  especially if you have no idea what an Absolute Path is. Just to clarify, your website’s Absolute Path is the place where all of its files live on the server it uses, and it tends to be needed by WordPress for the media gallery uploader and plugins that involve uploading files.

The easiest way to find out your absolute path is to create a php file and write:

When you view this output in a browser, you will find the absolute path, which normally looks something like “/var/www/my-domain”.

Now that you have this new information, replace your current absolute path with your new absolute path in your .sql file. There should only be a few instances of this.

Step Four: Importing the Adjusted Database

Now that we’ve made the necessary changes you can save your .sql file and head to the phpmyadmin control panel on your new domain. Here, make sure you are working with an empty database, or add a new database, and then head to ‘import‘. Pick the edited .sql file from your computer, and let it upload.

Step Five: The End

With the database set up and ready to rock, we can upload all of the files to the new domain, except for config.php. This is the file that tells WordPress how to connect to the database, and as we’ve changed servers the database details will not be correct.

Once everything is uploaded you can head to your-new-domain.com and, thanks to the lack of a config.php file, you will be greeted with a WordPress installation screen:

Now you can follow the lovely WordPress instructions to put in your new database details, and a new config file will be created on your server.