For those who don’t know, Caffeine PHP is a lite-weight PHP 4 and PHP 5 framework. It’s an open source project and hosted on Google Code.

Caffeine PHP 2.1 has some exciting new features:

• Full documentation in PDF eBook
• URI Routing
• An anchor utility function for easy URL creation
• The ability to use functions or classes in a controller (not just classes)
• Autoloading controllers, models and libraries (not just libraries)
• Checks for illegal URL characters

Among the above features, Caffeine’s code has been revised to work smarter and faster then before.

You can download Caffeine PHP 2.1 here.

What do you think of the new release?

Before you start to glaze over, let me just state that PHP Classes aren’t complex if you learn them properly. A lot of the time, new programmers will try to learn inheritance, scope etc. right of the bat. I’d be having bad dreams too!

My approach is to teach you in tid-bits. Enough to satisfy those cravings, but won’t cause indigestion.

For the duration of this article, I’ll assume you at least know the basics of PHP (variables, functions etc.)

So What’s A PHP Class?

Good question. A PHP Class is nothing more then a bunch of functions, available in one location. Usually these functions do similar or related things.

An example would be a collection of car functions. One tells you how much gas you have, the other tells you how fast you’re going and another tells you how far you are from your destination.

Thats it! Not so scary is it? (you can put away your teddy-bear now)

Ok, So What’s An Object?

Ah, now this is where a lot of new PHP programmers get confused. Isn’t an object the same thing as a class? What the heck is the difference?

An Object is a copy of a Class. Think of a Class as a mold. Once you have the mold built, you can make as many copies as you want. I’ll say it again. An Object is a copy of a Class.

What Are Object Methods?

During your journey into PHP classes and objects, you may have come across the term “class method” or “object method”. What are these?

That’s easy too! A Method is nothing more then a function inside a class. When a function exists by itself, its called a function. When a function exits inside a class, its called a method.

What Does A Class Look Like?

As I said before, classes are collections of functions. Before we look at the structure of a class, lets create the car functions we discussed previously.

// Returns how much gas we have
function check_gas()
{
    $gas = 'Half Full';
    return $gas;
}
 
// Returns how fast we're going
function check_speed()
{
    $speed = '100MPH';
    return $speed;
}
 
// Returns the distance remaining
function distance_remaining()
{
    $distance = '20 Miles';
    return $distance;
}

As you can see, these functions are pretty straightforward. One obvious limitation is they aren’t very dynamic.

Now lets take a look at a class. When you create a class, you need to give it a name. Since we’re using a collection of car functions, we’ll call our class “Car”.

// Define our class as "Car"
class Car {
 
    // Returns how much gas we have
    function check_gas()
    {
        $gas = 'Half Full';
        return $gas;
    }
 
    // Returns how fast we're going
    function check_speed()
    {
        $speed = '100MPH';
        return $speed;
    }
 
    // Returns the distance remaining
    function distance_remaining()
    {
        $distance = '20 Miles';
        return $distance;
    }
 
}

As you can see, all we’ve done is wrapped our car functions inside a class. A class is defined similar to a function. You start with “class” instead of “function” and remove the parenthesis “()”.

Creating Copies Of A Class

Before we continue, I should give you the technical term for creating copies of a class. Its called “Instantiation”. Fancy programmer jargon for “Copy”. To create an Object of a class, you “Instantiate” it. Glad that’s out the way.

So we’ve looked at how to create a class (our mold). How do we create copies of the mold? Well, its easier then you might think. Here’s how it’s done.

$CarObject = new Car();

As you can see, we’ve created a variable called $CarObject. We then gave it a value of new Car. The “new” keyword is how we create copies of a class. The new keyword is followed by the class we want to create a copy of, followed by parenthesis.

Lets say we had a class called Shoes.

class Shoes {
    // An empty class...
}

We could create objects of it like this:

$Shoe1 = new Shoes();
$Shoe2 = new Shoes();

Using PHP Objects

Great, so now you’ve created a class called Car, and created an object from it. Now lets take a look at how to use it.

To call an objects methods, you use the variable name of the object, followed by a “->” and the method you want to call. Here’s what it looks like:

$MyCar = new Car(); // Create a new copy of the class
$MyCar->check_gas(); // Call the check_gas() method

Simple huh?

Object Properties

As you may have noticed, our class is still very limited. All the values for our gas, speed and destination are hard-coded and can’t be changed. Lets make our class more dynamic by adding properties.

What are object properties? Object properties are variables that exists within the class. Object properties can be accessed from any of that objects methods or by the object its self.

To access a property from within the class, we use the “this” keyword.

Lets update our Car class to use properties.

class Car {
 
    $gas = 'Half Full';
    $speed = '100MPH';
    $distance = '20 Miles';
 
    // Returns how much gas we have
    function check_gas()
    {
        return $this->gas;
    }
 
    // Returns how fast we're going
    function check_speed()
    {
        return $this->speed;
    }
 
    // Returns the distance remaining
    function distance_remaining()
    {
        return $this->distance;
    }
 
}

We’ve moved the variables $gas, $speed and $distance out of their functions and into the class. These are now object properties.

The beauty of properties is when you update them, it effects the entire object. Lets try it now.

$Minivan = new Car(); // Create a new copy of our car class
echo $Minivan->check_gas(); // Check the gas (outputs "Half Full")
$Minivan->gas = "Empty!"; // Update our gas property
echo $Minivan->check_gas(); // Check the gas again (outputs "Empty!");

See how easily we where able to check the gas, update it, and check it again? Now lets try it with multiple Car objects.

$Minivan = new Car();
$Truck = new Car();
 
echo $Minivan->check_gas(); // Half Full
echo $Truck->check_gas(); // Half Full
 
$Minivan->gas = "Empty!";
 
echo $Minivan->check_gas(); // Empty!
echo $Truck->check_gas(); // Half Full

Notice that when we update the Minivan’s gas, it doesn’t effect the Truck. This as an important and powerful feature of objects. Changing one object will not effect the other.

Final Thoughts

You did it! You’ve created your own class, created copies of it, gave them properties and accessed their methods! You’re on your way to object-oriented leetness!

To wrap things up, we’ll quickly go over the concepts again.

• A class is a collection of functions
• An object is a copy of a class
• An method is a function inside a class
• An object property is a variable within the class

Try playing around with the Car class. Create a bunch of different objects, update the gas, speed and distance, then display them to the browser. Also try creating new methods that perform a new action. An example would be a method that turns the air-conditioning on and off.

You’ve learned a lot, but your still just scratching the surface. In the coming article, “A Beginners Guide To PHP Classes & Objects - Part 2″, I’ll show you how to really put your objects to work! Make sure to check back soon or subscribe to the RSS feed.

The Entire Class

Here’s the entire class we created throughout this tutorial. Save it in your favorite text editor and play around. If you get stuck, feel free to post your question in the comments!

// Define our class as "Car"
class Car {
 
    $gas = 'Half Full';
    $speed = '100MPH';
    $distance = '20 Miles';
 
    // Returns how much gas we have
    function check_gas()
    {
        return $this->gas;
    }
 
    // Returns how fast we're going
    function check_speed()
    {
        return $this->speed;
    }
 
    // Returns the distance remaining
    function distance_remaining()
    {
        return $this->distance;
    }
 
}
 
$Minivan = new Car();
$Truck = new Car();
 
echo $Minivan->check_gas(); // Half Full
echo $Truck->check_gas(); // Half Full
 
$Minivan->gas = "Empty!";
 
echo $Minivan->check_gas(); // Empty!
echo $Truck->check_gas(); // Half Full

Live Demo

Features

• Supports Wordpress 2.2 - 2.6.2
• Supports PHP 4 and 5
• Supports JPEG, GIF and PNG file types
• Easily adjust thumbnail and photo size in settings page
• Crop photos or size proportionally
• Easily customizable with CSS

Plugin Installation

The installation procedure is similar to most other Wordpress plugins. Unzip the file and upload its contents to your Wordpress plugin directory. Make sure you keep the directory structure intact. Once uploaded the files should be located at:

/wp-content/plugins/G4B_gallery/[php_files_here].

In order to upload photos, your upload directory MUST BE WRITABLE. When installed, the plugin will automatically create a directory within your plugin directory for storing uploaded photos. The default location is:

/wp-content/uploads/g4b_gallery

Usage

To include your photo gallery on any page or post, type in the keyword:

{g4b_gallery}

When the content is loaded, the plugin looks for this keyword, and swaps it with the photo gallery dynamically. To remove the gallery from that page or post, simply remove the keyword.

If you would like to embed the plugin using PHP, call the function:

echo G4B_gallery_view();

The function does not have to be within the Wordpress loop.

Styling with CSS

Style your gallery easily by editing the CSS file. The CSS file is located at:

/wp-content/plugins/G4B_gallery/G4B_gallery_view.css

Bugs & Suggestions

If you run into any bugs or have some suggestions, please post them in the comments. That way others can see if the same issue has already been submitted. Thanks!

Download

Download G4B Photo Gallery on Wordpress.org

Today I’m going to show you how to write your own MySQL class in PHP 5. We’ll be using the standard mysql_connect and mysql_query functions to ensure compatibility across multiple configurations.

The Breakdown

Like any experienced programmer will tell you, you should come up with a battle plan before jumping into code. As tedious as it may seem, it undoubtedly saves you time and frustration in the long run.

Object variables

A variety of object variables will be required to hold information while we work with our database.

1. $dbConn: Database connection link
2. $dbSql: Store the loaded SQL statement
3. $dbQuery: Store reference to last query
4. $dbBind: Stores bound hooks and values

The connect() Method

The connect method will be used to connect to our MySQL database.

The prep() Method

The prep function will be used to load SQL statements into the object and store them in an object variable.

The bind() Method

As with most queries, you’ll need to pass some parameters within your SQL statement. That’s the role of the bind method. The bind method provides a way to inject values into your SQL statement via the use of hooks. Bound values should automatically be cleaned to avoid SQL injection attacks. We’ll cover this in more depth later.

The run() Method

The run function does as you may expect; it runs the SQL statement we loaded with the prep method. The run function will return the number of rows affected by the statement.

Helper Methods

The helper methods will perform common tasks such as get all results, get only one row or count the number of affected rows.

The Core Class

Now that we have an outline of what our class looks like, lets get coding. First we’ll create the class core. In this example, our class name will be MyDB, but you can make it anything you want.

class MyDB {
 
    private $dbConn;             // Database connection link
    private $dbSql;              // Store the loaded SQL statement
    private $dbQuery;            // Store reference to last query
    private $dbBind = array();   // Stores bound hooks and values
 
}

The connect() Method

Ok, so we have our class core. Lets add the connection method to link in our database. Add the following method to your class file.

public function connect($dbHost, $dbName, $dbUser, $dbPass)
{
    $this->dbConn = mysql_connect(
        $dbHost,
        $dbUser,
        $dbPass
    ) or die(mysql_error());
    mysql_select_db($dbName, $this->dbConn) or die(mysql_error());
}

For simplicity sake, I’ve used die functions to handle errors. Another approach would be to use PHP 5’s Exception handler.

The prep() Method

As we stated in the class break down, the prep() method will be used to load our SQL statement into an object variable. Add the following method to your class.

public function prep($sql)
{
    $this->dbSql = $sql;
}

A simple but important method.

The bind() Method

The bind method is where our class starts getting juicy. We’ll be using this method to load values into our SQL statements via the use of hooks.

The first parameter defines the hook to look for, and the second parameter defines the value to replace the hook with. Values loaded with the bind method should automatically be escaped to avoid SQL injection attacks.

Add the following method to your class file.

public function bind($hook, $value)
{
    $this->dbBind[$hook] = $this->escape($value);
}

As you can see, we’re replacing the hook ($hook) with the value ($value). We’re also using a method we haven’t created yet, called escape(). This method will be used to fix any malformed SQL strings. We’ll be creating the escape() method next.

The escape() Method

As stated above, the escape method will be used to fix any malformed SQL strings, and prevent possible SQL injection attacks. The method will be private as its only used by other methods from within the our class.

private function escape($value)
{
    if(get_magic_quotes_gpc())
        $value = stripslashes($value);
    return mysql_real_escape_string($value, $this->dbConn);
}

The run() Method

Now that we have all the pre-steps to our query, lets complete it with the run method. This method will run the SQL string loaded with the prep method, and assign the returned query reference to our $dbQuery object variable. The run method will also return the number of rows affected by the query.

public function run()
{
    $sql = $this->dbSql;
    if(is_array($this->dbBind))
        foreach($this->dbBind as $hook => $value)
            $sql = str_replace($hook, "'" . $value . "'", $sql);  
    $this->dbQuery = mysql_query($sql) or die(mysql_error());
    $this->dbBind = array();
    return $this->numRows();
}

As you can see the query is run while any errors are handled with the die function. Any values set with our bind method are loaded into the SQL statement. A method we haven’t created is being used as well. The numRows() method is used to determine the number of rows affected by the last query. We’ll be creating this and other “helper” methods next.

Helper Methods

The helper methods will be used to perform common tasks on query results. These include fetching all rows, fetching a single row and returning the number of affected rows.

public function fetchAll($type = MYSQL_ASSOC)
{
    $tmpArr = array();
    while($row = mysql_fetch_array($this->dbQuery, $type))
    {
        $tmpArr[] = $row;
    }
    return $tmpArr;
}
 
public function fetchAssoc()
{
    return mysql_fetch_assoc($this->dbQuery);
}
 
public function numRows()
{
    return mysql_num_rows($this->dbQuery);
}
 
public function insertId()
{
    return mysql_insert_id($this->dbConn);
}

Usage

Phew, we’re done. Lets take this baby for a whirl. First we create our SQL statement and load it with the prep method. Then we’ll bind some values using the bind method and run it. We’ll also get the query results using some of our helper methods.

// Load our class and instantiate
require('MyDB.php');
$MyDB = new MyDB();
 
// Make the connection
$MyDB->connect('localhost', 'demo_database', 'demo_user', 'demo_password');
 
// Load SQL statment into object
$MyDB->prep('SELECT * FROM demo_table WHERE id = :id');
 
// Bind a value to our :id hook
// Produces: SELECT * FROM demo_table WHERE id = '23'
$MyDB->bind(':id', 23);
 
// Run the query
$MyDB->run();
 
// Get some results
$row = $MyDB->fetchAssoc();
$rows = $MyDB->fetchAll();
$count = $MyDB->numRows();

The Finished Class

class MyDB {
 
    private $dbConn;             // Database connection link
    private $dbSql;              // Store the loaded SQL statement
    private $dbQuery;            // Store reference to last query
    private $dbBind = array();   // Stores bound hooks and values
 
    /**
     * Used to strip slashes and escape strings
     */
    private function escape($value)
    {
        if(get_magic_quotes_gpc())
            $value = stripslashes($value);
        return mysql_real_escape_string($value, $this->dbConn);
    }
 
    /**
     * Handles connection to the database.
     * Die functions are used to catch any errors.
     */
    public function connect($dbHost, $dbName, $dbUser, $dbPass)
    {
        $this->dbConn = mysql_connect(
            $dbHost,
            $dbUser,
            $dbPass
        ) or die(mysql_error());
        mysql_select_db($dbName, $this->dbConn) or die(mysql_error());
    }
 
    /**
     * Loads a raw SQL string into the object $dbSql variable
     */
    public function prep($sql)
    {
        $this->dbSql = $sql;
    }
 
    /**
     * Load bound hooks and values into object variable
     */
    public function bind($hook, $value)
    {
        $this->dbBind[$hook] = $this->escape($value);
 
    }
 
    /**
     * Runs the SQL string in $dbSql object variable
     */
    public function run()
    {
        $sql = $this->dbSql;
        if(is_array($this->dbBind))
            foreach($this->dbBind as $hook => $value)
                $sql = str_replace($hook, "'" . $value . "'", $sql);  
        $this->dbQuery = mysql_query($sql) or die(mysql_error());
        $this->dbBind = array();
        return $this->numRows();
    }
 
    /**
     * Used to fetch all rows form the last query in an
     * array. You can define the return type. Default is
     * MYSQL_ASSOC
     */
    public function fetchAll($type = MYSQL_ASSOC)
    {
        $tmpArr = array();
        while($row = mysql_fetch_array($this->dbQuery, $type))
        {
            $tmpArr[] = $row;
        }
        return $tmpArr;
    }
 
    /**
     * Returns one row array in associative format
     */
    public function fetchAssoc()
    {
        return mysql_fetch_assoc($this->dbQuery);
    }
 
    /**
     * Returns the number of rows affected by the last query
     */
    public function numRows()
    {
        return mysql_num_rows($this->dbQuery);
    }
 
    /**
     * Returns the id generated from the last query
     */
    public function insertId()
    {
        return mysql_insert_id($this->dbConn);
    }
 
}

Supporting PHP 4

If you want to be compatible with PHP 4, simply remove the scope definitions (public, private) from the front of class methods and variables.

Final Thoughts

Writing your own classes for repetitive PHP tasks not only boosts your productivity, but can be very rewarding. A common saying amongst programmers is “don’t re-invent the wheel”. I beg to differ. If we’re not constantly creating, updating and exploring, we’ll never move forward. Inventing new wheels is what makes you a kick-ass programmer.

This is a very basic class, and could easily be tweaked to suit your needs. Some ideas for expansion would be to add more detailed helper methods, or handle errors via the use of Exceptions instead of simple die functions.

If you’re new to class and objects, check out my post “A Beginners Guide To PHP Classes & Objects - Part 1“.

Think Organic is my first publicly released Wordpress Template. Below is a breakdown of its features.

1. Widget aware
2. Gravtar aware
3. Wordpress 2.6+ compatible
4. Correct display in all major browsers
5. 100% height with CSS
6. Tightly coded
7. Free!

Installation

Installation is the same as any other Wordpress Template. Extract the .zip file, upload it to /wp-content/themes and activate in your Wordpress Control Panel.

Download

Any suggestion, bug reports or feedback are appreciated.

Download Think Organic v1.0 for Wordpress

When I first came across RipShout, it was the solution to my Shoutcast ripping needs. You can find my previous review here.

Now, after a bunch of feedback and some hard work from Adam Marciniec; RipShout 1.8 has been released.

Although there weren’t significant changes to the core, version 1.8 has the old RipShout seasoned with some handy new features. These include upgrades to the internal player, auto-proxy support, the ability to monitor and delete ripped songs and a sexy new interface.

If you haven’t yet discovered RipShout, your missing out. This app truly is the best way to rip your favorite Shoutcast radio streams, without the crap (or the price!).

You can download RipShout free, here.

Thanks Adam!

I’ve created a pre-made spreadsheet for you to download and import into your Google Docs to get started. Its a budget sheet for the year. With it you can calculate the totals for each month, and also see a break down of totals for the year.

Because the spreadsheet is in Microsoft Excel (XLS) format, you could use it in Excel or Open Office Calc instead of Google Docs.

Download the spreadsheet here.

Usage

Using the spreadsheet is easy. Simply enter in the different types of incomes you have, their values as well as the different types of expenses and their values. The totals will automatically be calculated and displayed in the “Totals” box.

Remember to update the SUM formula in the total rows if you add more fields to the “Income” or “Expenses” box. If you dont, your totals may be in-accurate.

Totals for all months will be displayed at the bottom of the spreadsheet. Unless you move any of the “Totals” boxes, you should never have to change the formulas in the “Yearly Totals” box.

ColorPix is a standalone app that tracks any color your mouse passes over. It also has a viewer that magnifies what your looking at. Once your over the right color, type any key on you keyboard to lock it in ColorPix, then type Ctrl+C to copy the color code.

Simple, light and free. Just the way I like it.

I recently came across a PHP version of the NetBeans IDE. Ok, so its not exactly PHP specific; basically its just a plugin. However, you can download the IDE as a base install specifically for PHP development, excluding any other unecessary languages or plugin bulk.

I’ve been using the IDE for two days now, and would have to say its a breeze to use. Its packed with features, and yet flexible enough to be a simple PHP editor with syntax highlighting. Its all up to you.

You can find the PHP NetBeans IDE here. You want to download the “Early Access for PHP” version.

One thing I’ve always wanted to do is save some of the songs to disk for later listening. Although there are several programs available that already do this, they either don’t work correctly, require payment or record the entire stream into one mp3; leaving you to split it up.

RipShout is a great freeware tool that rips the streams by song and saves the file by artist name and song title in mp3 format. While ripping a stream you can choose to run quietly in the system tray, play while ripping, or stream through Winamp while ripping.

If you use Shoutcast and want to save some streams, this free tool is for you. You can download RipShout for free here.