PHP has set forth certain global variables that makes this process painfully easy. We will be experimenting with several methods of finding certain parts in the URL within this tutorial. Respectively, they are:

1. Finding the current domain
2. Finding the path to the script
3. Finding the query string (if any)
4. Using a special short cut method to tie things together

Finding The Current Domain In PHP

If you need the current domain, you can use this neat little snipped below:

<?php
# Using HTTP_HOST

$domain = $_SERVER['HTTP_HOST'];
echo $domain;
?>

If we were to use this directly on this page, the output would be learnphponline.com – notice that it does not include the ‘http://’ or ‘www.’ prefixes. If you are trying to make a link, you could do so by concatenating these prefixes onto the HTTP_HOST server variable.

Finding The Path To The Current Script

If you need to link to the current page, we use the SCRIPT_NAME server variable. We see this in use a lot more than you would think. WordPress installations will link article titles to the same page for several reasons. First, it keeps things user friendly- but it is also great for search engine optimization. Don’t be afraid to follow their example such as the snippet below shows.

<?php
# Using SCRIPT_NAME

$path = $_SERVER['SCRIPT_NAME'];

echo "Path To Script Example: <a href='$path'>An Article Title</a>";

?>

You will notice that the domain section and query string is left out. Instead we get the script path that links nicely to the current page.

Finding The Query String In a URL

The query string is important in passing variables or authorization information across several different pages in your website. You have probably noticed this before when logging into your favorite website and seen something to this effect: “TheWebsite.com/users/index.php?name=YourName”

Making a query string is actually quite easy. Make a simple PHP file and create a link to the current file, yet concatenate a ternary symbol and assign a variable like this:

• <a href=’www.yoururl.com/index.php?variable=value’>Test it!</a>

This won’t do anything since we haven’t coded anything to work with the variable. But it will allow us to test the server variable below.

<?php
# Using QUERY_STRING

$queryString = $_SERVER['QUERY_STRING'];

echo "Query: " . $queryString;

?>

Finding The Current URL With Request URI

If you are using MOD REWRITE to make your URLs more user-friendly, there is still a way to get the original URL. By using the REQUEST_URI server variable, we can get the URL given to access the page. So be definition, we bypass any rewrite rules.

<?php
# Using REQUEST_URI

echo "http://" . $_SERVER['HTTP_HOST']  . $_SERVER['REQUEST_URI'];

?>

This saves a little bit of space over the previous examples, since REQUEST_URI can replace the script path and query string server variables. This is best used when you don’t need these variables separated, which you commonly do.

Security Issues To Consider

There are many ways to get the current URL, but the ones mentioned here are the safest. The server variable PHP_SELF is an example of a method that can result in cross-scripting attacks (XSS). Instead make sure you use the SCRIPT_NAME variable as we did above in our examples.

Also make note that header information can be faked. Any variable that includes “HTTP” in it has a potential to be untrustworthy data. There are always verification methods and alternatives to these pitfalls, so you aren’t without options.

A humorous example of how HTTP headers can be faked is with certain security software packages that rewrite referrer information that websites use for analytics. By setting your referrer field to something such as “FBI” or “CIA” you can effectively give the statistics-conscious webmaster a nice scare.

Closing Comments

As a last note, be sure to encode any URL information you make use of if you are using these server variables for your own coding experiments. Otherwise malicious users may take advantage of your inept security tactics and cause havoc on your database.

Find An Odd Or Even Number With The IF Statement

We can check for whether or not a number is even or odd by using the modulus operator seen below.

<?php

if (7 % 2) {
  echo "7 is odd";
} else {
  echo "7 is even";
}  

?>

We interpret the first line as “Divide 7 by two, and check for a remainder.” If there is a remainder (in our case we have 3.5, so a remainder of 0.5), then the number is odd. If there isn’t a remainder while dividing by two, then that number is even.

You could change the three sevens in the above script to eights, and you will notice the script outputs the number is even, since 8 divided by two is 4 with no remainder.

Checking For Odd And Even Numbers With A PHP Function

We can clean up so code here by using a function to do the dirty work for us. First we’ll stick the if statement into a function and make sure it works, then we’ll optimize our code once we get the concept up and running.

<?php

function is_odd($num) {
  if ($num % 2 == 0) {
  return false;
 } else {
    return true;
  }
}
############################

if (is_odd(4)) {
 echo "This number is odd.";
} else {
  echo "This number is even.";
}

?>

The function will do exactly what we just did with our IF statement previously, only this time we can reuse our code and save quite a bit of space. We supplied the is_odd function with a plain number; if we wanted we could put in a variable. In fact, we’ll do just that while we optimize our code in the next example.

<?php

function is_odd($num){
 return $num % 2 == 0 ? false:true;
}

$number_To_Check = 3;
if (is_odd($number_To_Check)) {
  echo "$number_To_Check is odd.";
} else {
  echo "$number_To_Check is even.";
}
?>

This time around we are saving even more space by using the ternary symbol (?). In this instance the left side of the colon is what gets executed if the statement is true, and the right side is what gets executed if the statement is false. Think of the colon as an “else” statement.We can use some pseudo-code to help understand this more:

<?php

function odd_check($num){
 (Is this statement true) ? yes  :  no;
}
?>

Back to our case example: since the statement checks for an even number, when the statement is true we return the value “false” to indicate it isn’t an odd number.

Further Optimization of The Odd Number-Finding Function

Want to really impress the ladies? Try showing them the following function to find odd and even numbers.

<?php

function is_odd( $num)
{
  return( $num & 1 );
}
########################

if (is_odd(7)) {
    echo "7 is odd";
} else {
    echo "7 is even";
}
?>

This time around we took the equation out. We can do this through using the AND operator (&). If you aren’t up to speed on binary, consult the chart below to see how we count to five. (Note that we will not go into depth on binary, just give you enough information to understand the AND process.)

Each place in the above numbers represents a different value. The furthest right number, as you might have guessed represents “1,” the next “2,” the next “4,” and so on. But notice something even more interesting: all the odd numbers have a “1″ while the even numbers don’t!

The AND operator is going to compare two binary numbers. If both numbers have a “true” (the number 1) value, then the result is true. If either numbers have a 0 (or “false”), or both numbers are false, the resulting number is 0. Consult the diagram below for more information.

Back to our equation. If the ($int & 1) check returns true, the number is odd. Let’s say we put an odd number such as 3 in. We will compare it against 1, which is already an odd number. 0011 and 0001 can be used in an AND equation to get the result of 1, since both values are 1 (and thus true).

You don’t necessarily have to understand this jargon to make use of the function- but it’s good to get the basics of binary down if you haven’t already.

Closing Comments

Now that you can find odd and even numbers, you can accomplish all types of artsy things. You’ll see this in effect most often on blogs that alternate the background colors of comments to make for easy reading. Lyrics websites do the same thing, and you can even use the same principle to use in more complex equations (which we won’t get into in the scope of this article).

Try running the following code just for fun:

<?php

function is_odd($num)
{
  return( $num& 1 );
}

for ($counter = 0; $counter <= 20; $counter++) {
  if (is_odd($num)) {
    echo "<div style='background-color:black;width:800px;height:30px;margin:0px auto;'> </div>";
  } else {

    echo "<div style='background-color:red;width:800px;height:30px;margin:0px auto;'> </div>";
  }
}
?>

Comments may only viewed by those who make changes to the code itself- the PHP engine doesn’t parse anything designated as a comment. A good example of this is seen below, where the first line isn’t being output to the browser, while the second is.

An Example Of The PHP Comment Syntax

<?php

// This is an example of a comment- this is not being parsed!

echo "This is being parsed by the PHP engine!";

?>

We, as able-bodied programmers and individuals, should invest our time into commenting for three primary reasons.

1. Employment – If you are working for an employer, or are planning to release your source code to the public, you will need to make use of comments. Employers demand it because if they were to lose you as an employee, they would have to hire someone new to peruse your code. This act with commenting can take hours, and without can take days. This same principle works with open source code, which needs to be readable by others so they know how to operate or modify your program correctly.
2. Saving time – Even if you plan on keeping the code to yourself, you should make use of PHP comments because as your projects grow in scale, you will forget where you place certain bits of code or even what large blocks of code do. Most arrogant programmers do without comments at this stage, claiming they can remember the programs they make. In reality, a programmer will often come back to a certain code block months into the future, and quickly find they will need to take a few hours to reread their code and comment it properly.
3. Troubleshooting – More intelligently, programmers use PHP comments to troubleshoot their applications. When trying to find which code block is causing an error, programmers can quickly section out new additions to the application with a comment block to see if the error subsides. If it does, that’s where the error lies. If not, the error lies elsewhere.

PHP Commenting Syntax

You’ve finally come around, and you want to start commenting your code. Bravo! The first step is to learn how to use it. There are three different ways we can make comments; two of which can be seen below in the example.

Two different Methods of Using PHP Comments

<?php

#This is an example comment

//This is another example comment

echo "Sentence 1."; //This is our first statement

echo "<br />"; #This is a line break

echo "Sentence 2."; // This is our second statement

?>

You’ll notice that both commenting styles, either the “#” or the “//” versions, are used on a single line. Also note we can use both behind an otherwise functional PHP statement, such as can be seen with our second half of the example. But if we wanted to format comments to span multiple lines, things would get tedious. Luckily, PHP developers can make use of a third way that spans multiple lines as seen below.

Multi-Line Comments in PHP

<?php

#This is a

#single line comment

#on multiple lines.

/* This is an easier

way to write comments

on multiple lines */

?>

In the above PHP commenting example we see that you can span multiple lines both ways, but the latter example is much easier to work with. These types of multiple line comments are usually placed at the top of a PHP file to explain what it’s for, what it accomplishes, and any specific information needed to run or edit the file correctly.

Some people like to showoff and get elaborate with their commenting styles. We’ll agree it’s great fun, since it actually helps out the readability of comments in many cases. Below is an example of what the LearnPHPOnline.com’s creative programming department came up with in all but a few seconds of their precious time.

Fancy-Shmancy PHP Comments

<?php

#################################

####  My PHP File Version 2.2####

#################################

/* Be sure to edit the server 

password and username details 

to properly configure this 

script to work! */

?>

Quite chauvinistic aren’t they?

Using PHP Comments To Troubleshoot

Troubleshooting is a vital part of programming, as we are sure the reader knows already. It’s always a great idea to take breaks every time a new code block is added to see if everything is still functional. If it isn’t, we have to get creative in how we find the root of the problem.

Below is an actual flawed script that we created. You will likely see the problem right off, but in a real-world environment, tracking such a problem down will be much more difficult.

Troubleshooting PHP Code With Comments

<?php

//This script will output a variable to the browser

$myVar1 = " meow mix";

$myVar2 = " meow mix';

echo "I want chicken, I want liver," . $myVar1 . $myVar2 . " please deliver!";

?>

When run, this script will give the error “Parse error: syntax error, unexpected T_STRING” – and even though the problem lies on line 4, it points us to line 6. So we’ll just comment out line 6, and we see that the problem still persists!

Troubleshooting PHP Code With Comments

<?php

//This script will output a variable to the browser

$myVar1 = " meow mix";

$myVar2 = " meow mix';

#echo "I want chicken, I want liver," . $myVar1 . $myVar2 . " please deliver!";

?>

Oh dear, it looks like the problem is still there once we run the application.

Now we’ll move the comment to line 4, and see what happens. Once we run the application, we see that the browser outputs this string “I want chicken, I want liver, meow mix please deliver!” We are missing the second meow mix, obviously, but the script still executed successfully. This means that the problem must lie on or near line 4. Upon further checking, we see that we used an apostrophe to close the variable assignment! Oops! Let’s fix it and see if it runs now.

Troubleshooting PHP Code With Comments

<?php

//This script will output a variable to the browser

$myVar1 = " meow mix";

$myVar2 = " meow mix";

echo "I want chicken, I want liver," . $myVar1 . $myVar2 . " please deliver!";

?>

Success! We now have the correct string output to the browser.

One Last Tip For PHP Comments

One last thing we need to stress is to use PHP comments in selection structures, such as CASE or IF. If you have an IF statement, always be sure to comment what each branch does, even if you don’t use one of the choices. An example is below.

PHP Comments And Selection Structures

<?php

//This script showcases comments in an IF structure

$clientAge = 18;

if ($clientAge < 18) {

echo "You are not able to view this material until you are 18 or older.";

} else {

//Don't show a notice

}

?>

Even though we don’t need a comment in the else branch, we should put one there because it does amazing things for readability. Once programmers start nesting IF statements inside each other, documenting each IF branch is absolutely vital in understanding how an application functions.

Closing Comments

Commenting is a vital part of programming, and it serves more purposes than what one would think as we can very well see. Always try to keep documentation on your code where possible, if not for yourself, then for your employers who don’t like seeing undocumented work from their employees.

PHP Include Tutorial – Basics Of The Include Language Construct

It should be noted that, much like the Echo statement in PHP, Include is not considered an actual function. Although it would behave like a function, we call it a language construct since it is “built into” PHP. We consider it an integral part of the language much like the IF statement! (You may notice some language constructs listed as functions- but this is only to improve documentation.)

The primary usage of this language construct in particular is to retrieve a remote file for inclusion into the currently running script. We are going to use the Include construct for three primary reasons:

1. Readability – We use the Include construct for replacing many lines of code with but one line of code. This increases the readability of an application, and ultimately lets us troubleshoot bugs quicker than ever before. We use the Include construct for replacing many lines of code with but one line of code. This increases the readability of an application, and ultimately lets us troubleshoot bugs quicker than ever before.
2. Save Time – We save time by using the Include() construct in a very ingenious way. If we were to change a link in our navigation menu, we would have to update that same link hundreds of time on different subpages. But if we used an Include() construct, we could just edit one file and the results on other pages would be instant!
3. Reliability – If an included file doesn’t exist or has malfunctioned, the server will tell us quite promptly. This is superb for troubleshooting! Error reporting is sometimes seen as a security risk, however, since it commonly shows semi-confidential information in the error.

PHP Include Tutorial – Examples Of Including A File

Before we can do dabble with an example, we need to learn how the Include syntax works. Using the Include construct is actually quite easy; we just need to know the URL of the code to be input, wrap it in parenthesis, and add the include statement.

An Example Of The PHP Include Syntax

<?php
    include("header.php");
    include 'footer.php';

    // Each Way Is Correct, But The First Example Is More Readable
?>

In the above example we are calling to two different files, in which both are located in the same directory as the page being viewed. Both statements will work, but we personally like the first example since we view it as more readable.

If the file we wanted to include is in the parent directory, we simply use the “../” notation as seen below.

Including A PHP File From A Parent Directory

<?php
    include("../header.php");

    // Include A File From Parent Directory
?>

Note that every time we use the “../” notation we go up one level. But things don’t have to get complicated! We can simplify things by simply using the entire URL as seen below:

An Easier Way To Include A PHP File

<?php
    include("http://www.YourUrl.com/includes/header.php");

    // Easy File Inclusion
?>

PHP Include Tutorial – An Include Example

To get started we are going to need at least two files. First, we will take an already-made index.php file as seen below:

Contents Of index.php – Copy And Paste

<html>
<title>A Basic PHP Website Using Include</title>

<p style="text-align: center;padding: 10px;">
<a href="#">Home</a>
<a href="#">Subpage 1</a>
<a href="#">Subpage 2</a>
</p>

<p style="text-align: center;border: 1px dotted blue;">Welcome to our website! The links above are being used in includes- saving us time that can be best used for developing better features for this website.</p>

</body>
</html>

	

Now create a file called “header.php” in another window. We are going to take out some of the contents of the index.php file and replace it with our include statement. Our header.php file should look like the following:

Contents Of header.php – Copy And Paste

<?php
	<a href="#">Home</a>
	<a href="#">Subpage 1</a>
	<a href="#">Subpage 2</a>
?>

Now we have two separate files. But we have a problem- how do we get the URLs from the header.php file into the index.php file? Simple! Review the code below to see where we put the include statement:

Contents Of header.php – Copy And Paste

<html>
<title>A Basic PHP Website Using Include</title>
<body>

<p style="text-align: center;padding: 10px;">
include("header.php"); ?>
</p>

<p style="text-align: center;border: 1px dotted blue;">
Welcome to our website! The links above are being used in includes- saving us time that can be best used for developing better features for this website.
</p>

</body>
</html>

Now upload both files to a same directory and test it out! If you’d like, you can change around the contents of the header.php file, upload it to your web server, and see the changes in real-time. This may not seem like a big time saver with only one page to use it on, but if we were to have a website filled with 100 pages, this would be quite the little time saver!

PHP Include Tutorial: Dealing With Variable Scope

Variable scope sounds like a mean phrase to anyone who doesn’t know what it is. The scope of a variable is just how far it “reaches”- or basically where it can and can’t be accessed. Variable scope can be seen when looking at two separate PHP scripts. If they are not connected in any way, then the variables of the first script will not interfere with variables in the second. (And vice versa)

We deal with scope in the Include construct quite simply because we are merging two files- so if we are using the same variable name in both scripts, which one gets precedence?

In our previous example we are not dealing with scope since we aren’t using any variables. But we can change that with the following edits to both index.php and header.php:

header.php – Edits To Show Variable Scope

<?php
  $home = "<a href='#'>Home<a>";
  $sub1 = "<a href='#'>Subpage 1<a>";
  $sub2 = "<a href='#'>Subpage 2<a>";
?>

We just declared our three variables as our links, so that we may see which variables take precedence in our index.php file. Our index.php file should be updated as seen below:

Contents Of index.php

<html>
<title>A Basic PHP Website Using Include</title>
<body>

<p style="text-align: center;padding: 10px;">
<?php 

$home = "";
$sub1 = "";
$sub2 = "";
include("header.php"); 

echo "$home $sub1 $sub2";
?>
</p>

<p style="text-align: center;border: 1px dotted blue;">Welcome to our website! The links above are being used in includes- saving us time that can be best used for developing better features for this website.</p>

</body>
</html>

So what do you think the script will output to the browser? As you can see, we declared each variable as an empty string before we included the file. But in the include of the file, we stated that the variables should contain links.

Upon testing this script, one can see that the output is going to be successful in displaying the correct navigation links. From this example it is seen that an included file will indeed overwrite variable values unless otherwise coded.

It should also be made clear that an include file is only going to have access to variables and functions that have been declared before the line used to include the file. In the following example we will declare a variable and reference it within the include file. (No need to test this out unless you want- you can easily see the results with the two short snippets below)

index.php – Testing Variable Scope

<?php
  $hello = "hello world!";
  include("echo.php");
?>

Now for the echo.php file:

echo.php – Testing Variable Scope

<?php
  echo  $hello;
?>

Once this script is run, we will see that “hello world!” is output to the screen. If we were to put the variable after the include line, we wouldn’t get any results at all.

PHP Include Tutorial – Two Major Security Concerns

PHP is considered a generally secure language since it hides the contents of the PHP code from the user. (Go ahead and view the source of the HTML of pages we have created- you won’t see PHP code!) If we take this protection away, anyone can see the contents of our scripts. Luckily you have to make the mistake of not using the PHP extension for this to happen.

It is sometimes common to see some use plain text or even a .INC file type for their includes. If you use the wrong extension or remove the PHP tags from the header.php file we were working with, you’ll notice that the plain text is output to the screen if you try to access header.php directly. This goes to show that when we use includes, always remember to use the PHP tags to enclose the data if it is using any type of sensitive data. (Or any time at all, since it builds good programming practice!)

The second major security concern is including files from a remote location. If we are only using local resources on our website, such as template files we have created, there is no reason to fret. But if we are pulling information from other websites, which is sometimes illegal in many cases anyway, the remote website can inject code into our websites and get confidential information with ease. As such, developers should only agree to use includes from remote resources if they are to be trusted without doubt.

Closing Comments

As we get more familiar with the Include statement, we can get a little more skilled in the way we use it. From using Includes in functions or even using IF statements to selectively include correct files, there is much to expand on here.

PHP Echo Vs Print: Which Should Developers Use?

The biggest triviality that plagues most newcomers to PHP is the fact that there are two commands that do (what appears to be) the exact same thing. Print and Echo both output data to the screen in a similar fashion- so why have two different commands for the same thing?

PHP Echo Vs Print Diagram

<?php
     print "Hello World! <br />";
     echo "Hello World! <br />";
     // The above outputs the text "Hello World!" on two separate lines.
     // Notice they are identical in output!

     print ("Hello World! <br />");
     echo ("Hello World! <br />");
     // The above are just the same, with parenthesis.
     // Notice both can act like functions, but note they actually aren't.
?>

In all actuality, Echo and Print differ based on how they are structured. Print returns a value much like a normal function would. But despite common belief, Print is not a function, as we can see by the fact that it doesn’t require parenthesis to work (Not to be confused with Printf). Print and Echo are actually both called language constructs, although this isn’t to say that we can’t make Print act like a function.

PHP Echo Vs Print: Which Is Faster?

Developers need to ask the all-important question; “Why on Earth would I ever need to return a value from a string of data?” This is a good question, and the easy answer is you probably will never need to. The fact remains to some that returning a value degrades system performance- but is it enough to worry over?

By looping a large block of text multiple times, we can measure how long the two language constructs take to print out data. In an exclusive LearnPHPOnline.com test, we found that through an extended amount of iterations through a loop, Echo did indeed turn out to be the winner in speed! Whereas it took around 550ms for Print, the complete iteration took around 450ms for Echo. (For those without a calculator or a quick noggin, that’s almost 20% difference.)

Percent Of A Full Second (1,000ms)

Of course results depend on certain conditions, and the fact that we had to iterate the blocks of texts to an unimaginable amount of times to see a result shows that the difference really is marginal. It’s actually mentioned through a supporting page on the PHP.net homepage that developers should pick what suits them best- performance isn’t a real issue.

As a last note on speed, it’s recommended that developers add strings together via parameters- not through concatenation or multiple Echo calls. Instead of using new Echo commands to help organize code, separate them with commas (Make certain you aren’t using concatenation- this actually slows the process)! Calling the Echo or Print command multiple times will also degrade the performance of the script, although marginally, as seen below:

A Special Note On Concatenation Vs Parameters

<?php
     echo "Hello" . "World! <br />";
// Concatenation slows down the process because PHP must add strings together

     echo "Hello" , "<br />";
     echo "World" , "<br />";
// Calling Echo multiple times still isn't as good as using Echo parameters solely

     echo "Hello" , "World!" , "<br />";
// Correct! In a large loop, this could save a couple of seconds in the long run!
?>

PHP Echo Vs Print: The Conclusion

So what do we use? Echo of course! But not because of speed, and certainly not because we have anything against pseudo-functions that are disguised as language constructs. So why do most PHP developers go for echo, when the benefits are very marginal?

Easy! It sounds cool! Not to mention the fact that the word Echo has one less letter in it that Print- and that’s saving our left pointing finger from having to press the “T” key each time we want to use the language construct in question.

It’s human nature to be lazy (Or have a certain appreciation for cool-sounding words), and that’s exactly the reason why you’ll see the majority of PHP developers use Echo over Print. The speed benefit is just icing on the cake.

Closing Comments

All jokes aside, it really makes no difference as to which command is used. We find that although most developers will use Echo, some of the older programmers use Print because it reminds them of their earlier programming years (Back when print was a command in early programming languages, where new language constructs weren’t stealing their glory).

Bottom line: It’s up to your tastes, and whether or not you like pressing the “T” key for nostalgic value.