PHP Starter » Beginner

Making Google Static Maps a Little More Dynamic with PHP

Andrew — Wed, 17 Mar 2010 14:00:24 +0000

If you have messed with the Google Maps API, you know that the JavaScript and API keys can be a real headache. Yes, there are very complex implementations that you can use, but what if you want…just a map? If you want just a map with no dynamic interface, Google Static Maps is just for you. I will show how easy it is to use, and then spice it up with some PHP-powered enhancements.

Check out how easy this is. If I want a map centered at a my zip code, I can create a JPEG image for that area with this link:

http://maps.google.com/maps/api/staticmap?sensor=false&center=46311&zoom=14&size=600x400

And it generates this:

No API keys, no JavaScript, and the URL is even short enough to not have to wrap on the page. As long as you don’t need the typical panning and zooming features, this is the best option. There are a limited but practical set of features including map types (satellite, hybrid, regular, etc), markers, lines, shapes, custom icons, and all in different image formats. View the Google Static Maps API page for the full details.

Making it a Little More Dynamic

This is a site on PHP. I can’t show you how to create static maps and leave it at that. There are several good reasons why we might want to dynamically generate that URL.

Simple “You Are Here” Map

For starters, how about a map that shows your local area based on your IP address geolocation? This sample below uses the code from a previous article that showed how to determine the geographic location from any IP address.

Run This Example

Static Map for Your Location

Static map for your town:

If you are placed in the middle of an ocean, your IP address is probably not in the database. The blue marker is your specific IP location (probably not exact).

&markers=color:blue|,&zoom=13&size=600x400" />

Details from IP GeoLocation:

Show Your Position With Other Objects

We already know how to find a list of the closest items in our area from this post: Locate the Nearest Radar Station and Display Radar Images. Now, let’s apply it to generating a Static Google Map. This uses the “Implicit Positioning” feature where you can just list a bunch of points, and the map will automatically create a zoom level and center based on the created points.

Run This Example

Static Map for Your Location

5 Closest Radar Sites to You

Red marker is you.

&markers=color:red|,&size=600x400" />

Details from IP GeoLocation:

Radar Sites:

These examples are meant to get your creative juices flowing. Have some other cool concepts for Google Static Maps? Post them below.

No related posts.

Separating the Application & Presentation and Alternative Syntax

Andrew — Wed, 18 Mar 2009 16:31:47 +0000

One of the biggest pet peeves I have when looking at (and unfortunately – working with) other people’s PHP code is the way they integrate their code into the HTML. Many people don’t take the time to organize, and they end up with a PHP & HTML mess. I believe that it is critical to separate the application logic from the presentation. In other words – do the bulk of the application operations in a script file that has no text/HTML output. When that processing is done, send the data to the presentation file that takes the data and outputs that along with the static HTML for that page. In this article, I will present an easy way to do it using no template engines.

I have some perfect textbook examples that I would love to post of very badly-formatted code, but because of privacy and confidentially reasons with my clients, I can’t do that. You will just have to take my word for it – I have seen some major hackjobs thrown together by the most obvious of n00bs I didn’t even know existed.

So the main thing to remember is this: Think of your web application as having two layers – application & presentation. The only job for the presentation layer is to format the data into the HTML and send it to the browser. Everything else falls to the application layer.

Bad Example

I decided to write a script that would utilize a database table in my sample database. This example uses data from the article on how to Locate the Nearest Radar Station and Display Radar Images. This script will take your IP’s location, and show the 10 closest radar stations to that location – but displaying the results in way that should make you cringe.

Run This Example




IP Geolocation Example







Details on IP Location:';
echo 'Location ID: ' . $location['locId'] . "
\n";
echo 'Country: ' . $location['country'] . "
\n";
echo 'Region: ' . $location['region'] . "
\n";
echo 'City: ' . $location['city'] . "
\n";
echo 'Postal Code: ' . $location['postalCode'] . "
\n";
echo 'Latitude: ' . $location['latitude'] . "
\n";
echo 'Longitude: ' . $location['longitude'] . "
\n";
echo 'Metro Code: ' . $location['metroCode'] . "
\n";
echo 'Area Code: ' . $location['areaCode'] . "
\n";

/* offset the coordinates by 3, and find the closest station */
$lat = $location['latitude'] + 3;
$lon = $location['longitude'] - 3;
$query = "SELECT *, SQRT(POW(69.1 * (lat - $lat), 2) + 
			POW(69.1 * ($lon - lon) * COS(lat / 57.3 ), 2 )) AS distance 
			FROM RadarSites ORDER BY distance ASC LIMIT 10";
$result = mysql_query($query, $db) or die(mysql_error());

echo'Radar Site Details';
echo '';
echo '';
echo '';
echo '';
echo '';
echo '';
echo '';
for ($i = 0, $n = mysql_num_rows($result); $i < $n; $i++)
{
	$radar = mysql_fetch_assoc($result);
	echo '';
	echo '';
	echo '';
	echo '';
	echo '';
	echo '';
	echo '';
}
echo 'Station ID Lat Lon Updated Distance
' . $radar['id'] . ' ' . $radar['lat'] . ' ' . $radar['lon'] . ' ' . $radar['updated'] . ' ' . $radar['distance'] . '';
?>

Station ID	Lat	Lon	Updated	Distance
' . $radar['id'] . '	' . $radar['lat'] . '	' . $radar['lon'] . '	' . $radar['updated'] . '	' . $radar['distance'] . '

This isn’t a worst cast scenario – I’ve seen worse, but I would like to point out the PHP code block in the middle of the header and footer HTML. Notice all the application work I’m doing in lines 13-67 that is right in the middle of the HTML output. Looking further, you can see that I am using echo statements to output the table HTML and other code. This is bad. It makes it hard to change the HTML without messing with the PHP, and it makes it next to impossible for a designer to work with it.

Good Example

Here is a better example with most of the logic separated from the HTML.

Run This Example





IP Geolocation Example








Details on IP Location:
Location ID: 

Country: 

Region: 

City: 

Postal Code: 

Latitude: 

Longitude: 

Metro Code: 

Area Code: 


Radar Site Details


	Station ID
	Lat
	Lon
	Updated
	Distance

In lines 46-54, I am using PHP shorthand tags to output PHP variables in a cleaner way. The other thing you will notice is that there is no getting around the loop structure that is needed to output the 10 radar sites. We can do it without the curly braces though, and with neater “tags” in the HTML to control the loop.

Another thing to mention – I would even have the PHP block in a different file, but I combined them for the simplicity of the example.

PHP Shorthand Tags and Alternative Syntax

Since the presentation files are to be more focused on the HTML, and won’t be very PHP-intense, we can use simplified tags. To output PHP variables in HTML without the PHP opening/closing tags, we use the shorthand method:

If we need to have a control structure, such as an if statement or loop, we do it this way:

Some content here

Here is a loop example:

Some content here with the current index of

So there you have it – a few tips for you to create more readable code. I have read that doing it this way with several PHP opening/closing tags can hurt performance by a hair, but I prefer losing a few CPU cycles over several hours debugging later down the road. The choice is yours.

Making Google Static Maps a Little More Dynamic with PHP

Basic PHP/MySQL Actions

Kurtis — Tue, 17 Feb 2009 06:00:22 +0000

Using databases to store user identification, image information, and so much more for dynamic websites is the easiest way to ease maintenance. MySQL is the most popular choice of database, and in this article, I’ll explain the most basic functions: connecting and using a MySQL database and its respective tables.The first step in using a MySQL database is to make sure your host has the necessities set up. Typically, your web host’s control panel will allow the creation of a database/user pair which will allow you to connect. However, most do not allow the creation of these directly through a PHP script. Check with your host to see how you can get your MySQL database running.

The next step, and probably the first in your running script is connecting to the user and database, using the following two functions:

Again, your host will work with you with respect to establishing the user, password, and database, and host is typically “localhost” when accessing the database on the same server as your website, but check with your host if you are having problems. The link, which is optional, would refer to the variable holding your mysql_connect() reference.

Now you have a database ready to go, but without a table, there’s no place for your streams of data to go, so let’s set one up. Most of our queries to MySQL are going to be run through the appropriately named mysql_query() function, and the text within will change with each different application. To create a table, we run a query like this:

You should take the time before creating a table to decide what all needs to be stored and what would be the best manner to do so, and then use one of the column types and attributes name at this resource. Some may seem confusing, but there are plenty of elaborations and tutorials available to describe the uses of each type. The mysql_close() function simply closes our the defined connection and is typically unnecessary as the connection will be closed at the end of the script anyway.

With a table available for queries, we can begin adding and working with our data. The main abilities available with the mysql_query() function our SELECT, SHOW, DESCRIBE, EXPLAIN, INSERT, UPDATE, DELETE, and DROP. The first four return a resource (explained in detail in a minute) and the latter four return a boolean value depending on the success.

SHOW, DESCRIBE, and EXPLAIN are honestly rarely used within the context of a functioning, user-run website. They are moreso used on the administrator’s end and even then are not as functional as the others. DELETE and DROP should certainly only be used on the administrator’s end and probably, again, only through MySQL itself and not through a publicly-available executable file. Only through proper authentication should someone be able to delete a record or even an entire MySQL table.

Let’s start with INSERT, as that is where you must start to use the other functions. To insert data into a table, run the function like this:

The column names in the first set of parentheses should correspond with the correct value in the second set. You may also opt, with each execution of mysql_query() to use the mysql_error() function to report an error should one occur, though hopefully you’ve worked your script well and an error is handled by your own error-checking. However, some things do slip by and happen unpreventably.

Next is the SELECT application. Just as it sounds, you select records from an identified table and can then use the data however you wish, by displaying it, checking it against variables, etc. Either way, a SELECT application looks like this:

The * can be replaced with each column you wish to extract, separated by commas, and the WHERE clause is in the query is optional but should be used when looking for particular records. You should note that SELECT returns a resource, so we have to loop through that resource using the mysql_fetch_array(), mysql_fetch_assoc(), mysql_fetch_row() or an appropriate alternative. Then the data from the records is stored in an array where each column is referenced by its respective name.

To delete a record (or records) use a similar construct to the SELECT application, but no looping or variable-calling is necessary. It simply works through the query:

To delete an entire table, use the DROP application, though realize that every record will be obliterated:

Lastly, editing records is fairly easy though it can be more cumbersome. Using the UPDATE application like so can allow for the altering of preexisting rows.

You can change as many columns as you need, separating each with a comma, but be careful with spacing because the success of the update can depend highly on the spacing as I have seen in the past, though I can’t find a good reference on what the exact spacing should look like.

With these basic applications in tow, little cannot be accomplished with your MySQL database. With a dynamic, user-driven website these will certainly be integrated into your website. To keep a more watchful eye on your database and perform certain one-time actions on your tables, you may also choose to employ a GUI like PHPMyAdmin or something similar which your host may already have available through the control panel.

Happy querying!

No related posts.

Explosive PHP Application

Kurtis — Tue, 10 Feb 2009 06:00:18 +0000

Sometimes a complex PHP-built website can become tedious when dealing with minor changes to the template and HTML markup. Changing, for instance, a set of links (navigation) or other integral parts of a website, can become quite the lengthy process. In this article, I’ll share a technique that I sometimes use to make something as simple as a website navigation a little more automated using an explosive function.So maybe you’ve caught on to the references to explosions and are thinking that something’s about to get dangerous, and really, this application is quite safe and easy to use. The function itself is properly named “explode”:

Now you may be thinking: that’s all well in good but what in the world is a delimiter? I thought the same way before I truly understood the function. The delimiter is just the common separator between each element. For instance, if we wanted to explode a sentence into an array with each element as a separate word from the string, the delimiter would be an empty space (” “). The optional “limit” is a limit of the number of elements to allow to be created. If it is left empty or set to “-1,” no limit will be set. Otherwise, once the limit is reached, the last element will be the rest of the unexploded string.

Now this is all good and well unless you have an awesome application of the function, and believe me, there are many, but my favorite is the dynamic navigation idea. I always get sick of having to add in all the extra template elements when altering a website’s navigation, and with this simple idea that can cease.

Here’s a basic run-down of what will happen: first, we’ll define a string holding all the link names and source locations. Then, we’ll explode that string to an array of all link name-source pairs which we will in turn explode individually to produce a great link. Here’s an example:


";

foreach ($links as $link) {

$link = explode(":",$link);

echo "".$link[0]."";

}

echo "";

?>

Be aware of the order in which we are exploding the elements. If you explode incorrectly, you could end up with inaccurate pairs. With this application, to update the navigation, instead of sifting through what could become complex HTML, you simply need to edit the “links” variable and let the PHP take care of business for you. Nothing complex, but certainly useful.

No related posts.

Understanding Decision Structures

Kurtis — Thu, 22 Jan 2009 06:00:53 +0000

Decision structures form the basis of all programming languages; just as they sound, these constructs move the program down a certain path depending on variables which are checked. This gives a program functionality and the ability to handle different input and analyze the data within the script.
Though the term sounds complex, decision structures just help the script make a decision. If something is true/false, do this. If not, do this. All decision structures come down to a true or false situation, and usually a comparison is made that results in one of the two choices. There are several comparison operators, and it takes a basic understanding of logic to fully utilize decision structures.

The comparision operators are:

==	($a == $b)	Returns true if $a equals $b
===	($a === $b)	Returns true if $a equals $b and is of the same type (int, string, etc)
!=	($a != $b)	Returns true if $a does not equal $b
!==	($a !== $b)	Returns true if $a does not equal $b or is not of the same type
<	($a < $b)	Returns true if $a is less than $b
>	($a > $b)	Returns true if $a is greater than $b
<=	($a <= $b)	Returns true if $a is less than or equal to $b
>=	($a >= $b)	Returns true if $a is greater than or equal to $b

Logical operators are a bit different but are also used in decision structures. There are five different logical operators, but for the sake of this article, in truth three are the most important.

&& , and	($a && $b)	Returns true if A and B are both be true
\|\| , or	($a \|\| $b)	Returns true if A or B (or both) is (are) true
xor	($a xor $b)	Returns true if A or B is true and the other is false

For more information on the reason behind two variations of “and” and “or” operators, check out the manual on operator precedence.

Now let’s get on to the decision-making part of programming with PHP. There are two main ways to do this, and we will start with the if-else statements.

Basically, this comprises the main idea of decision making. It handles like this: “If THIS is true, do something. Otherwise (else), do something else.” Using the operators defined above, you can make a basic script:

if ($a == $b) {
echo "The variables are equal.";
}
else {
echo "The variables are unequal.";
}
?>

This would be great if there were always just two choices, but sometimes there are several choices between these two. Think about a school grading scale. The following would assign a grade based on a ten-point scale. Since there are more than two possibilities, we will add some elseif statements inbetween.


= 90) {
$letter-grade = "A";
}
elseif ($grade > 80) {
$letter-grade = "B";
}
elseif ($grade > 70) {
$letter-grade = "C";
}
elseif ($grade > 60) {
$letter-grade = "D";
}
else {
$letter-grade = "F";
}
?>

Notice that we work downward to make sure the grade only fits in one category. It’s important to think about your script logically before setting out to write it. Now, the type of structure described above will handle any situation, but in truth it isn’t always the best choice. Suppose you wanted to create a script that would change a certain heading based on the date, if it is a holiday or not. While an if-else/elseif structure would work, there is an alternative, the “switch” construct which focuses on just one variable rather than comparison between two or more.

Obviously, hundreds of other holidays can be added in as a different “case,” but the idea is captured with this short script. The “default” case acts as an “else” in this structure, catching anything that did not match any case.

With these two ideas, it is easy to build fairly impressive scripts with PHP, and you will even find that the idea carries over to most different programming languages with tiny changes in syntax and operators. Combined with more complex variables handled by user input and organized sessions, you will see that decision structures are truly the core of a programming language.

No related posts.

Encrypting Password & Other Sensitive Information

Andrew — Tue, 13 Jan 2009 12:00:00 +0000

Encrypting sensitive data is extremely important. You, as the webmaster or database administrator, needs to make sure that the data is safe, even if it falls in the wrong hands. In this article, I will show you how to use MD5 and SHA1 encryption in PHP.

Salting your Passwords

Examples in this article will be with salted passwords. Salting the password lessons the risk of dictionary attacks. For example, if I were to use a password of ‘password’. That hash is common and very susceptible to a dictionary attack. However, if the application salted all passwords with a random string like ‘as87f56safg8′, then the resulting stored password would be the encrypted version of ‘as87f56safg8password’, which is not susceptible to a dictionary attack, regardless of how weak of a password provided by the end-user.

MD5 Encryption

Using PHP’s md5() function allows you to easily create a password hash.

Here is the recommended way to encrypt a password:

Since this is a one-way hash, you can’t decode it to compare to verify with a user-supplied password. Instead, take the user-supplied password, encrypt it with the same md5() function & salt, and compare it to the hash stored in your database. If the hashes match, then the supplied password is correct.

SHA1 Encryption

This is very similar to md5(), except using another algorithm.

There is an alternative PHP function, crypt(), but I find these other two functions easier to use.

No related posts.

Handling File Uploads

Kurtis — Thu, 08 Jan 2009 06:00:43 +0000

There are very few websites in existence that do not allow, for whatever function, uploading files via the browser. Whether for forum avatars, a gallery script, or even a school project, websites across the World Wide Web employ a myriad of upload scripts, including the ever-popular MySpace, Facebook, and YouTube. With this script and step-by-step explanation, your website can now allow users to add their own files.

An upload script can seem like a daunting task, a process of several steps and error-handling, and in truth, there is a lot to take into account, but the uploading step itself is very simple. Before we even begin with the form, I suggest (for those not too afraid) checking some settings in your php.ini file, typically located in your PHP root folder. This step isn’t necessary, so feel free to move on now. Find the following lines and check the settings as explained below:

file_uploads: Be sure this is set to On or your uploads will fail every time
upload_max_filesize: Must be at least the maximum file size you wish to allow for uploads
post_max_size: Represents the total amount of data allowed to be passed from a form, including file uploads, so I recommend setting this higher than the upload_max_filesize

For most typical PHP setups, the settings should work as they are, but for more advanced users I always recommend learning exactly what that php.ini file does with respect to certain PHP applications. With those settings taken care of, let’s move on to setting up the basic HTML form. For the purpose of this example, I’ll use the most basic markup possible.

Three things to keep in mind are the following specifications:

enctype=”multipart/form-data”: This attribute must be set as shown or the form will not process properly. This is different from most basic PHP forms.
: Specifies the maximum file size, in bytes, allowed to be uploaded. You can omit this line if you specify a maximum in your php.ini file (as described earlier).

: Notice we are using the “file” type here, again, mandatory for file uploads. This line will provide the input field with the “Browse” button.

Certainly, the HTML form is the easiest part, so let’s move on to actually handling the file and moving it to its final destination through the PHP processing file. Above we designated that as “upload.php.”

First of all, we’ll set two variables, arrays actually, which will be very handy a little later on in the script: the possible PHP error messages and the allowed file extensions.

"The file exceeds the maximum file size specification.", 2 => "The file exceeds the maximum file size specification.", 3 => "The file was not fully uploaded.", 4 => "The file was not properly uploaded.", 6 => "An error occurred during uploading.", 7 => "An error occurred during uploading.", 8 => "An error occurred during uploading."); $allowedExtensions = array("jpeg","jpg","gif","png"); ?>

I suggest leaving the error messages as they are (despite the odd numbering), but feel free to edit the allowed extensions to suit your needs. As we move through the script, the error messages will be further explained.

The next step in my upload script is to create two functions with very specific, well, functions. The first will be used when the upload fails:

function uploadFail($error) { header("refresh: 3; url=index.php"); echo "
".$error." You are now being returned to the upload form.
"; }

This will return the user to the upload form just after displaying the error message which is passed to the function. The next function will obtain the file’s extension:

function getExtension($file) { $file = explode(".",$file); return strtolower($file[count($file)-1]); }

Certainly there are several methods for obtaining the file’s extension, but this is the shortest one I could put together. Our last stop before starting the handling is one more array which is completely optional. I use it to ease the process of getting the file’s attributes:

$file = array("tmp" => $_FILES['file']['tmp_name'], "name" => $_FILES['file']['name'], "type" => $_FILES['file']['type'], "size" => $_FILES['file']['size'], "error" => $_FILES['file']['error']); $file['ext'] = getExtension($file['name']);

This will remove the need for such long lines each time an attribute is needed, though this step is not necessary. Note that we used our extension-finding function to do just that, and also be aware that the file type (MIME type) is available if you wish to check the type that way.

Finally, we’re here! We are ready to begin handling the file and checking for errors. First we’ll make sure the page is accessed through the form by making sure the ‘submit’ button was pressed:

if (!isset($_POST['submit'])) { uploadFail("You may only access this page through the form."); }

Next, we’ll check for those PHP errors we specified earlier. If the variable is set to ’0,’ that means there is no error. Otherwise, let’s reference the array we set earlier and return to the form. Note that the inherent PHP error returns an integer based on the error encountered. Our descriptions match pretty well what the problem is, but you can read more extensive descriptions in the manual.

else { if ($file['error'] != 0) { uploadFail($errors[$file['error']]); }

The last step in checking the file is to reference it against the extensions we listed earlier, so let’s do that now:

else { if (!in_array($file['ext'],$allowedExtensions)) { uploadFail("Uploaded file (".$file['name'].") is of a disallowed type."); }

If the file makes it this far, that means everything checks out and we just have two steps left: setting the final file name and moving it to the ‘files’ folder.

else { //Now the file is fine; let's finish the upload //Make sure file name is not already in use while (file_exists("files/".$file['name'])) { $file['name'] = time()."-".$file['name']; } //Finally move the file to the proper place if(move_uploaded_file($file['tmp'],"files/".$file['name'])) { header("Location: success.php"); }

Notice we use the file_exists() function to make sure a file of the same name isn’t already located in the folder, and if so, we rename it something sure to be more unique. Then, we use the move_uploaded_file() function to move the temporary file to its final resting place, and we take the user to the ‘success’ page where they are greeted with much love and praise for finishing the entire process. You can create a custom file however you wish and reference it in your ‘upload’ file.

All together, the ‘upload’ file can seem complicated, but it isn’t too tough. By establishing easy-to-use functions and variables early in the process, we were able to simplify the task and break it down into manageable parts. The finished script looks like this:

"The file exceeds the maximum file size specification.", 2 => "The file exceeds the maximum file size specification.", 3 => "The file was not fully uploaded.", 4 => "The file was not properly uploaded.", 6 => "An error occurred during uploading.", 7 => "An error occurred during uploading.", 8 => "An error occurred during uploading."); $allowedExtensions = array("jpeg","jpg","png","gif","txt"); //This function will return the user to the form, displaying the proper error message function uploadFail($error) { header("refresh: 3; url=index.php"); echo "
".$error." You are now being returned to the upload form.
"; } //This function will get the file's extension function getExtension($file) { $file = explode(".",$file); return strtolower($file[count($file)-1]); } //The following array will hold all of our file information $file = array("tmp" => $_FILES['file']['tmp_name'], "name" => $_FILES['file']['name'], "type" => $_FILES['file']['type'], "size" => $_FILES['file']['size'], "error" => $_FILES['file']['error']); $file['ext'] = getExtension($file['name']); //Processing begins here //Make sure the page is accessed through the form if (!isset($_POST['submit'])) { uploadFail("You may only access this page through the form."); } else { if ($file['error'] != 0) { uploadFail($errors[$file['error']]); } //Check for PHP errors else { //Check file extension if (!in_array($file['ext'],$allowedExtensions)) { uploadFail("Uploaded file (".$file['name'].") is of a disallowed type."); } else { //Now the file is fine; let's finish the upload //Make sure file name is not already in use while (file_exists("files/".$file['name'])) { $file['name'] = time()."-".$file['name']; } //Finally move the file to the proper place if(move_uploaded_file($file['tmp'],"files/".$file['name'])) { header("Location: success.php"); } else { uploadFail($errors[6]); } } } } ?>

Now you’re ready to make your website even more dynamic! By allowing file uploads, your visitors have the chance to add their own unique contribution to a website they’ll enjoy even more!

No related posts.

Sending Data Between Pages

Andrew — Thu, 04 Dec 2008 14:00:48 +0000

When a visitor navigates through a website, the server doesn’t know who you are from one page to the next. In other words, if you read this page, and then click on another article or link, the server can’t remember who you are! It is up to the developer to retain any data between page requests, and we will cover the best ways to do it in this article.

Retaining Data With PHP Sessions

PHP has a built-in sessions feature that makes it the easiest to retain data from one page to the next. As I said before, the server doesn’t know who you are from one page request to the next…unless you remind it every time. That’s what PHP Sessions does. When you start a session, PHP sends the session id to the client’s browser in the form of a cookie. Then the browser sends this cookie back to the server on every page request. In order to start or maintain a session, we only need this statement:

All you have to do is put that one line of code at the top of your pages to hold a session on your website. This single line of code will start a new session or maintain the current one, depending if the site visitor has an active session or not. If you don’t put this line of code at the very top, you may see this warning:

Warning: session_start() [function.session-start]: Cannot send session cookie - headers already sent by (output started at /home/user/php/test.php:3) in /home/user/php/test.php on line 4

Warning: session_start() [function.session-start]: Cannot send session cache limiter - headers already sent (output started at /home/user/php/test.php:3) in /home/user/php/test.php on line 4

If you get any of these warnings, make sure that you aren’t sending any output before you run the session_start() statement.

Now that your session is active, storing and manging the data is just as easy. All the data is stored in a single global array: $_SESSION. Everything that is stored in there will be retained as long as the session is active.

When you are ready to destroy a session, like when a user logs out, simply run session_destroy(). There are many other items to know about sessions, like what to do if the visitor’s browser doesn’t accept cookies. All that and more can be answered by visiting this page in the PHP manual.

Sending Data in the URL

Sending data in the URL is probably the easiest way to send data from one page to the other. Take this example URL: http://www.example.com?variable=value&second=something. The bolded text is the “query string”. The question mark separates the query string from the URL, and each variable/value pair is separated by an ampersand (&). These variables become part of the $_GET array, so in our example URL, $_GET['variable'] equals ‘value’, and $_GET['second'] equals ‘something’.

More information on $_GET can be found here.

Sending Data via a Form

This method is for sending data that can’t be sent directly in the URL. This could be because it’s sensitive data, or maybe because you want your URLs to be clean. You need to build an HTML form first to send the data.

Similar to the $_GET array, all data will go into a $_POST array. So if our example was submitted, $_POST['foo'] would equal ‘bar’, and $_POST['test_field'] would equal whatever was typed in the text field.

More information on $_POST can be found here.

Have something to say or a question to ask? Post a comment. Please also use the contact form if there is an article you would like to see.

No related posts.

Understanding PHP Tags & Code Blocks

Andrew — Sun, 30 Nov 2008 02:25:04 +0000

PHP was originally designed as a tool to make a website’s HTML more dynamic, so it’s no wonder that it mixes well with existing HTML in your website. There are several options for defining your PHP blocks, and we will cover them all here.

Most Common Tag and How It’s Used

In a previous PHP article, I had a sample script. Here it is again:

This is the most common PHP tag, and the most supported. Generally, this will be the only tag you need to worry about. Here would be another example in the context of a typical HTML page:

Sample PHP Script w/ HTML

PHP only parses the code in the PHP tags, so the other HTML is left alone, and we result in an HTML page like this:

Sample PHP Script w/ HTML It works!

Variables with Multiple Blocks & Short Tags

PHP function and variable declarations do stay intact between blocks of code, so this example would output ‘Hello, Andrew!’.

Hello, !

This can get pretty confusing with several blocks of PHP mixed in with HTML. To help keep code neater, there is a shorthand way to output variables in HTML:

Hello, !

In the above example, the code to output the username is quite condensed using “short tags”. Although this method is convenient, it is generally not recommended if you plan to redistribute your code to other servers, as some might have this option disabled.

ASP-Style Tags

I don’t know why PHP provides this as an option. I strongly discourage its use and I have it disabled on all of my servers. Nevertheless, it’s a working option for you to use.

<% /* output our intro message */ echo 'It works!'; %>

One Last Alternate PHP Opening/Closing Tag

Many developers don’t know this, but you can also use the HTML script tag to define your PHP code. This is the non-standard way to use this tag because this tag is normally used for client-side scripting, or scripts that are ran by the client’s browser. PHP is a server-side language, or a scripting language that is parsed by the server, and the clients are only served the results. I’m guessing that this method was implemented because WYSIWYG editors like MS FrontPage gets confused when it sees regular PHP tags, but recognize this script tag. Here is an example:

So there you have it. Inserting PHP code into your HTML pages is now a no-brainer.

No related posts.

Your First PHP Script

Andrew — Sat, 29 Nov 2008 17:56:55 +0000

Since PHP is a scripting language, creating your first PHP script is as easy as creating and saving a text file. In this article, you are going to be shown how simple it is to create your first PHP script.

Here is the code we will be working with. Every line will be explained in detail:

Copy that code in a text file, save it as text.php, and then upload it to your PHP-enabled web server, and you should see “It works!” in your web browser when you call up that script.

Lines 1 & 4: PHP Tags

All PHP code has to be within PHP tags, like this:

As you can see, the PHP tags can be in the same line in the code as I just did, or they can be on different lines, as in the first example. We need to surround all PHP code in these tags because it is possible to mix PHP & HTML in the same file.

Line 2: Comment

It’s best to get into the habit of commenting your code now. There are several ways to comment your code:

/* this comment can be on multiple lines */ # single-line comment // single-line comment

Lines 1-5 shows the best way write a comment that covers multiple lines. Lines 7 & 8 only work on one line as the example shows.

Line 3: ‘echo’ Statement

The echo statement is what sends data to the browser. There is another statement that accomplishes the same thing: print. There are tiny differences between the two statements, but for our introductory article, it’s safe to assume that they are pretty much the same.

So there you have it, a simple script, explained. Read more articles tagged for beginners for more great PHP articles for beginners.

No related posts.