There are number of advantages of implementing a huge program into a number of subprograms. The first advantage is we can reuse the existing code. During a single execution of a program, a function can be called several times from different places and even from another function. The second advantage is it is easy to understand the program logic, debugging and testing is easier.

Functions can be categorised in two broad topics, built-in functions and user defined functions. Built-in functions are the language constructs that comes with PHP. There are hundreds of built-in functions available in PHP for our use. User-defined functions are the functions created by programmers. In this tutorial we will discuss user-defined functions in detail.

Creating function

Let us start with a simple function that calculates sum of two numbers.

Example#1

/*
This function calculates the sum of two numbers
*/
function sum()
{
//declare and initialize variables
$x=20;
$y=30;
$z=$x+$y;
//print the result
echo 'The value of $x is '.$x. ' and value of $y is '. $y .' The result of $x + $y is '.$z;
}
//Execution of this program starts from here, and calls the function sum, that means code inside the function sum will be executed
sum();
?>

Function with parameter

Though we can call the function sum in example#1 as many times as we want, it produces the same result. Let us modify the above code to achieve better result.

Example#2

/*
This function calculates the sum of two numbers
*/
function sum($x,$y)
{
//Calculate result
$result=$x+$y;
//print the result
echo $result;
}
//Execution starts from here
$x=20;
$y=30;
sum($x,$y);

//We can call the function using different value
$x=200;
$y=300;
sum($x,$y);
?>

The code in both examples provides the same functionality but the variables in example#1 are hardcoded inside the function itself and hence, can provide the functionality of adding the hardcoded values. If we have to add other numbers we have to write another function. The code in example#2 solves this problem by passing parameters and provides more functionality. We can add any two numbers any times by just calling the function with parameters. The function sum in example#2 takes two parameters. The parameters are enclosed in parenthesis and separated by comma.

Function with parameter and return value

A function can also return value. The return statement is optional. A function can return any type including arrays and objects. After a function returns a value, its execution is passed back to the line from which it was called. Let us modify the code of example#2 to see how a function can return value.

Example#3

/*
This function calculates and returns the sum of two numbers
*/
function sum($x,$y)
{
//Calculate result
$result=$x+$y;
return $result;
}
//Execution starts from here
$x=200;
$y=300;
//calculate and print the result
echo "The sum is : ". sum($x,$y);
?>

For a complete reference of functions please visit http://www.php.net/manual/en/language.functions.php
webanddesigners.com

Classes add a lot of functionality to your code and help to stop you repeating yourself over and over again as you might in conventional code. With classes and functions you’ll be able to make generic scripts that you can simply call when you need them.

Not only this but classes make your coding a lot more tidy, so you can usually find everything you’re looking for. When you know how to use them they can really speed up the speed at which you’re working.
Why should I learn OOP in PHP?

Well, sort of like real languages (sort of) once you know one programming language, its sort of similar across the board. Sure you’ll have the odd difference here and there, but there won’t be any really huge differences. Apart from that, PHP is one of the most widely used server side languages on the web, and it’ll definitely be worth your time learning to use objects in it.

Class is in Session

In Object Orientated Programming in PHP, we make classes. Classes are sets of functions that we can call when we need to, to use in our applications or websites. A class is pretty easy to make, just write class followed by the name you want to call that class. Then open (curly) brackets and close them at the end of the class. Here’s an example.

1.
2.

3.
class name_goes_here {
4.

5.
}
6.

7.
?>
And there you have it, your first class. Are you proud of yourself? You should be! Lets add a function. These work the same way regular PHP funtions work. Just stick it inside the curly brackets.

01.
02.

03.
class firstClass {
04.

05.
function myFunction($variable, $variable_2 = 1) {
06.

07.
if($variable = 1 && $variable_2 = 1) {
08.
echo"Hello World";
09.
}
10.

11.
}
12.

13.
}
14.

15.
?>
Don’t understand functions? Let me explain. Functions are declared by writing the word function, followed by the name you wish to call it and two curly brackets. Inside the curly brackets you can add variables inside these brackets, which help you add additional settings to that function.

For instance, I could have a variable in the curly brackets, called “$variable”. It would be required that I define this variable when calling the function (we’ll get to that later). We can then use that variable inside the function, so that the variable can serve a different purpose in different cases. We can also set the variable to a default value which it will take if the user doesn’t define it, so we can put “$variable = 1″ in the brackets where 1 is the default value. If a default value is given, then you don’t have to define that variable when calling the function. Here’s an example:

01.
02.

03.
function myFunction($variable, $variable_2 = 1) {
04.

05.
if($variable = 1 && $variable_2 = 1) {
06.
echo"Hello World";
07.
}
08.

09.
}
10.

11.
?>
In the above $variable and $variable_2 must be set as 1 for the script to output “Hello World”. $variable_2 is already set as 1, so the user just has to set $variable as 1 for it to work (when calling the function).

So lets say, somewhere else in your file hierarchy you need to call that class and function. First we have to include the class file, and call a new instance of the class. Then we will call our function (myFunction) and define the variable $variable as 1 so that we’ll get the “Hello World” text.

01.
02.

03.
include"class.php";
04.

05.
$class = new firstClass();
06.

07.
$class->myFunction($variable = 1);
08.

09.
?>
Basically, that’s all there is to it, if you just want to create basic classes and functions. You can have as many functions as you like, so this will work fine:

01.
02.

03.
class myClass {
04.

05.
function functionOne() {
06.
}
07.
function functionTwo() {
08.
}
09.
function functionThree() {
10.
}
11.

12.
}
13.
?>
Just call the functions in the same manner as we did before.

Variables variables variables variables

Classes can have variables. In PHP5 to define a variable in a class you would do something like this:

01.
02.

03.
class myClass {
04.

05.
public $var;
06.
public $house = "312";
07.

08.
function myFunction() {
09.

10.
}
11.

12.
}
13.

14.
?>
There are actually three ways you can declare a variable. You can change the public keyword to private or protected. In PHP4 you would have used the keyword var, which is now deprecated. However if you use it in PHP5 it will be as if you used public. You can use these keywords with functions as well, for example:

01.
02.

03.
class myClass {
04.

05.
public myFunction() {
06.
}
07.

08.
}
09.
?>
By default however, all functions in a class are defined as public, so you do not need to write public beside every function.

But what do these words mean?
Public is basically the default mode, and will allow you to do everything we’ve explained so far. It makes no difference to your coding if you’re using just public.
Private means that the function or variable can only be accessed from inside that class (we’ll get to calling stuff inside a class next). This means that if you have a private function, you won’t be able to do this as it is outside the class it originated from:

01.
02.

03.
include"class.php";
04.

05.
$class = new firstClass();
06.

07.
$class->myFunction($variable = 1);
08.

09.
?>
It also means (when we get to it) you can’t use private functions or variables in a child class. Public also allows the outside world to access/alter it, whereas private does not.
Protected is sort of a hybrid mode, in that if you have a protected variable it will act as public inside the class and that classes child class (if any), but will be private outside of that.

Calling stuff inside a Class

This is pretty basic stuff. We’ve learned how to create variables, classes and functions so far, but how do we actually use that stuff together? You may have noticed that when we included the class and declared a function we used a new operator which looked like an arrow (->). We use this to call stuff inside a class too. Lets say we have an empty variable at the top of our class and we need to call it inside a function in that class. We use a special variable called $this followed by our new arrow operator and the variable name. Look, here’s an example:

01.
02.

03.
class myClass {
04.

05.
public $variable;
06.

07.
function myFunction() {
08.
$this->variable = “Hello There”;
09.
print $this->variable;
10.
}
11.

12.
}
13.

14.
?>
The same thing will work with functions; for instance, if you have two functions and you want to call one inside another, just do this:

01.
02.

03.
class myClass {
04.

05.
function functionOne() {
06.
echo"Hello World";
07.
}
08.
function functionTwo() {
09.
$this->functionOne();
10.
echo” my name is Johnny”;
11.
}
12.
}
13.

14.
?>
Instead of trying to overload you with information, I’ve decided to do this as a tutorial series, in different parts so you don’t get too much information at once. You should be able to make your own simple classes with this information.

Anyway, mess around with the information I’ve given you so far. Hopefully you should be able to make your own little creations. Until next time, my friend.

And what is more important, 3D City also goes free now. If you have a community or dating site you need to have something to attract customers. Day by day. Having a real 3D City live chat software on your site is sure to bring you a lot of new visitors. A new menu item will be added to your page: 3D City. The customer clicks on it and comes to an online virtual world, inhabited by other visitors of your site. They can chat and walk there together. After you purchase the internet 3D chat software, we will install it on your site free of charge. We will connect it to your user’s database seamlessly.

Hello, and welcome to another PHP tutorial. This one will teach you how to make a nice PHP calendar (in PHP of course!). When I started out in PHP I always wanted to know how to make a calendar, but could never find the tutorial to do it. So i figured I’d write my own up, to help anyone who is in a similar situation to what I was in. Click the read link to find out more.

Step 1. Getting Started and defining variables

If you’re a bit rusty, or are new to PHP you might want to check out our Short beginners guide, to get the basics down before you start this tutorial. Start the PHP document as you’d start any other, with a PHP open and close tag:

[sourcecode language="php"]

?>
[/sourcecode]

After that I decided to get the main variables sorted out. This is also pretty easy, it just requires some knowledge of the date and time functions. First of all, I decided that my PHP Calendar would be dynamic, as in, I could go through the months, and even the years.

So first, what I did was to get the ?month= part of the url.
[sourcecode language="php"]

if($_GET['month']) {
$month = $_GET['month'];
}
else {
$month = date(‘n’);
$_GET['month'] = date(‘n’);
}
[/sourcecode]

Okay I’m sure this must look difficult, but let me explain it line by line.
[sourcecode language="php"]
if($_GET['month']) {
[/sourcecode]

What we’re saying there, is if we can get the month from the url, then we will do whatever is inside the curly brackets. $_GET is a global variable, and month is what we’re trying to get from the url.

[sourcecode language="php"]
$month = $_GET['month'];
}
[/sourcecode]

Then what we do is we put the month (which we get from the url again) into a variable called month, and close the if statement with a curly bracket.
[sourcecode language="css"]

else {
$month = date(‘n’);
$_GET['month'] = date(‘n’);
}
[/sourcecode]

Otherwise (else), we set the month variable to the current month, as a default value if no other value is given. We also set $_GET['month'] to the current month (that’s what the date(’n’) bit does, it gets a numerical value for the month). You can’t see it in the url this time, but it is there. If you’re new to the whole date() function shindig, you might wanna check out this page: PHP Date Function. Next I did the same for the year:

[sourcecode language="php"]

if($_GET['year']) {
$year = $_GET['year'];
}
else {
$year = date(‘Y’); // Year
$_GET['year'] = date(‘Y’);
}
[/sourcecode]

Okay, if you understood the last bit, you should probably understand this bit. We’re doing exactly the same thing here only with the year. We’re saying, if we can get the year from the url, then put it in a variable. Otherwise, the year is the default year (current year, thats what date(’Y’) does, again.), and so is $_GET['year'] since it is not defined. Now that we have all this url business sorted out, let me give you an example of a url. Say that you are viewing July 2006. The url would look something like this: ?month=7&year=2006. See how that works? July is the 7th month, and the year is 2006. Lets move on. Next I defined 4 more variables, that control the date, etc.
[sourcecode language="php"]
$firstday = mktime(0, 0, 0, $month, 1, $year);
$number = cal_days_in_month(CAL_GREGORIAN, $month, $year); // Number of Days in a Month
$title = date(‘F’, $firstday); // Month name
$day = date(‘D’, $firstday); // Day
[/sourcecode]

This might look a bit daunting at first, but lets break it down.
$firstday = mktime(0, 0, 0, $month, 1, $year);
[/sourcecode]

All that the above variable does is gets the first day of the current month (and year), as something called a unix timestamp.
[sourcecode language="php"]
$number = cal_days_in_month(CAL_GREGORIAN, $month, $year); // Number of Days in a Month
[/sourcecode]

Another basic function, which gets the number of days in the month, using the gregorian calendar.
[sourcecode language="php"]
$title = date(‘F’, $firstday); // Month name
$day = date(‘D’, $firstday); // Day
[/sourcecode]

These lines find the month name using the timestamp we defined earlier as $firstday, and the name of the first day, again, using the timestamp we got earlier. Now that we’ve got the basic data defined, lets move on to some more intricate stuff.

Step 2. Finding out what the first day is called

So next we’re going to find out what the first day is, and then set a break before that. This is so that we don’t end up with the 1st beng a thursday, and then displaying in a column which should be for sundays.

[sourcecode language="php"]

if($day == “Sun”) {
$before = “0″;
}
elseif($day == “Mon”) {
$before = “1″;
}

elseif($day == “Tue”) {
$before = “2″;
}

elseif($day == “Wed”) {
$before = “3″;
}

elseif($day == “Thu”) {
$before = “4″;
}

elseif($day == “Fri”) {
$before = “5″;
}

elseif($day == “Sat”) {
$before = “6″;
}
[/sourcecode]

This is actually pretty straight forward. We’re just setting a variable called before, depending on what day the first day of the month is. If the first day of the month is Sunday, then there is no need to move the calandar at all, therefore, “before” is zero, because sunday is the first day of the week. However, if it’s Wednesday, and we dont set a break, then it will appear in the first column, which is supposed to be for Sunday. Therefore we need 3 breaks (in the 4th column), where wednesday should be. So we set “before” as 3, for 3 breaks.

Setting the scene

Okay, so I mentioned earlier that I want this to be a dynamic calendar. So we’re going to need links, to move between the different months. This is a pretty straight forward part of code. I’ll show you the links first, and then we’ll define the variables.

[sourcecode language="php"]
echo”«“;
echo”  $title $year  ”;
echo”»“;
[/sourcecode]

I don’t think this needs much explaining. All we’re doing here is echoing out variables that we made previously, well, apart from $previousmonth, $nextmonth, $previousyear and $nextyear. However, lets define those now. Put all of this above the links and title we just made.

[sourcecode language="php"]

if($_GET['month'] == 12) {
$nextmonth = 1;
$previousmonth = $_GET['month'] – 1;
$nextyear = $_GET['year'] + 1;
$previousyear = $_GET['year'];
}
[/sourcecode]

To start, what I did was to figure out whether or not this was the 12th month (december). After that I started defining variables. It makes sense logically, that if this month is the 12th month, then the next month will be January, or the first month, and that’s why $nextmonth is 1. However, the $previousmonth will be the current month (which we get from the url), minus 1. If we decided to go to the next year by pressing the next button, it will be the current year (which we get from the url), plus 1. Whereas, the previous year will just be the same, because going back will bring you to november, which is still in the same year. Another important thing to think about is if the month is January:
[sourcecode language="php"]
elseif($_GET['month'] == 1) {
$previousmonth = 12;
$nextmonth = $_GET['month'] + 1;
$previousyear = $_GET['year'] – 1;
$nextyear = $_GET['year'];
}
[/sourcecode]

So what we’re saying here, is if the month is 1 (elseif), then the previous month is going to be 12, logically. Whereas the next month is going to be the current month, plus 1. The previous year will be the current year, minus one, and next year will be the current year, since the next month is February, which is in the same year as January (1st month). Finally, we’ll finish with the else statement
[sourcecode language="php"]
else {
$nextmonth = $_GET['month'] + 1;
$previousmonth = $_GET['month'] – 1;
$nextyear = $_GET['year'];
$previousyear = $_GET['year'];
}
[/sourcecode]

So if the month is neither january or december, then the next month will just be the current month + 1, the previous month will be the current month – 1, and the next and previous year will stay the same. Remember to put all of this above the links we made before, or else it won’t work.

Looping it all out

To start this I defined two variables that I will use in the loops:

[sourcecode language="php"]
$i = 1;
$real = 1 + $before;
[/sourcecode]

we’ll explain these later, when we’re doing the loops. After that I made a table. As much as it pains me to make a table, I felt it was easier than doing a bunch of divs. You’re welcome to change the table to divs if you want.
[sourcecode language="php"]

echo”
“;
[/sourcecode]

Right, so lets make a loop.
[sourcecode language="php"]

while($before > 0) {
echo”

“;
–$before;
}
[/sourcecode]
Okay, so this is where we make the breaks, that I was explaining earlier. We want to leave blank spaces so that Wednesday doesn’t appear in a column which is for Sunday. Let me explain it, line by line
[sourcecode language="php"]
while($before > 0) {
[/sourcecode]
All we’re doing here is checking if the $before variable (remember, we defined it earlier) is more than zero, then the loop will continue.

[sourcecode language="php"]

echo”

“;
–$before;
}
[/sourcecode]
If it is more than zero, then take 1 away from the before variable, and show an empty table

element. This will show the correct number of blank spaces, so that we don’t end up with the problem i explained earlier.

[sourcecode language="php"]
while($i <= $number) {

echo"

“;

$divide = $real / 7;
if(is_int($divide)) {
echo”

“;
}
++$real;
++$i;
}
[/sourcecode]

We’re nearly done now. Let me explain this loop.
[sourcecode language="php"]
while($i <= $number) {
[/sourcecode]

So we’re saying, while $i (which is equal to 1) is less than or equal to (<=) the number of days in the month selected ($number), then the loop will continue.
[sourcecode language="php"]
echo"

“;
[/sourcecode]
So first of all we echo out the number, or date in a

table element. However, if we left it like that, it would just be a straight line of numbers. We don’t really want that. To seperate the days by the week they’re in, we use a nifty little trick:

[sourcecode language="php"]
$divide = $real / 7;
[/sourcecode]
You’ll remember that $real variable we defined earlier. Well we try and divide it by 7 here. Then..
[sourcecode language="php"]
if(is_int($divide)) {
echo”

“;
}
[/sourcecode]

We check if it is an integer, using the is_int() function. An integer (you may or may not know) is a whole number. So if the $real variable is divisible by 7, then we make a break in the table, using the

elements.
[sourcecode language="php"]
++$real;
++$i;
}
[/sourcecode]

Finally we add 1 to $real and $i using the ++ operator, so we don’t end up with an never ending loop. Then I closed the loop. To finish off, finish the table we started earlier:

[sourcecode language="php"]
echo”

		$i
$i

“;
?>
[/sourcecode]
And we’re done. I hope this tutorial proved useful.

Final Code

[sourcecode language="php"]

if($_GET['month']) {
$month = $_GET['month'];
}
else {
$month = date('n');
$_GET['month'] = date('n');
}
if($_GET['year']) {
$year = $_GET['year'];
}
else {
$year = date('Y'); // Year
$_GET['year'] = date('Y');
}

$firstday = mktime(0, 0, 0, $month, 1, $year);
$number = cal_days_in_month(CAL_GREGORIAN, $month, $year); // Number of Days in a Month
$title = date('F', $firstday); // Month name
$day = date('D', $firstday);

if($day == "Sun") {
$before = "0";
}
elseif($day == "Mon") {
$before = "1";
}

elseif($day == "Tue") {
$before = "2";
}

elseif($day == "Wed") {
$before = "3";
}

elseif($day == "Thu") {
$before = "4";
}

elseif($day == "Fri") {
$before = "5";
}

elseif($day == "Sat") {
$before = "6";
}

if($_GET['month'] == 12) {
$nextmonth = 1;
$previousmonth = $_GET['month'] - 1;
$nextyear = $_GET['year'] + 1;
$previousyear = $_GET['year'];
}

elseif($_GET['month'] == 1) {
$previousmonth = 12;
$nextmonth = $_GET['month'] + 1;
$previousyear = $_GET['year'] - 1;
$nextyear = $_GET['year'];
}

else {
$nextmonth = $_GET['month'] + 1;
$previousmonth = $_GET['month'] - 1;
$nextyear = $_GET['year'];
$previousyear = $_GET['year'];
}

echo"«“;
echo”  $title $year  ”;
echo”»“;

$i = 1;
$real = 1 + $before;

echo”
“;
while($before > 0) {
echo”

“;
–$before;
}

while($i <= $number) {

echo"

“;

$divide = $real / 7;
if(is_int($divide)) {
echo”

“;
}
++$real;
++$i;
}

echo”

	$i

“;

?>
[/sourcecode]

Credit To : http://webtint.net

This time around, we’re going to make it easy for ourselves to add in additional administrators without much additional code. Instead of using a bloated OR check for each email address, we’ll just have Wordpress run through a preset array containing all of the emails of blog administrators. If the email of a commenter also belongs to an administrator, the comment will be assigned a separate style to make it stand out.

Build the Email Array

Before we’re able to have comments highlighted, we’ll need to specify which emails deserve special treatment. I’ve used some of Sam and I’s email addresses as an example.

[sourcecode language="php"]
//List of emails to highlight
$admin_emails = array(
"zach@buildinternet.com",
"sam@buildinternet.com",
"zach@onemightyroar.com",
"sam@onemightyroar.com"
);
?>
[/sourcecode]

You’ve Got Options

Emails do not have to belong to a registered user in this method. If you have multiple email accounts, the array can check for all of them. This opens up many more options for expansion.

The downside to this route is the loss of automation. Each email addresses must be entered in manually by the blog administrator. It would be much easier to have Wordpress automatically detect the administrator accounts for the blog installation. That’s where the second option comes in.

The Automated Database Method

If we wanted to, we can code this so that we’ll never have to manually insert emails into the comments.php file once it’s been set up. We can have Wordpress pull all of the email addresses of registered users with privileges of Editor and Administrator. For most blogs, this will fit your needs just fine.

Query the Database

We’ll first need to get all of the admin emails from the database and place them into an array. This is easy to do using the Wordpress database object, to query the database for specific users.

[sourcecode language="php"]

//Automatically pull admin accounts

$user_level = 8; //Default user level (1-10)
$admin_emails = array(); //Hold Admin Emails

//Search for the ID numbers of all accounts at specified user level and up
$admin_accounts = $wpdb->get_results(“SELECT * FROM $wpdb->usermeta WHERE meta_key = ‘wp_user_level’ AND meta_value >= $user_level “);

//Get the email address for each administrator via ID number
foreach ($admin_accounts as $admin_account){

//Get database row for current user id
$admin_info = $wpdb->get_row(“SELECT * FROM $wpdb->users WHERE ID = $admin_account->user_id”);

//Add current user’s email to array
$admin_emails[$admin_account->user_id] = $admin_info->user_email;
}

?>
[/sourcecode]

If this is your first experience with the Wordpress database object (or databases in general) the code above may seem a little bit confusing. Here’s a breakdown of what’s going on to help sort it out:

• The $user_level variable contains a number 1-10. Wordpress user roles (e.g. Administrator, Editor, etc.) are all represented by a number value. To select Administrator accounts only, this number must be set to 8.
• The $admin_emails array will hold the emails returned from the query.
• The first database query searches the usermeta table for all users with a user level greater than or equal to the one stored in $user_level. The results are stored in the $admin_accounts array.
• Each item in the $admin_accounts array is processed, and the user table is queried using the user id number pulled from step 3. The email address is retrieved and stored in the $admin_emails array using the user id as an identifier in the array.

By the end of this code block, we have an array containing the email addresses of the specified user levels stored in $admin_emails. The nice part? This method will update itself when new users are registered. Just set it and forget it.

Marking Administrator Comments

At this point, both methods have the same next step. You’ll have an array of administrator emails stored in $admin_emails. We’ll need this as a reference when marking comments for special attention.

Filter the Comments

Now that we’ve got a list, we need to check each comment for admin email matches. If one is found, the comment will be assigned a class of “admincomment” and get different styling.

In the comments.php file of your blog theme, locate the foreach comment loop, and paste the following immediately under the start of it:

[sourcecode language="php"]

//Default to
$admin_comment = false;
foreach ($admin_emails as $admin_email){
//If comment was made from an admin email
if($comment->comment_author_email == $admin_email){
$admin_comment = true;
break;
}
};
?>
[/sourececode]

The above code grabs the comment author’s email address and checks it against those in the admin email array. If a match is found, $admin_comment is set to true.

Assign Special Class to Comments

Special comments are marked with a class of “admincomment” by default. I’ve put a stripped down sample comment below to help you visualize. Pay special attention to the PHP included in the class attribute.
[sourcecode language="php"]

Styling the Comments
Giving administrator comments some extra flair is the easy part. In both methods above, you’ll end up with a class of “admincomment” on comments to highlight. Since you’ve got a specific class to target, giving it some special styling is just an extra CSS style away.

I’ve included a sample CSS snippet below to help you get started, but feel free to get creative on your final product.
[sourcecode language="css"]
.admincomment{background:#191919; color:#FFF; border:1px solid #333;}
[/sourcecode]

Download Code Snippets

To help you along, I’ve put together a comment file with the necessary code snippets. It should help clear up any confusion left over about placement and ordering. You can grab the file using the link below:

Download Source : Click Here

Credit To : http://buildinternet.com

Share and Enjoy:

]]> http://www.w3updates.com/server-scripting/php/automatically-highlight-admin-comments-in-wordpress/feed/ 0 http://www.w3updates.com/server-scripting/an-introduction-to-object-oriented-php-part-3/ http://www.w3updates.com/server-scripting/an-introduction-to-object-oriented-php-part-3/#comments Mon, 31 Aug 2009 09:37:06 +0000 alyaspk http://w3updates.com/?p=337

Introduction

Welcome to the third and final part of a series introducing Object Oriented PHP!

In this Tutorial

Today, we are going to finally complete the task that we’ve been leading up to: writing our MySQLi DB class! We’re going to be using everything we’ve learned so far to do this, so strap in and enjoy!

• Variables and Constructor
• Main Functions
• Some extra goodies

Variables and Constructor

Create a new file called class.db.php and insert the following:

[sourcecode language="php"]

/*
* class db
* @param Host
* @param User
* @param Password
* @param Name
*/
class db
{

var $host; //MySQL Host
var $user; //MySQL User
var $pass; //MySQL Password
var $name; //MySQL Name

var $mysqli; //MySQLi Object

var $last_query; //Last Query Run

/*
* Class Constructor
* Creates a new MySQLi Object
*/
function __construct($host, $user, $pass, $name)
{

$host = $this->host;
$user = $this->user;
$pass = $this->pass;
$name = $this->name;

$this->mysqli = new mysqli($this->host, $this->user, $this->pass, $this->name);

}

}

$db = new db(‘localhost’, ‘root’, ”, ‘blog’);

?>
[/sourcecode]

*Try and dissect what we have done here before reading the explanation!**

First, we have done the most important part of Object Oriented PHP – organization! We have said what the class name is, and all the parameters that need to be passed to it when it is loaded. Next, inside the class, we have defined our four variables for MySQL connection and then required them as parameters of the constructor function, which can be passed when the class is loaded at the bottom of the file. Next, we have set our $mysqli variable to a new MySQLi Object. Simple, right? Let’s move on.

Main Functions

SELECT

Now that we have the connection down, we can start working with the database. Add a select function like this:

[sourcecode language="php"]
/*
* Function Select
* @param fields
* @param from
* @param where
* @returns Query Result Set
*/
function select($fields, $from, $where)
{

$query = “SELECT ” . $fields . ” FROM `” . $from . “` WHERE ” . $where;
$result = $this->mysqli->query($query);

$this->last_query = $query;

return $result;

}
[/sourcecode]
Here we have made a select function for selecting data from a MySQL table. We have defined three parameters, and you can see how they fit into the final query. All we return from this function is a query result set, which you can work with however you like in your pages.

INSERT

Of course, we can select data with our class now, but we don’t have anything to select unless we insert it! Let’s do that now by adding this function to your class:

[sourcecode language="php"]
/*
* Function Insert
* @param into
* @param values
* @returns boolean
*/
function insert($into, $values)
{

$query = “INSERT INTO ” . $into . ” VALUES(” . $values . “)”;

$this->last_query = $query;

if($this->mysqli->query($query))
{
return true;
} else {
return false;
}

}
[/sourecode]

Another quite simple function, we are just requiring two parameters: the table name to insert the data into, and the values for the fields. Instead of returning any real data for this function, we just go ahead and run it and if it inserted the data, it returns true, and if not, false. Simple for inserting data.

DELETE

Now that we can insert and then select our data, we have to have a way to delete it say if a user wanted to delete their account. Add this function:

[sourcecode language="php"]

/*
* Function Delete
* @param from
* @param where
* @returns boolean
*/
function delete($from, $where)
{

$query = "DELETE FROM " . $from . " WHERE " . $where;

$this->last_query = $query;

if($this->mysqli->query($query))
{
return true;
} else {
return false;
}

}
[/sourcecode]

Some extra goodies

You probably noticed the last_query variable we defined at the beginning of the class, then we set it every time we ran a query in a function. This is very vital for troubleshooting, to see what’s wrong with your query. Another possible class variable could be a last_error, that would hold the last error returned.

Conclusion

This will conclude this series on Object Oriented PHP – I hope you’ve at least learned the basics so you’ll be able to power up your applications! Thanks for reading.

Credit To : http://www.buildinternet.com/

Share and Enjoy:

]]> http://www.w3updates.com/server-scripting/an-introduction-to-object-oriented-php-part-3/feed/ 0 http://www.w3updates.com/server-scripting/an-introduction-to-object-oriented-php-part-2/ http://www.w3updates.com/server-scripting/an-introduction-to-object-oriented-php-part-2/#comments Mon, 31 Aug 2009 09:31:30 +0000 alyaspk http://w3updates.com/?p=334

Introduction
Welcome to Part 2 of a three part series introducing Object Oriented PHP!

In This Tutorial

Today, we are going to learn the following:

• Constructors and Destructors
• Returning data from your functions
• Keeping organized

Constructors and Destructors

Think of PHP constructors and destructors like a building. You construct a building at first, then when you’re done using it, you destruct it. Except in PHP, there are no live explosives for the destruction. Let’s look at the following example of constructors:
[sourcecode language="php"]
class MyClass
{
function __construct()
{
echo "MyClass Loaded!";
}
}
$MyClass = new MyClass();
?>
[/sourcecode]
In this example, we create a new class simply called MyClass, then a constructor function that says MyClass Loaded!. Basically, anything you want to happen when you call upon your class, should go in the constructor function.

In PHP, you don’t need to worry about always having a __destruct() method in your class, as all classes and variables are removed after your object is destroyed. (At the end of execution).

Returning data from your functions

In the real world, you don’t want to be using echo statements within your functions, you want to run your function and return the data for you to echo out where you want it. Let’s take a look at the following example that could be part of a blog application:

[sourcecode language="php"]

class MyClass
{

var $mysqli;

function __construct()
{

$this->mysqli = new mysqli(‘localhost’, ‘root’, ”, ‘blog’);

}

function get_latest_posts()
{

//Do some database selection
$query = “SELECT * FROM `posts` ORDER BY `id` DESC”;
$result = $this->mysqli->query($query);

return $result;

}

}

php?>
[/sourcecode]
Here, we are using a constructor to make a new MySQLi connection, and then using that connection set in the constructor to run a possible query, then to return the result set to be used however you’d like to display the data. Simple, right?

Keeping Organized

In the first part of this series, I described classes as boxes, and functions as the things within the boxes. This picture is a great representation of keeping your classes well separated from each other, and their contents nicely arranged.

One key aspect of writing classes is to keep things easy to read and edit later. Let’s take a look at a file from the very popular blogging platform Wordpress. As you can see, above every variable declaration, class declaration, and function declaration, there is vital information about the parameters, what the function does, and what it returns. Let’s write our own example now:

[sourcecode language="php"]

/*
* @name MyClass
* @params none
* Our database class that makes a new database connection, and will insert userdata.
*/
class MyClass
{

/*
* MySQLi Connection Link
*/
private $mysqli;

/*
* __construct
* Sets new MySQLi Connection
*/
function __construct()
{

$this->mysqli = new mysqli(‘localhost’, ‘root’, ”, ‘buildinternet’);

}

/*
* insert_userdata
* @params username, password
* @returns bool
*/
function insert_userdata($username, $password)
{

//Insert the userdata into the database
if(success)
{
return true;
} else {
return false;
}

}

}

php?>
[/sourcecode]

Here, we have said what our class is, what it does, and then defined each function or variable within it. In the insert_userdata() function, we have said what the parameters are and what it returns above the function. As you can already see, these comments help immensely when trying to read your code or trying to find a problem with your code.

Conclusion

Now, after reading the second part in this series, we have all the skills we need to write our MySQLi Database interaction class in Part 3! Thanks for reading and be sure to check back for the third part!

Credit To : http://www.buildinternet.com/

Share and Enjoy:

]]> http://www.w3updates.com/server-scripting/an-introduction-to-object-oriented-php-part-2/feed/ 0 http://www.w3updates.com/server-scripting/an-introduction-to-object-oriented-php-part-1/ http://www.w3updates.com/server-scripting/an-introduction-to-object-oriented-php-part-1/#comments Mon, 31 Aug 2009 09:20:16 +0000 alyaspk http://w3updates.com/?p=332

About This Series

This is a three part series introducing Object-Oriented PHP, a way to manage your code and keep different parts separate, all while being easily accessible.

By the end of this series, we are going to make a very simple MySQLi (MySQL Improved) database interaction class, for doing common tasks.

In this Tutorial

• What the heck are Objects and Classes?
• Writing our first class
• How to use your freshly written class
• How to personalize it
• Let’s get started!

What the heck are Objects and Classes?

Classes, at their simplest point, are just receptacles of functions. They can be compared to a folder on your computer (assuming you aren’t running DOS). Inside the folder you may have three files, or in this case, functions. Let’s use a classic example, a Dog.

Take a look at the following image:

As you can see, a Dog has many “functions”. It can run, walk, sit, play, and bark. This is the essence of what a class is.

An Object, on the other hand, is a way to represent your class. For example, you can have your class named “Dog”, but you can reference it by a variable called Cat if you really wanted to confuse yourself.

That’s all we’re going to cover in this section, so if you’re still confused, read on and I believe the examples will make some coherent sense.

Writing our first class

Since this is just our first class, we’re going to keep things nice and simple. Open up your text editor of choice and make a new file in your web root called myClass.php. Add in the following code:

[sourcecode language="php"]
class myClass
{
function sayHello()
{
echo "Hello there!";
}
}
?>
[/sourcecode]

If you navigate to this file on your server, nothing will show up. All we did was set up a class (container) and add in a function, we never referenced it to be run.

How to use your freshly written class

Now that we have our myClass.php file all written, we’re going to reference it and use it. Make a new file in the same folder as your class is in, called index.php. Add in the following code:
[sourcecode language="php"]

require_once('myClass.php');

$myClass = new myClass();

$myClass->sayHello();

?>
[/sourcecode]

If you run the file, you should see “Hello World!” echoed out. Let’s go over what we did to make this work. First, you can see that we required the myClass.php file, which contains our container full of functions. Next, we had to make a new Object, and we used the class name as the object name, just for ease of use. And finally, we referenced our sayHello function by writing the Object name with an arrow and the function name.

Making it Friendlier

Right now, if we wanted to use this to greet a logged in user, there wouldn’t be much of a sense of personalization, would there? Wouldn’t it be nice if we could say Hello to the specific user? Well, we can! Go back to your myClass.php file and edit it accordingly:

[sourcecode language="php"]
class myClass
{
function sayHello($user)
{
echo "Hello " . $user . "!";
}
}
?>
[/sourcecode]

All we did was add a parameter to the function called name, that we can pass along to the function from our index file. Go back to your index.php file now and add your name like so:

[sourcecode language="php"]

require_once('myClass.php');

$myClass = new myClass();

$myClass->sayHello(‘Dixon’);

?>
[/sourcecode]

Conclusion

Now that we’ve covered the very basics of Object-Oriented PHP, you can practically do it all. And was it hard? Hopefully not! Be sure to check in later for the rest of this series, in which we’ll be making a fully functional MySQLi Database interaction class! Thanks for reading.

Credit To : http://www.buildinternet.com/

Share and Enjoy:

]]> http://www.w3updates.com/server-scripting/an-introduction-to-object-oriented-php-part-1/feed/ 0 http://www.w3updates.com/server-scripting/php/displaying-author-meta-information-in-wordpress-2-8/ http://www.w3updates.com/server-scripting/php/displaying-author-meta-information-in-wordpress-2-8/#comments Sat, 29 Aug 2009 10:11:28 +0000 alyaspk http://w3updates.com/?p=292
One of the (many) nice updates the comes bundled in Wordpress 2.8 is with the_author_meta() template tag. This tag allows a developer to pull and display specific parts of any user’s information within a theme. Even though variations of this have been included in previous releases, this version has simplified it to a much easier syntax.

In this quick overview, we’ll look at some potential uses for the recently overhauled Author Meta template tag. Keep in mind that all of these demonstrations are done within a Wordpress 2.8 installation. If you do not have this version running, these tags will not work as intended.

Displaying the Data

Especially if your site has registered users, this is an easy way to personalize your blog’s theme for each one. Let’s say you wanted to provide users a way to contact you by email:
[sourcecode language="html"]

Get in touch with //Format the author's registration date
$register_date = date("m/d/Y", strtotime(get_the_author_meta('user_registered')));
?>
[/sourcecode]

And this code will give us a formatted output from the results:
[sourcecode language="php"]

has been with us since

[/sourcecode]

As you can see, the result finds the registration date of the user, and then formats it from the original timestamp into something much more pleasant to read. Not bad for a couple lines of code!

Build an Updated Author Box

The tags used there are now deprecated with this update, so let’s take a moment to refresh our code and stay fresh.

Originally, the code to render our author box with a gravatar, linked author name, and description looked something like this:
[sourcecode language="php"]

About

[/sourcecode]
As you can see, the previously used tags don’t really follow a single format. Now let’s take a look at the same result using the updated Wordpress 2.8 tags. For the sake of education, we’ll be replacing the author post link with an anchor to their website’s URL instead.

[sourcecode language="php"]

About http://www.buildinternet.com

Share and Enjoy:

]]> http://www.w3updates.com/server-scripting/php/displaying-author-meta-information-in-wordpress-2-8/feed/ 0 http://www.w3updates.com/server-scripting/display-thumbnails-for-related-posts-in-wordpress/ http://www.w3updates.com/server-scripting/display-thumbnails-for-related-posts-in-wordpress/#comments Thu, 27 Aug 2009 11:57:36 +0000 alyaspk http://w3updates.com/?p=258 In this tutorial you’ll learn how to increase pageviews by adding thumbnails to related posts using the popular YARPP plugin and Wordpress custom fields.

The Goal

Before we start, let’s take a look at the result of what we’re building:


Download the YARPP Plugin

The basis for this tutorial is the popular (and well named) plugin “Yet Another Related Post Plugin” or YARPP for short. We’ve used it on this blog right from the start, and it’s great for generating additional traffic for posts in the same subject. Thanks to the plugin’s latest update, we can now build our own template to display results.

Go ahead and download the plugin now if needed. If you’re installing YARPP for the first time and have questions, I’m going to refer you to the official site for more. This tutorial will start assuming that you have it up and running already.

Create a Related Post Template File

You’ll notice that when you install the plugin, it includes a folder of preset templates for a variety of display options. They are a great starting point for learning the ropes, but since what we’ll be doing is relatively simple we can start from scratch. Begin by creating a new file named “yarpp-template-thumbnails.php” in the root of your theme folder. This file will contain the structure of our related posts display.
[sourcecode language="php"]
Post Thumbnail Template
Author: Zach Dunn (www.buildinternet.com)
*/
?>

Related Posts

have_posts()):?>

have_posts()) : $related_query->the_post(); ?>

//Set Default Thumbnail Image URL's
$related_thumbnail = get_post_meta($post->ID, “thumbnail_url”, $single = true);
$default_thumbnail = ‘default-image.jpg’;
?>

1. 
   ” alt=”” />
   

No related posts found

[/sourcecode]

The code above says that if related posts exist, it will go through each and display the thumbnail image URL stored in the custom field thumbnail_url which has been temporarily saved into the $related_thumbnail variable. If no URL exists there, it will display the contents of the $default_thumbnail. This check keeps posts from being stuck without thumbnail previews.

Feel free to tweak it as needed. This is a stripped down version meant to demonstrate the inclusion of images and text, but there’s really no limit as to how in depth your template can become.

Insert into Single Template

In order to make sure that our related posts show up as intended, let’s manually insert the function into the single.php using the code below. I recommend placing it somewhere under the_content() tag.
[sourcecode language="php"]



[/sourcecode]

Put simply, this code checks to see if the YARPP plugin is active, and shows the related posts if so.

Customize with CSS

To keep things simple, we’ll just stack the results so that the thumbnail displays on top and the post title on the bottom. Paste the following CSS into your theme’s stylesheet for a good starting point.
[sourcecode language="css"]
/* Related Posts */
ol.related-posts {clear:both; text-align:center; margin:10px 0px 0px 0px; padding:0;}
ol.related-posts li{width:120px; float:left; display:inline; margin-right:15px;; padding:0;}
ol.related-posts img{clear:both; padding:5px; background:#F7F7F7; border:1px solid #DDD;}
ol.related-posts a{clear:both; display:block; border:none; text-decoration:none;}
ol.related-posts li{font-size:12px;}
[/sourcecode]

Activate The New Template

Now that you’ve built a form for YARPP to render the related posts from, you’ll have to let the plugin know that you want to use the template. This can be done from within the plugin’s option panel in the Wordpress dashboard.

Look for the “Display Options” section, and check the “Display using a custom template file” box. This will give you a chance to select the correct template from a dropdown box. If you’ve been following along with my naming conventions, you’ll want to pick “yarpp-template-thumbnails.php” and then save your changes.

Specifying Thumbnail in Custom Fields

The frameworks are in place, but how do you specify what thumbnail a post will use? The solution is surprisingly simple. When you’re editing a post in Wordpress, you’ll notice a section below the write panel titled “Custom Fields.” This is where we’ll paste the URL of the thumbnail to be used for each post.

Once you’ve pasted in the URL of the thumbnail image to use, update the post and then YARPP should show it when displaying related posts. No extra headache involved here.

Grab More Attention
With image previews for each of your posts, there’s a better chance someone might see something that inspires them. To help you get started, I’ve included a ZIP file below that contains my version of the YARPP template. At the very least, it should help you get started with your own ventures.

Download : Click Here

Share and Enjoy:

]]> http://www.w3updates.com/server-scripting/display-thumbnails-for-related-posts-in-wordpress/feed/ 0