• Intro to OOP
• Classes
• Object
• Attributes
• Methods
• OOP: The PHP4 Way
• OOP: The PHP5 Way
• Inheritance
• Conclusion

Intro to OOP

While it is a little beyond the scope I had originally intended for this article, I am going to go into a brief explanation of what exactly object-oriented programming is, and why it’s used.

Object-oriented programming is a way of writing code that is reusable throughout an application. It’s also much more than that. Here are a few of the concepts used in OOP:

Classes

Classes are the basis of all object-oriented programming. They are a “construct used as a blueprint to create objects”. (Wikipedia: Class (computer science))

Objects

Objects are simply instances of a class. Usually when an object is instantiated, a method called the constructor is called, if present.

Attributes

Attributes are variables encapsulated in the class. Generally, without a specific keyword, attributes cannot be accessed without specifying a specific object. When an object is instantiated, each attribute of the object’s class is created as variable inside the object. This might be a little confusing, but we’ll talk about it more in depth shortly.

Methods

Methods are functions encapsulated within a class. As with attributes, they’re not accessible without specifying an object unless they’re declared within the class with a special keyword.

OOP: The PHP4 Way

I chose to start with the PHP4 way of doing things, because, while deprecated, all of this syntax is still completely valid in PHP5. There are, however better ways of doing it in PHP5. If you watch carefully, I’ll distinguish between what is specific to PHP4, and what is still proper in both.

In PHP, like many languages, you have to use class construct to declare your class. For example:

<?php
class Foo {
  // The contents of the class go here
}
?>

This creates a class called Foo. Right now there are no attributes or methods in the class. Let’s look at how we add attributes.

1
2
3
4
5
6
7
8
9
10

<?php
class Foo {
  // Attributes
  var $attr1;
  var $attr2 = 0;
  var $attr3 = "bar";
  var $attr4, $attr5 = 1, $att6 = "blah";
  var $attr7 = $attr2 + 1;  // this line will generate a syntax error.  explanation below
}
?>

As you can see, it’s quite simple and similar to declaring normal variables in PHP. Please note that the preceding ‘var’ is necessary. In PHP4, this declares a public attribute. Unfortunately, in PHP4, there is no way to officially declare private and protected attributes, the difference of course being that private and protected attributes can’t be accessed outside of class methods, but public and protected attributes may be overwritten, while private attributes may not. We’ll talk more about inheritance later. There are, however, naming conventions. Private attributes are prefaced with an underscore (i.e.: $_myPrivAttr), and protected attributes are prefixed with an underscore and a capital T (i.e.: $_TmyProtAttr). No extra action is taken on these naming conventions, but an experienced PHP programmer will see these and know what they mean. I’ve shown all of the different types of attribute declaration above on lines 4-6. You can either declare an attribute with no value, as on line 4, or you can give it a constant value, as on lines 5 and 6. You can also put multiple declarations on one line, as in line 7. However, you can not try to use a variable or function to set the default value of an attribute. The above code, due to line 8, will generate the following message:

Parse error: syntax error, unexpected T_VARIABLE in /Users/collin/class.php on line 8

Now that we’ve explored the do’s and don’t’s of attributes, let’s move on to methods.

As I mentioned before, methods are just functions specific to a class. In PHP4, they’re declared exactly the same as a normal function declaration. For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

<?php
class Person {
  // attributes
  var $_first_name, $_last_name;
 
  // methods
  // constructor
  function Person( $f = null, $l = null ) {
    $this->set_first_name( $f );
    $this->set_last_name( $l );
  }
 
  function first_name( ) {
    return $this->_first_name;
  }
 
  function last_name( ) {
    return $this->_last_name;
  }
 
  function set_first_name( $f = null ) {
    if ( $f )
      $this->_first_name = $f;
  }
 
  function set_last_name( $l = null ) {
    if ( $l )
      $this->_last_name = $l;
  }
}
 
$p = new Person( 'Collin' );
$p->set_last_name( 'Klopfenstein' );
 
print_r( $p );
?>

Let’s walk through the above example, shall we? First, you can see we’ve declared our class (line 2), and our attributes (line 4). Then we have a method called Person (line 8). There is a reason this method shares its name with the class. It is the constructor. This means PHP automatically calls this function whenever an object of Person is instantiated. Notice, we’ve given the method two arguments. We’ve chosen to default each argument to null in the event that we don’t know our person’s first and last name before instantiation. In the constructor, we’re simply calling two other methods in the class to set the first and last name. Any time that you are accessing class methods or attributes from within a class method, just like outside of the class, you must reference the object. How do you do this within a class method? You use $this.

You might be wondering why we made the first_name( ) and last_name( ) methods. Well, if you look back up to line 4, you’ll notice we used the private naming convention for both attributes. This means that, while in PHP4 PHP will not try to stop us, we should not attempt to access these attributes outside of the class. Instead we call first_name( ) and last_name( ), which return the value stored in their respective attributes. These aptly-named methods are often referred to as “getters”, as they are used to get the value of an attribute. We also have “setter” methods (set_first_name( $f ) and set_last_name( $l )). We use these functions to set the $_first_name and $_last_name attributes of our class.

Now take a look at line 32. We’ve talked about instantiation in the last few examples. Now you get to see what it looks like. This is how you create an object from a class. It’s also perfectly acceptable, if the constructor allows you to not pass any arguments as ours does, to do this instead:

32

$p = new Person;

Have you noticed the ->? Wondering what it is? Whether in a class method ($this->) or outside of the object (in this case $p->), that is how we reference an attribute or method of an object.

The last line of our example code, line 35, is calling a very useful function. print_r prints our information about a variable (most useful on an array or object) in human-readable form. Based on our code, this function call will output the following:

Person Object
(
    [_first_name] => Collin
    [_last_name] => Klopfenstein
)

This kind of information is VERY useful in debugging.

OOPHP: The PHP5 Way

Now that we’ve seen the basics of writing object-oriented PHP, let’s look at the differences in the current version, PHP5. You’ll recall that in PHP4, we don’t have any way to officially declare whether an attribute or method is public, private, or protected. In PHP5, however, we do have this luxury. Let’s begin converting our OOPHP4 to OOPHP5.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<?php
class Person {
  // attributes
  private $_first_name, $_last_name;
 
  // methods
  // constructor
  public function Person( $f = null, $l = null ) {
    $this->set_first_name( $f );
    $this->set_last_name( $l );
  }
 
  public function first_name( ) {
    return $this->_first_name;
  }
 
  public function last_name( ) {
    return $this->_last_name;
  }
 
  public function set_first_name( $f = null ) {
    if ( $f )
      $this->_first_name = $f;
  }
 
  public function set_last_name( $l = null ) {
    if ( $l )
      $this->_last_name = $l;
  }
}
 
$p = new Person( 'Collin' );
$p->set_last_name( 'Klopfenstein' );
 
print $p->_last_name;
 
print_r( $p );
?>

So far, we’ve only changed the declaration types. We want out attributes to be private, so we declared them as such. To demonstrate what declaring an attribute does, I’ve tried to print out one of our attributes, $_last_name. Here’s what will output:

Fatal error: Cannot access private property Person::$_last_name in /Users/collin/class.php on line 35

If we take that line out, you’ll notice print_r( $p ) also has some different output for you:

Person Object
(
    [_first_name:private] => Collin
    [_last_name:private] => Klopfenstein
)

Notice the :private. This is PHP’s way of telling print_r( $p ) that $_first_name and $_last_name are private variables. You’ve been warned.

Now let’s look at the difference with constructors/destructors in PHP. PHP4 does not have destructors by default. There are ways of accomplishing this in PHP4, but that is beyond the scope of this article. I suggest you try googling “PHP4 Destructor”. Anyway, now we’ll take our partially-converted code and change the constructor to a PHP5 constructor, add a destructor, and remove that pesky print accessing a private variable. Here’s how it looks now:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<?php
class Person {
  // attributes
  private $_first_name, $_last_name;
 
  // methods
  // constructor
  public function __construct( $f = null, $l = null ) {
    $this->set_first_name( $f );
    $this->set_last_name( $l );
  }
 
  public function __destruct( ) {
    unset( $this->_first_name );
    unset( $this->_last_name );
  }
 
  public function first_name( ) {
    return $this->_first_name;
  }
 
  public function last_name( ) {
    return $this->_last_name;
  }
 
  public function set_first_name( $f = null ) {
    if ( $f )
      $this->_first_name = $f;
  }
 
  public function set_last_name( $l = null ) {
    if ( $l )
      $this->_last_name = $l;
  }
}
 
$p = new Person( 'Collin' );
$p->set_last_name( 'Klopfenstein' );
 
print_r( $p );
?>

Alright, this is now up to PHP5 snuff. By no means do you HAVE to have a destructor, or even a constructor, but constructors can be VERY useful. You can see on line 8 that the constructor has changed from “Person” to “__construct”. We’ve also added a method called “__destruct”. This function is called when the object is destroyed. Now that we know how to write OOPHP4 and OOPHP5, let’s move on to a new concept.

Inheritance

Inheritance is the act of one class inheriting attributes and methods of another class upon instantiation. For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?php
class Foo {
  public $pub;
  private $priv;
  protected $prot;
 
  public function __construct( ) {
    $this->pub = "I'm public!";
    $this->priv = "I'm private!";
    $this->prot = "I'm protected!";
  }
}
 
class Bar extends Foo {
  public $pub;
  protected $prot;
 
  public function __construct( ) {
    $this->pub = "Bar Pub!";
    $this->prot = "Bar Prot";
  }
}
 
$bar = new Bar;
 
print_r( $bar );
?>

There should be nothing new here other than extends Foo in the class declaration of Bar on line 13. This just tells PHP that you want Bar to inherit all of Foo’s inheritable attributes and methods. Based on what you’ve read in this article, can you figure out which attributes Bar will end up with and what their values will be? Here’s your answer:

Bar Object
(
    [pub] => Bar Pub!
    [prot:protected] => Bar Prot!
    [priv:private] =>
)

You’re probably wondering why it is that $priv is not defined, right? I mean, it was defined in the constructor of Foo, right? Right. The constructor, being a public method, is overridable. With inheritance, if an attribute or method is declared as public or protected, it’s overridable. This means that Bar’s constructor overrides Foo’s constructor, rather than inheriting it. But have no fear. There is, however, a way to call the parent class constructor. Here it is:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<?php
class Foo {
  public $pub;
  private $priv;
  protected $prot;
 
  public function __construct( ) {
    $this->pub = "I'm public!";
    $this->priv = "I'm private!";
    $this->prot = "I'm protected!";
  }
}
 
class Bar extends Foo {
  public $pub;
  protected $prot;
 
  public function __construct( ) {
    parent::__construct( );
 
    $this->pub = "Bar Pub!";
    $this->prot = "Bar Prot";
  }
}
 
$bar = new Bar;
 
print_r( $bar );
?>

Now your output will be this:

Bar Object
(
    [pub] => Bar Pub!
    [prot:protected] => Bar Prot
    [priv:private] => I'm private!
)

Conclusion

Alright, so that’s pretty much it. If you have any questions, comments, concerns or criticism, just leave a comment. Thanks for reading!

In this tutorial, we’ll be going over the very basics of using PHP in a web page.

• Introduction
• Basics
• Conclusion

Introduction

PHP Is a very easy language to learn, especially if you’re familiar with a C-like language. However, it can still prove quite difficult to master. Don’t expect to memorize everything you’ll ever have to do in it. I’ve been working in PHP for 5 years now, and I still have to look functions up. This tutorial assumes you already have a suitable development environment. There are plenty of tutorials of how to set up Apache/PHP on a wide variety of operating systems, and that is beyond the scope of this article. Alright, let’s get our hands dirty.

Basics

If you’re reading this article, you’re probably familiar with HTML. If so, you know what .html files, and their outdated, older brothers, .htm files are. Pages with PHP code in them do not use this file type. They are suffixed with .php, which just lets our web server know that they need a little bit of pre-processing before they’re ready to display. These files, usually, are just HTML with PHP code injected. This is accomplished by using <?php ?> or <? ?> for shorthand. While it is perfectly acceptable to use either aforementioned syntax, I generally recommend that you stick with <?php ?> because if you use XHTML, you MAY have issues with collision with <?xml ?> stuff.

Here is an example of how to output “Hello, World!” on a page in bold using PHP:

<html>
  <head>
    <title>Hello, World Example - PHP<title>
  </head>
  <body>
    <strong><?php print "Hello, World!"; ?></strong>
  </body>
</html>

You can probably deduce exactly what is happening from the code above, but just in case, let’s break it down.

• <?php - This is lets PHP know it’s time to do work on 22s.
• print - This is a construct within PHP. In essence, print is a function, however there are certain rules it does not have to follow that functions do. For example, we can call it without parenthesis, whereas if I wanted to call a function, I would have to say myFunc( ).
• "Hello, World!" - This is the string we’re telling PHP to print out. This could be anything though: an integer, a floating-point decimal, or an array. PHP is a very loosely-typed language, meaning that you don’t have to declare the type of a variable when you declare the variable.
• ?> - This closes the PHP block.

Here are some other basic examples of how to do things in PHP:

<?php
// This is a comment.  It's skipped by the processor, and is only seen when viewing your code, not on the
presentation side.
 
# You can also use a pound sign at the beginning of a line to make comments.
 
/*
This is a different kind of comment...
...it spans multiple lines.
*/
 
$myVar = 0;  // here we're creating a variable and setting its value to zero
 
// Here are some basic mathematical operations in PHP
$myVar = 1 + 1; // addition
$myVar = 1 - 1; // subtraction
$myVar = 1 * 1; // multiplication
$myVar = 1 / 1; // division
 
// Here are some more advanced operations
$myVar = 3 % 2; // modulus. this will divide 3 / 2, and store the remainder in $myVar
$myVar ++; // this will increment the value by 1
$myVar --; // this will decrement the value by 1
$myVar += 3; // this will add 3 to the current value of $myVar
$myVar -= 5; // this will subtract 5 from the current value of $myVar
 
print $myVar == false;  // this will print 'true', as 0 evaluates to false in PHP
print $myVer == null;  // this will also print 'true', as 0 also evaluates to null in PHP
 
/*
This is one way of doing an if..else statement.  Notice, the exclamation point in the statement being
evaluated in the if.  That's the equivalent of saying '$myVar == false'.
*/
if ( !$myVar ) {
  print '$myVar is false!';
} else {
  print '$myVar is NOT false!';
}
 
// There's also "else if".  For example:
if ( !$myVar ) {
  print '$myVar is null!';
} else if ( $myVar == 1 ) {
  print '$myVar is 1';
} else {
  print '$myVar is not null or 1';
}
 
// here is another way of doing an if..else.  Notice the colons and the 'endif'.
if ( !$myVar ) :
  print '$myVar is false!';
else :
  print '$myVar is NOT false!';
endif
 
// if you only have one line to be executed per condition, then you can do this
if ( !$myVar )
  print '$myVar is false!';
else
  print '$myVar is NOT false!';
 
// You can also mix and match between the first and last I showed you.  For example:
if ( !$myVar )
  print '$myVar is false!';
else {
  // on the next line we're using the concatenating operator ('.') to outprint the value of $myVar
  print '$myVar is ' . $myVar . '.  Setting $myVar to null';
  $myVar = null;
}
 
// Finally, there are what are called "ternary" statements.  It's the last type of true if..else
!$myVar ? print '$myVar is null!' : print "\$myVar is $myVar";
/*
Here's how this breaks down:
!$myVar ?  print '$myVar is null!' :  print "\$myVar is $myVar";
|--1--|-2-|----------3-----------|-4-|-----------5-------------|
 
1: this is the conditional statement (what you would put in the "if" of the if..else)
2: this operator begins the block of code to execute if the statement is true (the "if")
3: this is the block of code to execute if the statement is true
4: this operator begins the block of code to execute if the statement is false (the "else")
5: this is the block of code to execute if the statement is false
*/
 
// The final type of conditional structure is a switch.
switch ( $myVar ) {
  case 0:
    print '$myVar is null!';
    break;  // note: this automatically jumps out of the control structure
  case 1:
    print '$myVar is 1!';
    break;  // we break because we've already found the case we want
  default:  // this is the 'else' of this structure
    print '$myVar is not null or 1!';
    // we don't have to break here, because we're already at the end of the structure
}
/*
In some cases you may not want to break.  You may want to match the proper case and then
perform the actions for ever case after that.
*/
 
/*
had we used double-quotes above, the concatenating operator would not have been needed,
though it's usually easier to read.  For example:
/*
print "\$myVar is $myVar";  // notice we had to escape ('\') the first $ so it shows '$myVar is 0'
 
/*
The last thing I'm going to cover in this article is arrays.  There are two ways to use arrays:
  - non-associative
  - associative
*/
 
// Non-associative Array
$myArr = array( "blue", "red", "green", "yellow" );  // this creates a new array
 
/*
One of the most important array functions you'll use is 'count'.  You simply pass it an array
and it tells you how many values there are in the array.  It's worth noting that count will
always return a number greater by one than the highest index in the array, as the array starts
on 0.  We use this to our advantage ;-)
*/
 
// One way to add things to the array is this:
$myArr[count($myArr)] = "orange"; // We've added "orange" as the 5th element (index of 4)
 
// Another way
array_push( $myArr, "purple" );  // this adds "purple" as the 6th element (index of 5)
 
/*
Now we move on to associative arrays.  As you may guess by the name, there is an association
made that is not made with non-associative arrays.  Here's how we define an associative array:
*/
$myArr = array (
  'red'    => 'Red',
  'green'  => 'Green',
  'blue'   => 'Blue',
  'yellow' => 'Yellow' );
 
/*
In this example, we're giving each index a key to access each value by.  The original way using
numbered indexes still works as well;
*/
print $myArr['red'];  // this will output 'Red'
print $myArr[2];  // this will output 'Blue'
 
$myArr['orange'] = 'Orange';  // this adds 'Orange' with a key of 'orange' to $myArr
 
// You can also remove values from an array.  There are two main ways to do this:
array_pop( $myArr ); // this way removes the value at index 0, shifts all indexes down one, and
                     // returns the value removed.
unset( $myArr[2] );  // this way just removes the value passed to it and shifts the indexes above
                     // it down one.  It's worth noting that you can unset almost any variable, not
                     // just array indexes
?>

Conclusion

Alright, so that’s it for this tutorial. If you have any questions, comments, concerns, or criticism, please feel free to leave me a comment.

I did a bunch of work to get the contact page up. It’s only using light validation though. It’s checking whether the required values are present. That’s all. I haven’t implemented any RegEx on the email yet for lack of a good RegEx that will actually catch emails with a dot in them (i.e.: john.doe@aol.com). I can’t say I’ve really looked THAT hard either though. It’s definitely on my TODO list.

I also got a little bit done to the “What’s New” part of the website on the index. Now, instead of just having recent tweets from @kulerwerks, it also has link that switches to the last 3 blog posts. This is also preloaded, so if everything goes according to plan, there’s no waiting when you click the link for recent posts.

Just adding a little more function to the site…

Tonight for example, I coded a nifty feature into my ‘page’ template. This feature allows me to include one page’s content from another page. For example, on the home page, I’m using the bio page’s content. When I get a little more written on the bio page, I’ll eventually put a <!–more–> in there.  The home page will then only show the bio page’s content up until the <!–more–>, at which point, there will be a link to the bio page.  I think this is a pretty useful feature if using WordPress as a CMS, and frankly, I’m kind of surprised that there’s not an existing way to do this.

Oh well, divide and conquer, I suppose…