Overview

In this tutorial we’ll be creating a very simple blog system. We won’t be using OOP yet in this tutorial. For creating a Blog using OOP in PHP, another more advanced tutorial will be written and posted as well. The same goes for creating a more advance CMS. However in this tutorial will just be creating a simple Blog system with php functions. Functions will be created for:

• Connecting to Host & DB
• Adding posts
• Deleting posts
• Adding replies
• Deleting replies
• Creating categories
• Retrieving & Displaying Posts
• Add user
• Edit user profile
• Display user profile
• Search

Also a simple 2 rows div layout will be created with a side-menu and main content div.

Database

Let’s start with creating the database for our simple blog. We’ll call it ‘simple_blog’. However you can call it anything you like as long as you set it correctly in the script later on. Now let’s create the tables inside this database.

Table: posts

The fields that need to be created:

[TABLE=6]

SQL:

CREATE TABLE IF NOT EXISTS `posts` (
  `id` int(250) NOT NULL AUTO_INCREMENT,
  `title` varchar(50) NOT NULL,
  `author` int(250) NOT NULL,
  `message` longtext NOT NULL,
  `timestamp` int(250) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Table: replies

[TABLE=9]

CREATE TABLE IF NOT EXISTS `replies` (
  `id` int(250) NOT NULL AUTO_INCREMENT,
  `postid` int(250) NOT NULL,
  `author` int(250) NOT NULL,
  `message` mediumtext NOT NULL,
  `timestamp` int(250) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Table: categories

[TABLE=10]

CREATE TABLE IF NOT EXISTS `categories` (
  `id` int(250) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Table: members

[TABLE=11]

CREATE TABLE IF NOT EXISTS `members` (
  `id` int(250) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(50) NOT NULL,
  `email` varchar(250) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Files

Now we’ve created our database, so let’s start with an overview of the files we’ll be creating now.

• functions.php
• config.php
• profile.php
• index.php
• post.php
• includes/header.php
• includes/footer.php
• includes/sidebar.php
• admin/index.php
• admin/functions.php

Let’s start with creating our function to connect  to the database we just made.

File: functions.php

<?php

function connect($connection) {

  $host = $connection[‘host’];
  $user = $connection[‘user’];
  $pass = $connection[‘pass’];
  $db    = $connection[‘db’];
  $conn =  mysql_connect($host, $user, $pass);

  If(!$conn)
    die(“Couldn’t connect to host.”);

  $db = mysql_select_db($db);

  If(!$db)
     die(“Couldn’t connect to database.”);

}

?>

Allright so first you see we set an argrument variable ‘$connection’ for the function. This variable should be given when calling the function and should contain all host & database info required to connect to the host & database. As you can see inside the function it seperates the sub-variables of the $connection variable into 4 new variables. These are for the host, user, password and database (db). As these are the data required to connect to the host & database and should be set in an array $connection and given to this function with sub-variable ‘host’, ‘user’, ‘pass’ and ‘db’.

We’ll be offering the $connection variable to the function as an array. It will use the sub-variable named ‘host’,  ‘user’, ‘pass’ and ‘db’ to try to establish a connection to the host and database. So these we’ll need to set in our config.php file. We’ll shorten the name of the variable $connection to $conn. As the name of it doesn’t really matter as long as we give it to the function ‘connect’ when calling it.

File: config.php

<?php

####CONNECTION CONFIGURATION###
$conn[‘host’] = “localhost”;        // database host (name/IP)
$conn[‘user’] = “root”;                // database host username
$conn[‘pass’] = “password”;      // database host password
$conn[‘db’]    = “simple_blog”; //database name

?>

With this info our function ‘connect’ should be able to establish a connection to the host & database.

We set each sub-variable for the $conn array. So we’ve got one variable ( array ) that contains all sub-variables, all info required for establishing a connection to the database. Which our function connect will accomplish.

Let’s include these files to the index file already.

File: index.php

<?php

include(“functions.php”);

include(“config.php”);

?>

We can already use our function to connect to the host & database:

File: index.php

<?php

include(“functions.php”);

include(“config.php”);

connect($conn);

?>

We provide the array variable $conn to the function which contains all the sub-variables data of host & database ( as we set it in config.php ) required for establishing a connection.

End of part 1

That’s it so far! In this part we’ve createn the structure of the script for both files, functions & database purpose. And also we’ve made our first function to establish a connection to the database & host using the configurations for the  connection set in our config.php file we created. In the second part we’ll be creating a basic CSS, Div based 2 columns layout. With a side-bar menu and a main content area where all posts will be appearing. Hope to see you in the next part!

The Form

File: form_handle.php

<form method="POST" action="fom_handle.php">
 <input type="text" name="test_field">
 <input type="submit" name="submit" value="Send!">
</form>

Handling the form data

Ok in this form we made 2 fields. One text input field, we named ‘test_field’ and one submit button we called ’submit’ and already gave the value ‘Send!’ to it. Now once the submit button gets pressed, the data of the input fields will be send using the method POST to the file form_handle.php ( as set in the form tag ). This means all values of the input fields will be stored into $_POST['input_field_name'] variables. So in our case we got 2 input fields, and so 2 $_POST variables will be created. One for the field ‘test_field’, which will be stored in $_POST['test_field'], and one for the submit button field we called ’submit’, which will bestored in $_POST['submit']. So in this way the data will be send to the page once the form gets submitted using the form. The submit button we gave a default value already ‘Send!’ so for this input field always this variable will be created:

$_POST['submit'] = "Send!";

Once the form has been submitted. So we can actually CHECK if the form was submitted, by validating this:

<?php
if($_POST['submit'] == "Send!") { //form has been submitted correctly?

   //handle form data

}

  //show form

}
?>

Because when the form gets submitted, as mentioned above, for each field will be created a variable $_POST['field_name'] and given a value ( either filled in by user or the default value ) which is default set to ‘Send!’ for the submit button. So the variable $_POST['submit'] must have been created if the form was submitted and must be given the value ‘Send!’ to as we gave it that value inside the form submit button input field. But we also made another input field we called ‘test’. This field we didn’t gave a value and can be filled in by the user as it’s a “text” input field. Which looks like this:

And we want to show what the user filled in there. And as we know the data of the input fields are stored in $_POST['input_field_name'], we can get the data filled in for the field named ‘test’ from the variable $_POST['test']. So let’s do this. But of course only when the form was submitted this is possible, so we use the loop we created to check whether the form was submitted or not:

File: form_handle.php

<?php

if($_POST['submit'] == "Send!") { //form has been submitted correctly?

   //handle form data
   echo "Input field: 'test' - You filled in: ".$_POST['test'];

}else{ //not submitted? show form

?>

<form method="POST" action="fom_handle.php">
 <input type="text" name="test_field">
 <input type="submit" name="submit" value="Send!">
</form>

<?php

}

?>

When the form has not been submitted yet, this will output:

Once the form has been submitted this will output:

Input field: ‘test’ – You filled in: [here what the user filled in for this field]

Allright, so those are the basics of retrieving user input data. The same principe works for all other input fields such as checkboxes ( which get their value when they’re checked ), radio boxes, etc..

However there’s also a second method: the GET method. It works the same for retrieving the data, they’re put inside $_GET['input_field_name'] when submitting the form. However, they can be changed inside the url. As they’re now submited through url. Like:

form_handle.php?submit=Send!&test=what_the_user_filled_in_for_this_field

So it could be manipulated very easily by changing that inside the url, and beside that, the user can see all values of as well hidden input fields ( which are given a default value for example ) through url. For example you’d have an input field:

<input type='hidden' name='key' value='myverylongsecretkey2985230'>

Then once the form gets submitted using GET method you’ll see this key just in the url!

form_handle.php?key=myverylongsecretkey2985230

So you don’t want that. So usually POST methods are used for securely submitting form, user input data.

End of tutorial

We’ve come to the end of this small tutorial. Hope you learnt something in this tutorial and also have a look at the tutorial about User Input Validation. Which can nicely be combined with this tutorial on how to actually first RETRIEVE the user input data before validating it or anything. Enjoy!

It’s also possible to have a second class which extends the main class. This make the class able to use the (public) functions (methods) & properties of the main class inside the other class. To extend a class we use extends.

Example:

class BasicClass {

}

class Class2 extends BasicClass {

}

Here Class2 extends the class ‘BasicClass’ which means it will be able to use all the functions and variables/constabnts of this class. However in this example those are none.

Using parent functions inside extending class

[b]Note:[/b] The examples in this tutorial are just to show how extending classes works and what possiblities it has, what it’s cappable of.

As mentioned above it’s possible to use functions of the basic class ( parent class ) inside the extending class ( which extends the basic class ). Here we’ll be doing this. Let’s say we’ve got a basic class which has functions to set the name, age and gender of a human (/colleagues for example). Now we could have multiple other classes which make use of these functions ( extend the basic class ), each representing ne colleague/human.

Note: this is just an example to show how it works and how extending classes can make use of functions set in a basic class.

Example:

class Colleague {

   protected function setName($name) {

       $this->name = $name;

   }

   protected function setGender($gender) {

       $this->gender= $gender;

   }   

   protected function setAge($age) {

       $this->age= $age;

   }   

}

class Colleague1 extends Colleague{

     parent::setName("Peter");
     parent::setGender("Male");
     parent::setAge("22");

}

class Colleague2 extends Colleague{

     parent::setName("Kim");
     parent::setGender("Female");
     parent::setAge("20");

}

However this might not be such practical to do, a more practical use ( example ) is shown below. But this example is though a good example to easily understand what it’s cappable of ( extending classes ) theoretical and how it can be used.

Ok, so here we created one basic class which indicate the basic functions and properties for a colleage. Each colleague was made a class for ( 2 colleagues in this example ) using these functions to set the basic properties for each colleague. Let’s first have a look at the ’setName’ function of the basic ( parent ) class ‘Colleague’:

   protected function setName($name) {

       $this->name = $name;

   }

It’s a protected function so only the extending class can use it. It sets the variable ‘name’ which will also be able to be used in the extending class ( as that one makes use of all functions AND properties/variables of the parent/basic class ). You could as well make it a public function so that the user can use it outside the class to set the name of the colleague manually ( as done in the 2nd example/part of this tutorial ). Here though we made it a protected function so we’ll use it inside the extending class which brings us to the extending class ‘Colleague1′ which sets the name with the following code:

     parent::setName("Peter");

Or mainly:

     parent::setName("name");

This uses the parent and :: symbols to access the parent class ( the class that it extends: ‘Colleague’ ). This method works like this:

     parent::functionName();

To access a function of the parent class and:

     parent::$variablename;

to access a variable of the parent class.

The parent class just uses $this->variableName to set the variables as they’re “global” – able to being used in any other class that extends this class.

Example of output from object:

<?php

class Colleague {

   protected function setName($name) {

       $this->name = $name;

   }

   protected function setGender($gender) {

       $this->gender= $gender;

   }   

   protected function setAge($age) {

       $this->age= $age;

   }   

}

class Colleague1 extends Colleague{

     parent::setName("Peter");
     parent::setGender("Male");
     parent::setAge("22");

}

class Colleague2 extends Colleague{

     parent::setName("Kim");
     parent::setGender("Female");
     parent::setAge("20");

}
########CREATE OBJECT (OUTPUT EXAMPLE)########
     $coll1 = new colleague1;
     $coll1->name; //outputs the name which is set using the parent function setName and is set to 'Peter' in this class
     $coll2 = new colleague2;
     $coll2->name; //outputs the name which is set using the parent function setName and is set to 'Kim' in this class

?>

Using parent functions outside the extending class ( as object )

It’s also possible to have a basic class set the functions that the extending class needs to be cappable of. For example: SHOWING the name, instead of SETTING the name. Then we could have the class that extends it, create a function to set the name. So when an object of the class is created, we can set the name and use the function of the parent class as well to show the name. However we do need to make the functions of the basic class ( parent ) public as we want to use it outside the class ( wih the object, to show the name ).

class Colleague{

    public function showName() {

       return $this->name;

   }

}

class Colleague1 extends Colleague{

     public function setName($name) {

              $this->name = $name;

     }

}

So the extending class has his function to set the name, and uses the function of the basic class to be cappable of showing the name. We could create an object that shows us that it’s cappable of this:

$coll = new colleague1;
$coll->setName("Peter"); //set name, uses the function set in this extending class
echo $coll->showName(); //show name, uses the function set in the parent class (basic class: Colleague)

This tutorial will explain the reasons to secure data in PHP and the best ways to easily accomplish this.

Securing data before database interaction

The first ‘type’ of data you should secure is the data which you will interact to the database with. Of course you could as well just use the user inputten data to interact with your database table right away, but let’s have a look at what could happen if you do so:

Unsecure mysql select query(BAD):

$user_input1 = "username_example"; //example of valid user input
$user_input2 = " ' OR username = 'username_example"; //BAD user input
$sql = "SELECT id FROM accounts WHERE username = '$user_input1' AND password = '$user_input2' ";

This is an example of an unsecure sql query which could for example be used with a login system to check whether the user inputten username & password are valid. However because of it’s unsecurity users could just fill in some password like ‘OR username = ‘username_example . What will happen then, you can see from the following:

$sql = "SELECT id FROM accounts WHERE username = '$user_input1' AND password = '$user_input2' ";

becomes =>

$sql = "SELECT id FROM accounts WHERE username = 'username_example' AND password = '' OR username = 'username_example' ";

Now, say, ‘username_example’ is a valid username of an account the user knows and want to login to without having to supply the password ( hack it ), he just filled in his bad code to make the query still return true because it now checks whether the username & password are correct OR the username is only correct. Which obviously is the case. So the user has now successfully logged in to the victims account. Of course you don’t want this to happen to your website’s members! So be smart, and secure your data in PHP.

However this was just an example for an unsecure login system, sql query. The same thing can happen to any other sql queries which are set up unsecured, which use user inputten data straight away without securing it first.

In the above example the coder made atleast 2 major security faulths:

• Coder used the user inputten data straight away into a sql query
• Coder put the user inputten data in the query between single quotes

The first faulth was explained above. But beside that it was also very wrong to put the user input data between single quotes which, as you could see in the above example of a bad user input, made the user able to easily bypass/get round these quotes and add another part to the query themselves. So the first thing we should do to make this query to secure is put it between ‘”. and .”‘:

So in general example:

$better_query = "SELECT field FROM table WHERE field = '".$_POST['userinput_fieldname']."' ";

But still this isn’t enough. However it’s already a lot harder now for the user to inject codes inside the query, it still can be done. To prevent this totally, we can use the security function made by PHP: mysql_real_escape_string. This function will escape all dangerous contents out of the user inputten data. So it can’t do any harm to your sql query and database and/or website anymore.

Secure and proper select query example (GOOD):

$better_query = "SELECT field FROM table WHERE field = '".mysql_real_escape_string($_POST['userinput_fieldname'])."' ";

Allright, so now atleast our query is secured and safe. The same can be done by INSERTING data into the database however there’s still one thing that could possibly happen: an error can occur when users use symbols such as ‘ and ” (quotes) in an inapropperiate way.

To fix this, we can make PHP add slasshes before these symbols to escape them. This will make these quotes for example, to be threatend as plain text. A function that does this for us is: addslashes.

Secure and proper insert query example (GOOD):

$secure_and_proper_query = "INSERT INTO table(field)VALUES('".addslashes(mysql_real_escape_string($_POST['userinput_fieldname']))."' ";

When doing this you might want to use stripslashes again when rertrieving the data, if it happens to show the slashes in the output.

Securing data before database output

It’s also not always safe to output user input data from database straight away, especially when you haven’t secured the user input data. If you DO secure the user input data to the database as done above, you should be safe, but to be 100% sure the database fields don’t contain any codes that will be executed: a function such as htmlspecialchars could be used. This function escapes all possibly harming tags/symbols out of the data. For example < will become <. Which will only be converted once by the browser into the text symbol < and which won't be executed as a code ( such as < b > normally would make text bold ).

Secure Output Example:

//example of bad user input from database or input field
$bad_userinput = "make whole page from here bold! <b> and mess up layout </table> or <table>";

echo htmlspecialchars($bad_userinput); //hah I won't!

And Fixed - your webpage has been prevented of being totally messed up by the user input.

Hope you learnt something and don’t forget: always secure user inputten data in PHP before using !

Preknowledge

For this tutorial it’s prefered that you’ve got some preknowledge about php variables, arrays, functions and the foreach loop. If not, I’d recommend you to have a look at the following tutorials which apply well to this tutorial:

• PHP Variables
• PHP Arrays
• Foreach Loop

Functions & Loops used

The functions/loops used in this tutorial:

Creating the function

Let’s first create a function which will do this job – replacing all smiley tags by smiley images. The only thing the function needs to do this task is a string ( text ) to do this for and an array of all smiley tags & corresponding smiley images to replace them with inside the string.

function replaceSmilies($str, $smilies) {

}

We gave them as argruments for the function, we called the string that needs to be given: ‘$str’, and the array with smiley tags & images that need to be set: ‘$smilies’.

Setting up smilies syntaxes & images

Note: This part should be put outside the function as it’s just for setting up the smiley tags & images ( example ) and an example string to replace them in. In other words: setting up the variables that are required for the function to do his task. The variables that we’ll be working with inside the function to replace the smileys.

The first thing we’re going to do is set up a list of smiley ‘tags’, syntaxes ( such as : ) and : D, etc. ) and the corresponding image icons (smilies) for those tags. We’re going to create an array to do this.

An array can be created like this:

$myArr = array("key" => "value", "key2" => "value2");

In our case we’ll set the keys equal to the smilie tags and the values equal to the smilie images ( icons ) with which these tags need to be replaced with.

Example:

$smilies = array(":)" => "smile.jpg",
                 ":P" => "thongue.jpg");

Here I just set up 2 smilies but setup as many as you want. The image names I used (’smile.jpg’ and ‘thongue.jpg’) can be any image that contains the smiley icon you want to show up for this smiley tag.

What we’ll want to do inside the replaceSmilies function is replace the keys (smiley tags) of the array by the images of the values (smilies) of the array.

Now let’s as well create an example text ( string ) in which these smiley tags occur and need to be replaced by the smiley icons/images:

$str = "Hi there!   Example text  ";

So now we’ve setup the argruments ( variables/arrays ) that are needed for our function that we’ll be creating. So let’s put everything together for so far:

<?php
function replaceSmilies($str, $smilies) {

}

$smilies = array(":)" => "smile.jpg",
                 ":P" => "thongue.jpg");
$str = "Hi there!   Example text  ";
?>

Creating the loop

Now we’re going to create a foreach loop which we’ll let it put the keys ( smiley tags ) of the array into a variable ‘$tag’ and the values ( smiley images ) into a variable ‘$image’. However it will do this for only 1 couple of a key and a value per time and execute the loop for that couple of a smiley tag and a smiley image. We’ll put the loop inside the function as the function will need to do the replacing of these smiley tags by these smiley images.

Structure of a foreach loop:

foreach($array as $keyvariable => $valuevariable) {

}

becomes =>

Our foreach loop:

foreach($smilies as $tag => $image) {

}

$smilies is the array we created to put all smiley tags ( keys ) and smiley images ( values ) into. As mentioned above for each couple of a smiley tag and a smiley image, the foreach loop will be ran with the smiley tag put in $tag and the smiley image put in $image. So for example $tag = ‘:)’ and $image = ’smile.jpg’. This is the first variable of our example array ($smilies) – our first couple of a smiley tag ( key ) and a smiley image ( value ).

So let’s put it inside the function.

function replaceSmilies($str, $smilies) {

   foreach($smilies as $tag => $image) {

   }

}

Replacing the smilies

So what will it need to do with this smiley tag and smiley image? It will need to replace the smiley tag by the smiley image inside the string which is set in $str ( see the function argruments & the example $str message set in the beginning ).
Before we’ll do this we’ll first create a new variable ‘$new_str’ which we’ll set equal to ‘$str’ in the first place but which will change as the smiley tags get replaced by the smiley images in there.

function replaceSmilies($str, $smilies) {

   $new_str = $str; //set the new string equal to the string given in the first place
                        //the foreach loop will be replacing the smilies inside this string
                       //so $new_str will contain the new string with images of the smilies (icons) inside

   foreach($smilies as $tag => $image) {

   }

}

Now we’ll be replacing the smiley tags by the smiley images. This will be done inside the foreach loop as there we got the smiley tags inside $tag and smiley images inside $images so we can easily replace them. Therefore we’ll use the str_replace function. So how does this function work?

str_replace("thing to replace", "value to replace it by", "string to do this inside");

so in our case;

str_replace($tag, $image, $new_str);

Which will replace $tag by $image inside $new_str. Which is correct: $tag contains the smiley tag and $image contains the smiley image and $new_str the string to replace these inside ( which will contain the new string ). Now it will return $new_str but then with the smiley tag replaced by the smiley image. But we do want to save this new (replaced) string it returns inside the variable $new_str to update it:

$new_str = str_replace($tag, $image, $new_str);

However now it will replace for example like ‘:)’ by ’smile.jpg’. Which won’t give us the image of ’smile.jpg’ yet!
So instead we need to replace it by:

<img src=’smile.jpg’>

or in general:

<img src=’”.$image.”‘>

So let’s change this inside the replace function:

$new_str = str_replace($tag, "<img src='".$image."'>", $new_str);

And let’s put it inside the loop.

function replaceSmilies($str, $smilies) {

   $new_str = $str; 

   foreach($smilies as $tag => $image) {

     $new_str = str_replace($tag, "<img src='".$image."'>", $new_str);

   }

}

The last thing the function needs to do is return the new string, which is put in $new_str.

function replaceSmilies($str, $smilies) {

   $new_str = $str; 

   foreach($smilies as $tag => $image) {

     $new_str = str_replace($tag, "<img src='".$image."'>", $new_str);

   }

   return $new_str; //return the new, updated string containing the smiley images

}

Smilies Directory Updating

It could be that you’ve put the smiley images inside another map/directory. In that case you can easily update the path of the image inside the loop. Better said: inside the str_replace function of the loop.

To do this, this part needs to be changed:

<img src=’”.$image.”‘>

As that’s the html image that all smileys will be replaced by. And we used a foreach loop for the smileys array which put all smiley images, one per time, inside $image and executed the foreach loop for each smiley the same way. So we only need to change this part as it uses this for each smiley and each smiley image. As they all will be set inside $image and replaced the same way inside the foreach loop.

So, for example, we could update the path like this:

<img src=’yourpath/”.$image.”‘>

     $new_str = str_replace($tag, "<img src='images/".$image."'>", $new_str);

Where we set the path to images/, so all smilies will be replaced by ‘images/smiley_image_name.jpg’ instead of just ’smiley_image_name.jpg’.

Using the function

To use the function we simply call the function and give the string ($str) and smiley tags & images array ($smilies) which we set in the beginning of this tutorial.

<?php

function replaceSmilies($str, $smilies) {

   $new_str = $str; 

   foreach($smilies as $tag => $image) {

     $new_str = str_replace($tag, "<img src='".$image."'>", $new_str);

   }

   return $new_str; //return the new, updated string containing the smiley images

}

$smilies = array(":)" => "smile.jpg", ":P" => "thongue.jpg");
$str = "Hi there!   Example text  ";

echo "Input string: {$str} <p>
          Output string: ".replaceSmilies($str, $smilies);

?>

Download Full Script (function & smilies pack)

I’ve created a sample script of this tutorial which includes a ready to use function for replacing smilies in a text by the smiley images (icons). The smiley icons/images are provided within the zip file and the function automaticly uses these smiley images by default unless you provide another set of smilies to the function.

How to use

<?php

    include("function.php"); //include the smilies function to your file      

    $str = "the message with smilies    "; //setup a variable that contains the message that needs to be converted

    echo replaceSmilies($str); //replace he smilie tags with the default smiley images

    //or: echo replaceSmilies($str, $smilies, $dir); where $smilies is the array with smiley tags & image filenames as done in this tutorial

?>

Download

What will be explained in this tutorial?

This tutorial will only explain the basics of OOP programming in PHP which consist of:

• creating classes
• creating public, protected and private functions & variables
• creating objects (instances of classes)
• using/calling other variables or functions inside the class
• using objects to call to functions or variables of the class

Why OOP?

First of all OOP can be, especially when creating huge scripts/projects, much easier to work with ( edit, modify, etc. ), it’s much more organized. Beside that it also makes use of classes, objects and functions which can make the programming a lot more efficient and fast. Also it offers a lot of (extra) features.

OOP – what’s it?

OOP is based on using objects created by classes. These classes can contain properties ( constants, variables ) and methods ( functions ). Let’s start with the classes of OOP and how to create them.

Classes & Objects

As mentioned above OOP uses classes which create the final ‘object’. To create a class we use the keywords class. This is how we create a basic class:

class MyBasicClass {

  //... what should this class be cappable of - do?

}

You see the class we create starts with the keyword class followed by the name of the class we create. Then we put everything of the class between { and }. What we’re going to put here is what this class should be cappable of – what should it be able to do? We could for example make it show a welcome message which however is rather useless but just to give an idea of how it works. To do so, we need to create a function inside the class. Let’s call the function ’sayHello’.

class MyBasicClass {

  //... what should this class be cappable of - do?
  // say hello!

  public function sayHello() {
       echo "Hello! Welcome to my website!";
  }

}

When it comes to creating functions or properties for a class, you have the choice of making it either a public , protected or private function or property. We made this function a public function so we can access it outside the class ( call it from an object ).

Public
Public functions or properties are accessable inside the class and parent classes but also outside the class (via/by object).

Protected
Protected functions or properties are only accessable inside the class and parent classes and not outside the class itself.

Private
Private functions or properties are only accessable inside the class itself and not by parent classes or objects.

Now we have created the class, but haven’t created the object, an instance of the class, yet. To do this we create a variable object and use the new keyword to create an instance of the class, the object.

$myObject = new MyBasicClass();

Now we created an instance of the class ‘MyBasicClass’ as an object ‘$myObject’. Do remember to put the creation of the class above this so an instance can be created of it. Otherwise it won’t find the class initialized and return an error.

Remember we made the function ’sayHello’ as a public function. So we should be able to access it outside the class using the object (instance of the class) we just created in $myObject. To do this we use the symbol ->.

$myObject = new MyBasicClass();

$myObject->sayHello(); //say hello to the world!

This makes it call the public function ’sayHello’. Let’s put it together so you can see how the real script looks like:

<php

class MyBasicClass {

  //... what should this class be cappable of - do?
  // say hello!

  public function sayHello() {
       echo "Hello! Welcome to my website!";
  }

}

$myObject = new MyBasicClass();

$myObject->sayHello(); //say hello to the world!

?>

This will output:

Hello! Welcome to my website!

Note: However in most cases classes are created within a seperated file ( usually called something like: classname.class.php ) and included anywhere above the part where it creates the object. Usually just in the top/header.

Creating a variable inside the class can be done in exactly the same way as creating a function. We can again make it either public, protected or private.

Example:

class MyBasicClass {

  //... what should this class be cappable of - do?
  // say hello!

  private $message = "Hello! Welcome to my website!";

  public function sayHello() {
       //show the message set in $message
  }

}

We here created a private variable ‘$message’ which so will only be accessable inside the class, which is the only way we’ll need to use it. Now we want the function sayHello to show the message we just set. Therefore we’ll need to use the variables of the function, to be specific: the variable called ‘message’ ( which we just created ). Accessing variables of the same class inside the class can be done like this:

$this->variable_name

So in our case:

$this->message

It’s just the way to access variables of its own class. So let’s use this to show the welcome message inside the function ’sayHello’:

class MyBasicClass {

  //... what should this class be cappable of - do?
  // say hello!

  private $message = "Hello! Welcome to my website!";

  public function sayHello() {
       echo $this->message;
  }

}

This will output exactly the same as the previous class function if we create an instance object of it again and call for (execute) the function again. But we won’t do this again, it’s just the same way as done above ( creating an instance object of the class, then calling the function sayHello ).

We might want to be able to set the value of the welcome message (variable ‘message’) outside of the class, when creating an instance object of the class. So we could have multiple instances with each showing different welcome messages for example. We’ll use the default __construct function to do this, which will require the user to set variables for the class when creating the object (instance).

  public function __construct($variable1, $variable2, $optionalVariable3 = NULL) {

  }

It obviously needs to be a public function as it needs to be accessed automaticly when creating a new instance of the class. The variables that need to be given a value to is put between the brackets. In this example there’s one optional variable ( $optionalVariable3 ) which has been given a default value ( NULL ). So for that variable no other value is REQUIRED to be given, but optional. However in our case we only need to construct ONE variable, the variable containing the welcome message: $message.

  public function __construct($message) {

  }

However the value of $message ( set by the user when creating an instance object of the class ) is now only accessable inside this __construct function. To make it a public variable which is accessable all over the class, we will again use $this->variable_name to create the variable for the whole class:

  public function __construct($message) {

      $this->message = $message; //set the public variable 'message' equal to the value of $message
      //as public variables can be accessed inside the whole class atleast

  }

Let’s put it inside our previous class. So replace the $this->message variable with this construct function which sets it equal to the value given by the user when creating an object instance of the class.

class MyBasicClass {

  //... what should this class be cappable of - do?
  // say hello!

  public function __construct($message) {

      $this->message = $message; //set the public variable 'message' equal to the value of $message
      //as public variables can be accessed inside the whole class atleast

  }

  public function sayHello() {
       echo $this->message;
  }

}

Now we could create an object, instance of the class and set the welcome message to show:

$myObject = new MyBasicClass("Example welcome message!");

And again use the -> symbol to call the function that shows the welcome message ( function ’sayHello’ ):

$myObject = new MyBasicClass("Example welcome message!");
$myObject->sayHello();

Let’s put it all together:

<?php

class MyBasicClass {

  //... what should this class be cappable of - do?
  // say hello!

  public function __construct($message) {

      $this->message = $message; //set the public variable 'message' equal to the value of $message
      //as public variables can be accessed inside the whole class atleast

  }

  public function sayHello() {
       echo $this->message;
  }

}

$myObject = new MyBasicClass("Example welcome message!");
$myObject->sayHello();

?>

Instead of using the __construct function, the variable could as well be set as an argrument of the ’sayHello’ function itself. In that case you would need to set the welcome message when calling the function ( $myObject->sayHello(“welcome message”) ) instead of when creating the object.

Conclusion

So now we’re able to create a class, create (public, protected and private) functions and properties, construct a class so it’s constructable/modifieable/configurable outside the class (when creating the object), create an instance of the class and call functions and properties of the class using the object (instance of the class).

What’s next?

Play arround with creating objects, classes, methods and properties and try to think of useful and efficient ways to use them. If you don’t really have a clue yet on the use of them ( examples ), no worries: more tutorials will follow with useful examples of the use of classes and a tutorial further continueing on extending classes and creating more advanced classes as well, soon. An example of a very good use of classes would be to create a template system like Smorty e.g. which requires functions to set template to load, module to load, macros, etc., so classes would come very handy here. A tutorial on creating a basic template system will be written and posted as well for who’s interested.

Overview

Let’s start with having a look at the functions that will be explained in this tutorial and so our file upload system will be cappable of:

- Upload form
- Uploading files to a specific directory
- Set max file size for upload files
- Limit uploadable files by specific file extension
- Retrieve error message & handling
- Check whether file doesn’t already exists

Upload Form

We’ll start off with creating a upload form for our file upload system. File upload systems often use the POST method for this form which is a common way of submitting data using forms. The action of the form is set to the file that will handle the uploading, which will be done in the same file: “upload.php”. One last thing that we’ll need to set for our form is the enctype attribute which we set to “multipart/form-data”. This will basicly enable us to upload files and handle them.

... upload form fields ...

Allright, now we ll be adding the fields to the form. Which are the ’select upload file’ input field and the ’submit’ button. Let’s start with the ’select upload file’ input field. This input field allows the user to pick a file to upload. It can be created by creating a normal input field in which you set the type equal to ‘file’. This will make it a common file select input field in which the user can select a file from his computer to upload. Give it any name you like but remember we’ll need the name of the input field later to retrieve the file selected by the user ( and all data related to it ). Here I gave it the name ‘uploadfile’.

The second input field we’ll be adding is the submit button. Which we can create by adding a normal input field with as type set to ’submit’. The value of this input field will be shown as text on the button. Also don’t forget to set a name for this input field ( submit button ) as otherwise no POST data will be send which is required to check if the form was submitted.

File: upload.php

That’s it, our basic file upload form. However notice that we’ll be editing it later by adding more input fields to it which allow us to set more limitations or use more features of file handling system.

File Upload Handling

Okay, so we’ve now got our basic file uploading form in which the user can select a file to upload and submit it. But obviously this doesn’t do the job of actually uploading the file selected by the user. Therefore we’ll need to use some PHP functions, handle the uploading process. All info we need about the user selected upload file and the process of submiting it can be found inside the array variable $_FILES['file_inputfield_name']. And as in the example we gave the ‘file’ input field the name ‘uploadfile’, we can find all file data in $_FILES['uploadfile']. So what data can be found inside? Here’s a basic list of the sub-variables we’ll be using:

[TABLE=3]

The first thing we want to do is check whether any error occured already while ’submitting’ the file (through form). To do this we’ll check the ‘error’ subvariable which is stored in $_FILES['uploadfile']['error'] assuming the upload file input field is given the name ‘uploadfile . You can as well see this in the table above. When no errors have occured, this variable should contain the numeric value ‘0′. So to check if any errors occured we simply check it with an if loop:

<?php
if($_FILES['uploadfile']['error'] > 0) {

    echo "Error occured!";

}else{

    //... no error occured - upload the file! ...

}
?>

This needs to be checked once the file has been ( attempted to be ) submitted. This can be checked by checking the array variable $_POST. As we used the method ‘POST’ for submitting the form data. Which means that, once the form has been submitted, all data will go inside the $_POST array variable. So we simply check if this is the case by using the empty function to check whether it’s empty. We put a ! before it to check if it is NOT empty ( so if the form has been submitted ).

<?php
if(!empty($_POST)) {

    if($_FILES['uploadfile']['error'] > 0) {

          echo "Error occured!";

    }else{

          //... no error occured - upload the file! ...

    }

}
?>

Let’s put it together with the form:

File: upload.php

<?php
if(!empty($_POST)) {

    if($_FILES['uploadfile']['error'] > 0) {

          echo "Error occured!";

    }else{

          //... no error occured - upload the file! ...

    }

}
?>

Now we’re heading to the part of processing the uploading of the file. Therefore we can use a simple function move_uploaded_file. Which, when we put it in a loop, does 2 things for us: checking whether the file could be uploaded to a temporary directory AND ( if so ) move the uploaded file to our set directory. So it will require us to set 2 argruments for it, the upload file and the path to move the uploaded file to. The path will need to include the name of the file too ($_FILES['uploadfile']['name'])!

$path = "uploads/".$_FILES['uploadfile']['name'];

We create a variable $path which we put the path for the upload file to be moved to, into. We set it to ‘uploads/uploadfile_name’ but you can set it to any directory you like the upload file to be placed into.

Now, the function to actually move the uploaded file to this path looks like this:

move_uploaded_file($_FILES['uploadfile']['tmp_name'], $path);

As the $_FILES['uploadfile']['tmp_name'] is the path of the temporary location in which the upload file was automaticly uploaded into and the $path variable contains the path that it needs to be moved to.

And inside a loop:

if(move_uploaded_file($_FILES['uploadfile']['tmp_name'], $path)) {

    //... file successfully uploaded and moved to the path set in $path

}else{

   //... could not move uploaded file to path set in $path

}

Let’s put it inside our script:

File: upload.php

<?php
if(!empty($_POST)) {

    if($_FILES['uploadfile']['error'] > 0) {

          echo "Error occured!";

    }else{

          //... no error occured - upload the file! ...

          //>>>>HERE<<<<<

          $path = "uploads/".$_FILES['uploadfile']['name'];

          if(move_uploaded_file($_FILES['uploadfile']['tmp_name'], $path)) {

               //... file successfully uploaded and moved to the path set in $path
               echo "File <b>
                   ".$_FILES['uploadfile']['name']."</b>
                    successfully uploaded to ".$path;

          }else{

              //... could not move uploaded file to path set in $path
              echo "Error - could not move uploaded file to {$path}!";

          }

    }

}
?>

We put it in the second loop which checks if there were any errors ( remember? ) and we put it in the else part which is executed when no errors were found. As in that case the file was successfully submitted and uploaded to temporary path, and needs to be uploaded/moved to the definitive path.

Max File Size

For adding a max file size we could either do this inside the php.ini file (find MAX_FILE_SIZE) or by adding another input field to the form. You could even make another loop to check if the max file size was not exceeded (check $_FILES['uploadfile']['size'] to check ). However we’ll be using the second method: we’ll add another input field to the file upload form. This input field needs to be hidden as it just sets a value, and is not litterally an input field. We need to set the name of the input field equal to ‘MAX_FILE_SIZE’ so the system will recognize it as the input field containing the max file size for the upload file.

The type of the field is set to ‘hidden’ as mentioned above already. The name to ‘MAX_FILE_SIZE’, also as mentioned above and the value to ‘1048576′ BYTES, which is equal to 1 MB (1024 bytes = 1 KB, 1024 KB = 1 MB => 1 MB = 1024 BYTES * 1024 = 1048576 BYTES (1 MB) ).

Add it to the form with the other input fields and … <b>DONE!</b>

File: upload.php

<?php
if(!empty($_POST)) {

    if($_FILES['uploadfile']['error'] > 0) {

          echo "Error occured!";

    }else{

          //... no error occured - upload the file! ...

          //>>>>HERE<<<<<

          $path = "uploads/".$_FILES['uploadfile']['name'];

          if(move_uploaded_file($_FILES['uploadfile']['tmp_name'], $path)) {

               //... file successfully uploaded and moved to the path set in $path
               echo "File <b>
                   ".$_FILES['uploadfile']['name']."</b>
                    successfully uploaded to ".$path;

          }else{

              //... could not move uploaded file to path set in $path
              echo "Error - could not move uploaded file to {$path}!";

          }

    }

}
?>

Upload File Extensions

Now we’ll be creating another loop to check whether the extension of the uploaded file is allowed by us. In this example we’ll allow a couple of image types (jpg, jpeg, gif, png and bmp) but make it anything you want to allow upload files of. The extension of the upload file is set in $_FILES['uploadfile']['type'] as explained in the beginning of this tutorial inside the table, list. We’ll use a simple pattern to check if the file type, extension, is any of these images. If you aren’t familiar with php patterns either skip this part, use a regular if loop or have a look at the tutorial about user input validation.

/^image\/(jpg|jpeg|gif|png|bmp)$/

The file type should start with ‘image/’ all image files are given the file type value ‘image/extension’ (where extension is any of jpg, jpeg, gif, etc. ). We allow a collection of file types: jpg or jpeg or gif or png or bmp – the file may contain any of these. They’re seperated by a | to indicate the file type may be ANY of these ( one ). You could as well just allow ALL image extensions. The pattern would then look like this:

/^image\/(.*)$/

As all images get the file extension starting with ‘image/’.

We put it inside a regular if loop and use the preg_match function to check whether the pattern matched with the upload file extension.
Notice the file extension is set in $_FILES['uploadfile']['type'] and that we use the function strtolower so that for example
JPEG would become jpeg. So it won’t make any difference for capital letters – match the pattern as well as they’re converted to non-capital (lower) letters ).

$pattern_filetypes = "/^image\/(jpg|jpeg|gif|png|bmp)$/";
if(preg_match($pattern_filetypes, strtolower($_FILES['uploadfile']['type']))) {

     //matched the pattern -> file type is allowed

}else{

   //didn't match the pattern -> file type is not allowed

}

Put the pattern for the filetypes that are allowed inside a variable to make it easier readable and editable.

So, where do we put this inside our total script? It should be in the first loop atleast, as that’s where all the file handling takes place ( when the form was submitted ). The second loop inside that one, of our whole script checks, checks if there are any errors. It should be in the else part of that loop as that else part is executed when no errors were found. And then it will need to check the file type, and if that’s correct as well, it will execute the file uploading stuff:

File: upload.php

<?php
if(!empty($_POST)) {

    if($_FILES['uploadfile']['error'] > 0) {

          echo "Error occured!";

    }else{

          //... no error occured - upload the file! ...

          //>>>>HERE<<<<<

          $pattern_filetypes = "/^image\/(jpg|jpeg|gif|png|bmp)$/";
          if(preg_match($pattern_filetypes, strtolower($_FILES['uploadfile']['type']))) {

               //matched the pattern -> file type is allowed

               //Put the file handling script here (moved from below)

         $path = "uploads/".$_FILES['uploadfile']['name'];

          if(move_uploaded_file($_FILES['uploadfile']['tmp_name'], $path)) {

               //... file successfully uploaded and moved to the path set in $path
               echo "File <b>
                   ".$_FILES['uploadfile']['name']."</b>
                    successfully uploaded to ".$path;

          }else{

              //... could not move uploaded file to path set in $path
              echo "Error - could not move uploaded file to {$path}!";

          }

          }else{

              //didn't match the pattern -> file type is not allowed

             echo "Error - file type not allowed!";
         }

    }

}
?>

Retrieve errors & Handling

Now that we’ve got our file upload system work, we do want to be able to tell the user WHAT error occured if any. As now it just showed an error message if any error occured. Let’s have a closer look on that part again, pick it out of our script for a sec:

    if($_FILES['uploadfile']['error'] > 0) {

          echo "Error occured!";

When $_FILES['uploadfile']['error'] contains a value greater than 0, an error has occured. But what error occured can be told by checking the value ( number ) of $_FILES['uploadfile']['error'] which contains the number of the error occured. Here’s a list of what error each number represents:

[TABLE=5]

As you can see all numbers greater than 0 indicate an error ( we checked it correctly in the if loop: $_FILES['uploadfile']['error'] > 0 ). Now we’re going to create a switch loop which checks WHICH of the errors occured. We’ll be using the data from the table above:

switch($_FILES['uploadfile']['error']) {

         case 1:
         echo "Max file size exceeded";
         break;

         case 2:
         echo "Max file size exceeded";
         break;

         case 3:
         echo "File was only partially uploaded";
         break;

         case 4:
         echo "File was not uploaded";
         break;

         case 5:
         echo "Missing temp directory";
         break;

         case 6:
         echo "Could not write file to disk";
         break;

         case 7:
         echo "Upload stopped by file extension";
         break;

}

Think that’s quite straight forward. It checks which error number occured ( value of $_FILES['uploadfile']['error']) and for each number it shows the corresponding error message. Let’s put it all together!

File: upload.php

<?php
if(!empty($_POST)) {

    if($_FILES['uploadfile']['error'] > 0) {

          echo "Error occured - ";

         //>>>HERE<<<
         //which error occured?

         switch($_FILES['uploadfile']['error']) {

               case 1:
               echo "Max file size exceeded";
               break;

               case 2:
               echo "Max file size exceeded";
               break;

               case 3:
               echo "File was only partially uploaded";
               break;

               case 4:
               echo "File was not uploaded";
               break;

               case 5:
               echo "Missing temp directory";
               break;

               case 6:
               echo "Could not write file to disk";
               break;

              case 7:
              echo "Upload stopped by file extension";
              break;

        }

    }else{

          //... no error occured - upload the file! ...

          $pattern_filetypes = "/^image\/(jpg|jpeg|gif|png|bmp)$/";
          if(preg_match($pattern_filetypes, strtolower($_FILES['uploadfile']['type']))) {

               //matched the pattern -> file type is allowed

               //Put the file handling script here (moved from below)

         $path = "uploads/".$_FILES['uploadfile']['name'];

          if(move_uploaded_file($_FILES['uploadfile']['tmp_name'], $path)) {

               //... file successfully uploaded and moved to the path set in $path
               echo "File <b>
                   ".$_FILES['uploadfile']['name']."</b>
                    successfully uploaded to ".$path;

          }else{

              //... could not move uploaded file to path set in $path
              echo "Error - could not move uploaded file to {$path}!";

          }

          }else{

              //didn't match the pattern -> file type is not allowed

             echo "Error - file type not allowed!";
         }

    }

}
?>

File Exists Check

Now one last thing we might want to do is check whether the uploaded file doesn’t already exist. We can simply use the function file_exists to do this.

if(file_exists('file/path/')) {

    // file exists

}else{

   // file doesn't exist

}

So in our case the path would be $path ( remember?). As we earlier set $path equal to:

         $path = "uploads/".$_FILES['uploadfile']['name'];

Which is the path for the file to be uploaded to. But we first want to check if the file already exists in there, so we use the file_exists function.

if(file_exists($path)) {

    // file exists
    echo "File already exists!";

}else{

   // file doesn't exist - continue uploading

}

We put it in the script right after the part where the $path is set ( which is in the loop where it starts uploading the file ):

File: upload.php

<?php
if(!empty($_POST)) {

    if($_FILES['uploadfile']['error'] > 0) {

          echo "Error occured - ";

         switch($_FILES['uploadfile']['error']) {

               case 1:
               echo "Max file size exceeded";
               break;

               case 2:
               echo "Max file size exceeded";
               break;

               case 3:
               echo "File was only partially uploaded";
               break;

               case 4:
               echo "File was not uploaded";
               break;

               case 5:
               echo "Missing temp directory";
               break;

               case 6:
               echo "Could not write file to disk";
               break;

              case 7:
              echo "Upload stopped by file extension";
              break;

        }

    }else{

          //... no error occured - upload the file! ...

          $pattern_filetypes = "/^image\/(jpg|jpeg|gif|png|bmp)$/";
          if(preg_match($pattern_filetypes, strtolower($_FILES['uploadfile']['type']))) {

               //matched the pattern -> file type is allowed

               //Put the file handling script here (moved from below)

         $path = "uploads/".$_FILES['uploadfile']['name'];

//>>>HERE<<<

if(file_exists($path)) {

    //file exists

    echo "File already exists!";

}else{

   //file doesn't exist - continue uploading

          if(move_uploaded_file($_FILES['uploadfile']['tmp_name'], $path)) {

               //... file successfully uploaded and moved to the path set in $path
               echo "File <b>
                   ".$_FILES['uploadfile']['name']."</b>
                    successfully uploaded to ".$path;

          }else{

              //... could not move uploaded file to path set in $path
              echo "Error - could not move uploaded file to {$path}!";

          }

}

          }else{

              //didn't match the pattern -> file type is not allowed

             echo "Error - file type not allowed!";
         }

    }

}
?>

Done!

And that’s our final script! Hope you learnt something and have fun uploading .

Modification Suggestions

<b>Change the path to url</b>
As with this file uploading system we let it show the relative PATH to the file, we could also make it show the url to the file uploaded. To do this you need to change this part of the script:

               //... file successfully uploaded and moved to the path set in $path
               echo "File <b>".$_FILES['uploadfile']['name']."</b> successfully uploaded to ".$path;

That’s where it shows the file being successfully uploaded -message. You see it shows the path which is set in $path. To make it show the URL, just create another variable for example like this:

      $website_url = "http://mywebsite.com/directory_of_this_file"; /* url to the directory of this file (not the file itself) - for example: http://mywebsite.com/ or http://www.mywebsite.com/upload/ ) */
      $file_url = $website_url."/".$path;

We created the variable $file_url which holds the url to your site / the path to the upload file which is the total url to the uploaded file.

               //... file successfully uploaded and moved to the path set in $path

               $website_url = "http://mywebsite.com/directory_of_this_file";
               $file_url = $website_url."/".$path;

               echo "File <b>".$_FILES['uploadfile']['name']."</b> successfully uploaded to ".$file_url."";

Cheers,
Admin.

Script: backlinks_checker.php

<?php

####################################################################
/* backlinks_checker.php                                                               */
/* Author: webcodez.net 							                */
/* Creation Date: 2 February 2010 - 3 February 2010		       */
/* Description: Checks whether a link is on a specific website.    */
/* *Update: Gets all backlinks to a specific website from urls.     */
####################################################################

###################### CONFIG #######################################
$domainsite = "webcodez.net"; //domainname of the website to search backlinks for - example: domainname.com
$urls_file = "urls.txt"; //file containing all urls to check for backlinks on
####################################################################

$domainsite = str_replace(".", "\.", $domainsite);

$urls = array("http://www.webcodez.net/"); //website pages to check backlinks on

//Get urls to check backlinks on
$handle = @fopen($urls_file, "r");
if ($handle) {
    $curr_arr = count($urls);
    while (!feof($handle)) {
        $buffer = fgets($handle, 4096);
        //if(file_exists($buffer))
		$urls[$curr_arr] = $buffer;
	  $curr_arr++;
    }
    fclose($handle);
}

$total_urls = 0;

foreach($urls as $key => $addr) {

$urls_cont = file_get_contents($addr);
$pattern = "/(http)(s)?(:\/\/)(www\.|[A-Za-z0-9_-]*\.)?".$domainsite."(\/[A-Za-z0-9-_ .]*)*/ ";
$get = preg_match_all($pattern, $urls_cont, $backlinks);

$catch_backlinks[$key] = $backlinks[0];
$amount_backlinks[$key] = count($catch_backlinks[$key]);

$total_backlinks += $amount_backlinks[$key];

}

echo "<h3> Total Backlinks Found: ".$total_backlinks." </h3>";

foreach($urls as $key => $addr) {

echo "<p><b>{$amount_backlinks[$key]} Links to ".stripslashes($domainsite)." found on \"".$addr."\"</b></p>";

foreach($catch_backlinks[$key] as $url) {

	echo "<p>{$url}</p>";

}

}

?>

How to use?

Just create a ‘urls.txt’ in which you put all websites on which you want to check backlinks to your/any website on. Take one line per url. Then inside the script replace ‘webcodez.net’ with your own website or the domain of the website you want to check backlinks of.

Use of all patterns

All patterns explained in this tutorial can be used by using the preg_match function, for example using an if loop:

//$value = $_POST['input_field_name']; for example
if(preg_match("/pattern/", $value))
   //matched
else
  //did not match

Email Validation

To validate a user input for an email, to check whether it’s a valid email, can be done in several ways. Here I’ll be showing 2 ways to validate an email. To create a pattern for validating an email you’ll first need to think of how an email can look like ( structure ). Which is:

email_name@email_provider.lang

Where ‘lang’ can be anything like: com or net or nl ( dutch ), etc.. The ‘email_name’ can be anything of any length containing alphabetical characters, numbers or the – _ symbols. Same goes for the ‘email_provider’. So for validating USA email addresses (.com) for example, we could have a pattern like this:

Pattern:

/^[A-Za-z0-9-_.]*@[A-Za-z0-9-_.]*(\.com)$/

However this pattern will only allow/match email addresses that end with .com. We could use the | seperator to allow several ‘extensions’ for the email ( .com OR .net OR .nl, etc..). That would look like this:

Pattern:

/^[A-Za-z0-9-_.]*@[A-Za-z0-9-_.]*(\.com|\.net|\.nl|\.de|\.be|\.co\.uk)$/

And you could add all extensions you want to allow for the email address there, seperated by | and don’t forget to escape the dots (.) with a backslash (\) so it will be treated as a normal character.

Note: a second way to do this could be to allow all extensions (.com, .net or .anythinghere). To do this just replace the \.com|\.net|etc… by \.[A-Za-z0-9]* which basicly means: all alphabetical characters and numbers.

Example of use:

<?php

$email = "validemail123@validprovider_09.net";

if(preg_match("/^[A-Za-z0-9-_.]*@[A-Za-z0-9-_.]*(\.com|\.net|\.nl|\.de|\.be|\.co\.uk)$/", $email)) {

    echo "<p> Valid email: {$email} </p>";

}else{

    echo "<p> Invalid email: {$email} </p>";

}

$email = "invalid' email@invalid,provider}.fpweo";

if(preg_match("/^[A-Za-z0-9-_.]*@[A-Za-z0-9-_.]*(\.com|\.net|\.nl|\.de|\.be|\.co\.uk)$/", $email)) {

    echo "<p> Valid email: {$email} </p>";

}else{

    echo "<p> Invalid email: {$email} </p>";

}

?>

Output:

Valid Email: validemail123@validprovider_09.net

Invalid Email: invalid’ email@invalid,provider}.fpweo

Website Address Validation

For creating a pattern to validate website adresses (urls) we’ll have a look at a valid structure of a website address first, which is similar to:

http(s)://(www. or subdomain.)websitename.com(/directories)(/page.ext)(?getvar&getvars)

Where what’s between brackets is optionally. The .com can be any other ‘extension’ of course (.net or .co.uk, etc.).

Pattern:

/^(http)(s)?(:\/\/)(www\.|[A-Za-z0-9_-]*\.)?[A-Za-z0-9_-]*(\.com|\.net|\.co\.uk|\.net)(\/|\/[A-Za-z0-9-_ .]*)*$/

This is just an example of a pattern I created that could be used. It may at first look complex but it isn’t that complex at all if you have a further look into it. Let’s go through it briefly. Each valid website address starts with ‘http’ (^(http)) followed by an optional ’s’ ( (s)? ). After that there’s a ‘://’ which is put inside the pattern as (:\/\/) as all /s need to be escaped by a \. So // becomes \/\/. Then there’s an optional ( so a ? behind the collection ) ‘www.’ or ’subdomain_name.’ where the subdomain_name can be any alphabetical character or number or _ or – ([A-Za-z0-9_-]) and any size (* = any amount of characters). The question mark behind this collection ( www. | subdomain. ) defines it may occur one or zero times (that it’s optional). Then there’s again the [A-za-z0-9_-] which again means any alphabetical characters or numbers or the _ or – symbol, which is for the domainname of the website which may contain any of these characters in any length (*). Then it should be followed by any of these ‘extensions’ ( \.com|\.net|\.co\.uk|\.net ). Now the rest of the pattern is optional – there can be anything after the url (after a backslash / ).

Example of use:

<?php

$url = "http://www.validurl.net/anypath/anyfile.php?anything";

if(preg_match("/^(http)(s)?(:\/\/)(www\.|[A-Za-z0-9_-]*\.)?[A-Za-z0-9_-]*(\.com|\.net|\.co\.uk|\.net)(\/|\/[A-Za-z0-9-_ .]*)*$/", $url)) {

    echo "<p> Valid url: {$url} </p>";

}else{

    echo "<p> Invalid url: {$url} </p>";

}

$url = "http://invalidurl-^.";

if(preg_match("/^(http)(s)?(:\/\/)(www\.|[A-Za-z0-9_-]*\.)?[A-Za-z0-9_-]*(\.com|\.net|\.co\.uk|\.net)(\/|\/[A-Za-z0-9-_ .]*)*$/", $url)) {

    echo "<p> Valid Url: {$url} </p>";

}else{

    echo "<p> Invalid Url: {$url} </p>";

}

?>

Output:

Valid Url: http://www.validurl.net/anypath/anyfile.php?anything

Invalid Url: http://invalidurl-^.

Note: To only allow domain names website addresses without any paths behind it ( like: http://www.google.com ) remove the last part of the pattern between brackets followed by a * ( which is: (\/|\/[A-Za-z0-9-_ .]*)* ) or replace it by (\/)? if you do want to allow a possible ending backslash ( http://www.google.com/ ).

Example:

<p><a name="paragraph1">Paragraph 1</a></p>

some very long text here

<p><a name="paragraph2">Paragraph 2</a></p>

another very long text

In this example we set 2 paragraphs names: paragraph1 and paragraph2. Both are now automaticly scrolled to by adding #paragraph1 or #paragraph2 to the url. However this is of course only usefully when you’ve got a very long text as mentioned before, where you’ve got a long scroll bar wherefore it would be easy to have an index page for the article including links to all paragraphs.

Example2:

<h2>Paragraphs</h2>
1. <a href='#paragraph1'>Paragraph1</a> <br />
2. <a href='#paragraph2'>Paragraph2</a> <br />

<p><a name="paragraph1">Paragraph 1</a></p>

some very long text here

<p><a name="paragraph2">Paragraph 2</a></p>

another very long text