Webcodez at Squidoo

• HTML Basics Tutorial
• PHP & MySQL Poll System Tu…
• PHP basics tutorial
• CSS Basics Tutorial
• PHP & MySQL Visitors Count…
• How to install PHP & MySQL…
• PHP & MySQL Login System T…
• PHP POST and GET Variables Tut…
• MySQL Basics Tutorial
• PHP Banner Rotator Tutorial
• PHP Email Validation Tutorial
• PHP Functions And Classes
• PHP Random Password Generation…
• PHP Smilies System Tutorial
• PHP Sessions and Cookies Tutor…
• PHP Arrays Tutorial
• PHP Including Files And Securi…

To match a regular expression pattern with a string, we may use the preg_match or preg_match_all function. The difference between these two functions is that preg_match stops searching for a match after one has occurred while preg_match_all continues to search for all matches. The preg_match function therefore is moreover used to check whether a pattern occurs inside a string, while the preg_match_all function is used to actually retrieve all matches with the pattern inside the string. So how do we set up a pattern? Therefore multiple symbols can be used. Here’s a table of the most common ones:

Symbol	Meaning
^	The word after this symbol should be at the beginning of the string to match.
$	The word before this symbol should be at the end of the string to match.
*	The expression before this symbol may occur any amount of times in the string to match.
?	The expression before this symbol may or may not occur once.
+	The expression before this symbol should at least occur once.
{x}	The expression before this symbol should occur x amount of times.
{x1,x1}	The expression before this symbol should occur atleast x1 amount of times, max x2 amount of times.
.	Any character.
|	Either the expression before or after this symbol should match.

Expression	Meaning
bar$	The string to match should contain the word ‘bar’ at the end of the string.
^foo(.*)bar$	The string to match should contain the word ‘foo’ at the beginning of the string AND the word ‘bar’ at the end of the string.
^[A-Za-z]*[0-9]*$	The string to match should start with only letters and end with only numbers.
.*	Any amount of any characters.
[A-Za-z]	Any letter ( basicly: all the characters between the brackets are allowed).
[A-Za-z]*	Any amount of letters ( but also: only letters ).
[A-Z]|[a-z]	Either a capital or a non-capital letter.
^foo	The string to match should contain the word ‘foo’ at the beginning of the string.

preg_match example

<?php
//preg_match([pattern], [string], [match], [flag], [offset])

$pattern = “/^[A-Za-z0-9_]*@[A-Za-z0-9_]*\.com$/”;
$str1       = “match_example@provider.com”;
$str2       = “no_match_example@provider.nl”;
$str3       = “no-match@[test.com”;
$str4      = “example_match123@456web.com”;

if(preg_match($pattern, $str1)) {
echo “$str1 matches.”;
}else{
echo “$str1 does not match.”;
}

if(preg_match($pattern, $str2)) {
echo “$str2 matches.”;
}else{
echo “$str2 does not match.”;
}

if(preg_match($pattern, $str3)) {
echo “$str3 matches.”;
}else{
echo “$str3 does not match.”;
}

if(preg_match($pattern, $str4)) {
echo “$str4 matches.”;
}else{
echo “$str4 does not match.”;
}
?>

preg_match_all example

<?php
//preg_match_all([pattern], [string], [matches], [flag], [offset])
$pattern = “match[0-9]”;
$str         = “this is match1 and this is match2”;
if(preg_match_all($pattern, $str, $matches)) {
print_r($matches); //prints the array containing all matches found
}
?>

Why would I use classes & objects?

You may be asking yourself: why would I use OOP? That question has one simple answer: for writing your codes fast, efficient and keeping them clear.

Creating a class

As mentioned before, a class consists of constants, variables and methods. There’s one default method which ‘creates the object’. It is automaticly executed when an object of the class is created. In other words: it can be used to ‘initialize’ the object ( its default properties e.g. ). This method is called the construction ( __construct ) method.

class ClassName {
	public function __construct( ... arguments ...  ) {

	}
}

What you may have noticed is that there’s the keyword ‘public’ before the function. This indicates that the function may be used/called from anywhere ( also from outside the class ). There are 3 types of keywords that indicate how a function may be accessed:

• Public May be accessed from anywhere: inside the class, outside the class or from a
  parent  class
• Protected May be accessed from inside the class OR from a parent class.
• Private May be accessed ONLY from inside the class.

Alright, knowing that, let’s go back to the construction method. The construction method may or may not need certain information to create the object and its properties. These need to be given as arguments to the class ( or: to the construction method of the class ).

For example: for creating a Product object, we may need the id, name and price of the product.

class Product {
private static $id, $name, $price;
	public function __construct( $product_id, $product_name, $product_price ) {

	}
}

The construction method now asks for the id, name and price of the product upon creating an object of the class (a Product object).

Using & Creating class variables and methods

To access variables and methods of the current class we use:
$this->variable_name or $this->function_name(… arguments …). In the example of the product class, we can now set the class variables equal to the ones given as arguments to the construction method:

class Product {
private static $id, $name, $price;
	public function __construct( $product_id, $product_name, $product_price ) {
		$this->id = $product_id;
		$this->name = $product_name;
		$this->price = $product_price;
	}
}

Now we can create any other functions for the class ourselves, just the same way as the construction method was formed. For example a function to ‘buy’ the product could be created:

class Product {
private static $id, $name, $price;
	public function __construct( $product_id, $product_name, $product_price ) {
		$this->id = $product_id;
		$this->name = $product_name;
		$this->price = $product_price;
	}

	public function buy() {
		echo “Successfully bought the product ‘”.$this->name.”’ for $”.$this->price.”!”;
	}

}

How to create an object of a class?

So far we know how to create a class, but not yet how to create an actual object of the class. It’s however not so hard to do. An object of a class is created using the keyword new followed by the name of the class and brackets which may contain arguments that are required for the class ( by the construction method of the class ). An object is usually created inside of a variable:

$myObject = new ClassName( … arguments … );

We’ll continue with the Product class we’ve been creating. The construction method requires 3 variables to be given values to: product_id, product_name and product_price. These need to be given values to when we want to create an object ( product ) of the class. We do this by giving them as arguments.

$product = new Product( 1, “Example Product”, 9.95 );

This will create an object of the class and set the variable id equal to 1, name equal to “Example Product” and price equal to 9.95. We’ve created a ‘product’! Now we may use any of the public variables and functions of the class. For example the buy function we made.

$product = new Product( 1, “Example Product”, 9.95 );
$product->buy();

This will output:

Successfully bought the product ‘Example Product’ for 9.95!

Note: the script of the class we created needs to be included in the script that creates the object of the class and needs to be put BEFORE it, so that the class is recognized when it’s created. Usually the code of a class definition is put in a separate file ( e.g. ClassName.class.php ) and then included into the file that uses the class. For example, assuming we put our class code inside the file Product.class.php:

<?php
include(“Product.class.php”);
$product = new Product( 1, “Example Product”, 9.95 );
$product->buy();
?>

Extending classes

Classes can also be extended. When this happens, we create a new class based on an earlier created class. The new (parent) class may use any methods and variables of the earlier created class ( the ‘main’ class ).

class MainClass {

}

class ParentClass extends MainClass {

}

For example:

<?php
class Product {
protected $id, $name, $price; //protected: can be accessed from parent class too
	public function __construct() { }

	public function buy() {
		echo “Successfully bought the product ‘”.$this->name.”’ for $”.$this->price.”!”;
	}
}

class Game extends Product {
protected $rank;
	public function __construct($game_id, $game_name, $game_price, $game_rank) {
		//may use any variables from the parent class (‘Product’)
		$this->id = $game_id;
		$this->name = $game_name;
		$this->price = $game_price;
		//may also create and use its own, new variables
		$this->rank = $game_rank;
	}
}

$test_game = new Game(1, “Test Game”, 19.95, 3);
//when creating an object of the Game class, the methods of the ‘main’ class may be used
$test_game->buy();
?>

<form method=”POST” action=”<?=$_SERVER[‘PHP_SELF’];?>”>
<input type=’text’ name=’username’>
<input type=’password’ name=’password’>
<input type=’submit’ name=’submitBut’ value=’Login!’>
</form>

The above form has 3 fields. Two of them are text fields which can be given values to by the user. The other ‘field’ is a submit button ( which will automaticly be given the value ‘Login!’ in this example ). The method of the form is set to ‘POST’, which means: once the user presses the submit button, all form data is stored into the $_POST array and sent to the target page ( as set in the action parameter of the form tag ). In this example form the values of 3 fields will be stored inside the $_POST array like this:

$_POST[‘username’] = “ ... “;
$_POST[‘password’] = “ ... “;
$_POST[‘submit’]      = “Login!”;

Where … would be replaced by the user filled in values.

How to check whether a form was submitted
We know that once a form is submitted the $_POST array is created containing all form data. Therefore we can just check whether the $_POST array is set to define whether the form was submitted.

<?php
if(isset($_POST) AND !empty($_POST)) { //if the $_POST array is set and not empty
	//... form was submitted ...
}else{
	//... form isn’t submitted yet ...
}
?>

Note: If multiple forms can be submitted at one page, you could identify the submitted form by checking
for example the POST variable for the submit button of that form.

Example of usage

<?php
if(isset($_POST) AND !empty($_POST)) { //if the $_POST array is set and not empty
	//... form was submitted ...
	// -> show filled in form values
	echo “<p><b>Username:</b> “.$_POST[‘username’].” </p>”;
	echo “<p><b>Password:</b> “.$_POST[‘password’].” </p>”;
}else{
	//... form isn’t submitted yet ...
	// -> show form
?>
	<form method=”POST” action=”<?=$_SERVER[‘PHP_SELF’];?>”>
	<input type=’text’ name=’username’>
	<input type=’tetx’ name=’password’>
	<input type=’submit’ name=’submitBut’ value=’Login!’>
	</form>
<?php
}
?>

http://mywebsite.com/somefile.php?var1=value1&var2=value2&var3=value3

When accessing the URL as shown above, there will be created a total of three GET variables: var1, var2 and var3 with the values value1, value2 and value3. As you can see,  to add GET variables to the URL you need to put a question mark (?) after the filename. Then you can define any GET variables, separated by the AND mark (&).

All GET variables will be created inside an array $_GET. Accessing a file somefile.php through the above example URL, would create the following GET variables in code:

somefile.php(?var1=value1&var2=value2&var3=value3)

$_GET[‘var1’] = “value1”;
$_GET[‘var2’] = “value2”;
$_GET[‘var3’] = “value3”;

To print all GET variables, the print_r function may be used. This may make it even more clear to see what’s happening.

print_r($_GET); //prints the $_GET array on the screen

full function usage

set_cookie( name, value, expire, path, domain, secure, httponly );

basic function usage

set_cookie( name, value, expire);

The arguments of the function are quite a lot, however you usually only need the name, value and expiration data to be set. In fact, only the name must be given for the function to work. The other arguments are optional.

You can as well access any of your cookie variables on any page of your website. They do not need to be ‘activated’ or something, like for sessions, as they’re dependent of the browser. Al though, unlike sessions, cookies need to be created at the very TOP of the page.

Example1.php

<?php
set_cookie( “username”, “Admin”);

// now the cookie can be used anywhere in any file 

// ... rest of your webpage ...

?>

Example2.php

<?php
if(isset($_COOKIES[‘username’]) && !empty($_COOKIES[‘username’])) {

	echo “Welcome back, “.$_COOKIES[‘username’];

}else{

 	echo “You are not logged in.”;

}
?>

You cannot use the set_cookie function after any graphical content ( HTML output ). However you can of course USE your cookies anywhere in your scripts, though they need to be created at the top of a script. For the rest, it can be used just the same way as sessions.

$_SESSION[‘username’] = “Admin”;

You can access any of your session variables on any page of your website. However, there’s one requirement that has to be fulfilled: you need to activate sessions before you can use them. This can be done by calling the function session_start. This must be done before outputting anything graphical ( e.g. HTML / Text ). For example:

<?php
session_start();

$_SESSION[‘username’] = “Admin”;

//… here goes the rest of your webpage …

echo “Hi there, “.$_SESSION[‘username’].”!”;

?>

Calling the function at the beginning of the file is always good.

Example of usage:

create_session.php

<?php
session_start();

$_SESSION[‘username’] = “Admin”;

?>

Note: You have to run this file to make it create the session.

use_session.php

<?php
session_start();

if(isset($_SESSION[‘username’]) && !empty($_SESSION[‘username’])) {

	$username = $_SESSION[‘username’];

}else{

	$username = “guest”;

}

if($username == “Admin”)) {

	echo “Welcome back, Admin!”;

}else{

	echo “You’re not allowed to be here, “.$username.”!”;

}

?>

Manner 1

$my_array = array(
                   “sub_var_1” => “value_1”,
                   “sub_var_2” => “value_2”,
                   “sub_var_3” => “value_3”
                 );

Manner 2

$my_array[‘sub_var_1’] = “value_1”;
$my_array[‘sub_var_2’] = “value_2”;
$my_array[‘sub_var_3’] = “value_3”;

However, as you may already have noticed, the first manner is more like a first declaration of the array. The second manner can be used anywhere to alter the array dynamicly or add new sub-variables to it. These sub-variables work just the same way as normal variables ( a name = key, and a value ) and can be used the same way. However this time the ‘prefix’ is different as it’s not just a ‘stand-alone’ variable, but it belongs to an array of sub-variables. A sub-variable of an array is called this way:

$array_name[‘sub_variable_name’]

You can as well have multiple dimensional arrays. For example:

$products = array(
                  1 => array(
                             “name” => “product one”,
                             “price” => “9.95”
                             ),
                  2 => array(
                             “name” => “another product”,
                             “price” => “14.95”
                             )
		);

Now we have 2 sub-variables of the array ( each representing a product’s ID ) which as well have their own array of 2 sub-variables ( for the name and price ). They could as well be created in this manner:

$products[1] = array(“name” => “product one”, “price” => “9.95”);
$products[2] = array(“name” => “another product”, “price” => “14.95”)

Or even:

$products[1][‘name’] = “product one”
$products[1][‘price’] = “9.95”;
$products[2][‘name’] = “another product”;
$products[2][‘price’] = “14.95”;

Which is as well the way how you can use the variables when calling them ( by $array['sub-variable-name'], or a sub-variable of a sub-variable: $array['sub-variable-name1']['sub-variable-name2'] ).

function funcName ( ... arguments ... ) {
	... function process code ...
}

You can give the function any name you like as long as there’s not already an existing PHP function with the same name. The arguments of the function are variables where the function needs values for ( data that’s required for your function to run ). For example: a function that retrieves all data of a user would require the user’s ID to be given as argument to the function. Upon calling the function, these arguments should be given values to. A function is called by its name followed by values for the variables that need to be given as arguments to the specific function, between brackets.

funcName( … arguments … );

The function’s return can be of any type ( boolean, String, integer, anything ). However, do notice that returning a value is different from echoing a value. When a value is returned, it can be catched by a variable. When a value is echoed, it automaticly is displayed on the webpage. For example, a function that returns a value can be compared:

$num = 9;
if(sqrt($num) == 3) {
	echo “The number is 9.”;
}

The function sqrt is a premade function that returns the integer square root of the number given as argument to the function.

while( … condition … ) {
	… execute code …
}

The code between accolades is only executed when the condition between brackets is true ( just like the If Loop) however after it executed the code, it will go back to check the condition again; if it’s still true, it will execute the code again, etc.. This will be repeated until the condition between brackets is no longer true. Only then, it will stop executing the code and continue with the rest of your script ( below the while loop ). Therefore, you should watch out for endless while loops ( which keep repeating themselves for an infinitive time ), for ex.:

$num = 1;
while($num == 1) {
	echo “Num equals 1.”;
}

As num is always equal to 1, this code will be executed forever. When that happens, the rest of your script is no longer executed and the browser will be stuck in executing the while loop script which will cause the browser to crash ( mostly ). A valid example of the use of a while loop could be for ex.:

$num = 1;
while($num <= 10) {
	echo “<p>”.$num.”</p>”;
	$num++;
}

Which shows the value of $num as long as it’s not greater than 10 and then increases it by 1. In other words: it counts to 10.

Now, another form of the while loop is the do while loop. The difference with the while loop is that the code of the do while loop is atleast executed ONCE ( no matter if the condition is true or not ). For example:

$num = 1;
do {
	echo “<p>”.$num.”</p>”;
	$num++;
}while($num <= 0);

Will result in displaying the number 1. However when we’d use the while loop instead, it would result in displaying nothing. The code would not be executed because the variable $num equals 1, which is greater than 0. The condition is false so the code won’t be executed ( not once ) in a while loop. However in a do while loop it executes it at least once but also after that it will check the condition and no longer execute the code when this condition is false.