var xmlHttp;

function checkName(name) {
var url="checkName.php";
url=url+"?n="+name;
xmlHttp.onreadystatechange=stateChanged;
xmlHttp.open("GET",url,true);
xmlHttp.send(null);
}

function stateChanged()
{
if (xmlHttp.readyState==4 || xmlHttp.readyState=="complete")
{
document.getElementById("nStatus").innerHTML=xmlHttp.responseText;
}
}
function GetXmlHttpObject()
{
var xmlHttp=null;
try
{
// Firefox, Opera 8.0+, Safari
xmlHttp=new XMLHttpRequest();
}
catch (e)
{
// Internet Explorer
try
{
xmlHttp=new ActiveXObject("Msxml2.XMLHTTP");
}
catch (e)
{
xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");
}
}

return xmlHttp;
}

I would place this into a separate JavaScript file and link it to the page where the action takes place, but all that is really needed from this point is to add an event trigger to the form field to execute this function.  Something like this:

...

<input type='text' value='' onchange='checkName(this.value);' />

<p id='nStatus'>Please enter a name for your board.</p>

...

You can see then that the value from the form field will be checked in the function which will send the data to a PHP file which we must now define.  Whatever that PHP file “responds” with (or echoes back) will be displayed in the ‘p’ tag we defined below the input field.  So let’s finish it off with the PHP file which must check the name entered against the boards already existing in the MySQL database, leading to something like this:

<?php

//Connect to MySQL...

$name = mysql_real_escape_string($_GET['n']);

//We're using the GET method here, but there are applications of POST

$getBoards = mysql_query("SELECT `id` FROM `boards` WHERE `name`='$name'");

if (mysql_num_rows($getBoards) == 0) { echo "OK"; }

else { echo "Taken"; }

?>

Depending on your application, the echoed strings would be changed and perhaps even a bit more complex, but these work fine for the basic application we worked through.

As I noted above, we used the GET method, just like what is used in normal forms, where variables are passed through the URL to be accessed by the PHP file.  However, POST can be used and should be used in certain situations.  In general, they coincide with the general rules for form method choosing.  GET should be used for shorter requests of one or two variables and POST for multiple fields and especially those sent to the database.  Remember that the URL from GET can only be so long before cut off and may not be able to hold all the information from a long request.  Therefore, POST is certainly the most viable choice because it can be used in all applications by simply altering the method in the JavaScript and PHP and adding a few lines as noted on the tutorials listed above.

Still wondering where AJAX can come in handy?  We’ve all seen those handy “username checks” on registration pages and the suggestions provided by Google, Yahoo!, YouTube, and other big-name websites, and these all employ AJAX.   Whether you realized it or not because of their speed, these pages actually utilize more code than a typical PHP/ASP check, but they have certain disadvantages and will always be up for debate.

No related posts.

The most basic regular expression consists of a single literal character like a.  It will match that character in a string, but only on the first time, unless you apply repetitive properties to it or are more specific.  To use literal symbols, [, \, ^, $, ., |, ?, *, (, ) you must escape them with a backslash (\).   For example, 1\+1=2 is the correct regular expression to match 1+1=2.

Next are character classes or character sets.  Instead of specifying each letter of the alphabet or digit, it is possible instead to use sets of alphanumeric characters to match a string.  For instance six[a-z]+ matches sixteen, sixty, and sixlet, among others.  Charcter sets should be placed within brackets and can include any range of lower-case characters, upper-case characters, digits from 0 to 9, hyphens, and underscores.

Regular expressions do have some shorthand character classes to ease your mind:  \d for all digits, \w for all alphanumeric characters or the underscore (“_”), \s for whitespace characters including tabs and line breaks, \t for tabs individually, \r for carriage returns, and \n for line feeds.  Remember that Windows text files use \r\n to terminate lines while UNIX text files simply use \n.

The dot or period (“.”) stands for any character except line break characters, meaning the same as [^\n], where the ^ character means the negation of the following character (“anything but …”).  Often times a character class or negated character class is faster and more precise, so be cautious when using the dot.

Alternation allows for some choice in your regular expressions.  Using the vertical pipe bar (“|”), you can make sixteen, sixty, and sixlet all match the following regular expression: six(teen|ty|let).  The question mark (“?”) allows for optional characters, for instance when dealing with British-English and American-English spellings (colou?r matches color and colour).

Lastly is the issue of repetition.  The asterisk (“*”) tells the engine to atempt to match the class zero or more times.  The plus sign (“+”) tries to match one or more times.  An integer in curly brackets following a class can specify an exact amount of instances.

Now for some examples.  The description above can seem quite weighty and boring, but some applications should solidify the ideas and clarify any confusion.

Format of an e-mail address

<?php

$goodEmail = "yourname@yourdomain.com";

$badEmail = "thisIsNoEmailAtAll";

$niceTry = "thisIsClose@domain";

$tooManyAts = "thisIsCloseToo@@domain";

if (@preg_match('/[-a-zA-Z0-9]+@{1}[-a-zA-Z0-9]+[\.]{1}[a-zA-Z]{2,4}[\.]*[-a-zA-Z0-9]*/', $email)) {

echo "Good email!";

}

else {

echo "The format of your e-mail address is unacceptable.";

}

?>

You can run through each e-mail address above, and the one named as good will work while the others will fail.  Notice that we allow for three or four letter domains as well as those like “co.uk” where the domain would have two periods (“.”).

Another common use of regular expressions is in URL rewriting.  For instance, on my website, JeoReview, when a user access a URL like ‘http://www.jeoreview.com/board/Board-Name’ a different page is served to show the board itself.  In truth, that URL does not exist.  The regular expression, as placed in the .htaccess file, looks like this:

Options FollowSymLinks
RewriteEngine On
RewriteRule ^board/(.+)$ loadboard.php?name=$1

The caret (“^”) marks the beginning of the string and the dollar sign (“$”) marks the end.  Because nearly any character can be used for the board name, a dot (“.”) is used to match the name itself.  In truth, the better alternative would be to match exactly what characters can be used to increase speed and accuracy.  In any case, the $1 refers to the first character case, and each subsequent integer is filled with the following character cases, though in this example there is only one.

There are plenty of other great uses of regular expressions.  Check some out by visiting these great resources and cheat sheets:

• Regular-Expressions Reference (http://www.regular-expressions.info/reference.html)
• Regular Expression Checker (http://regjex.com/)
• Cheat Sheet (http://www.addedbytes.com/cheat-sheets/regular-expressions-cheat-sheet/)
• Using Regular Expressions and PHP (http://www.regular-expressions.info/php.html)

No related posts.

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

<?php

...

mysql_connect(host, user, password);

mysql_select_db(database [, link]);

...

?>

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:

<?php

//Connect to MySQL before running any queries, every time

mysql_query("CREATE TABLE table_name(

column_one ATTRIBUTES,

column_two ATTRIBUTES,

...

)");

mysql_close(link);

?>

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:

<?php

//Connect to MySQL before running any queries, every time

mysql_query("INSERT INTO `table_name` (col1, col2, ...)

VALUES('val1', 'val2', ...)") or die(mysql_error());

...

?>

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:

<?php

//Connect to MySQL before running any queries, every time

$getRows = mysql_query("SELECT * FROM `table_name` WHERE `col_name`='val'");

while ($result = mysql_fetch_array($getRows)) {

echo $result['col_name'];

...

}

...

?>

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:

<?php

//Connect to MySQL before running any queries, every time

mysql_query("DELETE FROM `table_name` WHERE `col_name`='val'");

...

?>

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

<?php

//Connect to MySQL before running any queries, every time

mysql_query("DROP TABLE `table_name`");

...

?>

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.

<?php

//Connect to MySQL before running any queries, every time

mysql_query("UPDATE `table_name`

SET `col_name` = 'val', `col2_name` = 'val2', ...

WHERE `col_name` = 'val'");

...
?>

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.

<?php

...

$arr = explode(delimiter, string [,limit]);

...

?>

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:

<?php

...

$links = "Home:index.php,About Us:about.php,Contact Us:contact.php,Portfolio:portfolio.php";

$links = explode(",",$links);

echo "<ul>";

foreach ($links as $link) {

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

echo "<li><a href='".$link[1]."'>".$link[0]."</a></li>";

}

echo "</ul>";

?>

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.

SEO experts would say using images to replace text is a bad idea because crawlers cannot read the text on images to analyze the content on your website, but this process will effectively use JavaScript to overcome that.  First, we’ll talk about the basic idea of creating an image with the text using a basic GD function, imageloadfont().

<?php

$font = imageloadfont("path/to/font.gdf");

?>

You can see the file is in a strange format, but you can safely use this program to convert Windows font files to the necessary format.  Using this program within the spectrum of an image created with PHP, text can be written on the image with a certain font:

<?php

$string = "Your string goes here";

//You should define the next two based on the font you are using

$charwidth = ...;

$charheight = ...;

$imagewidth = ($charwidth*strlen($string));

$text = imagecreatetruecolor = ($imagewidth,$charheight);

$font = imageloadfont("path/to/font.gdf");

$white = imagecolorallocate($text,255,255,255);

$black = imagecolorallocate($text,0,0,0);

imagefill($text,0,0,$white);

imagestring($text,$font,0,0,$string,$black);

header("Content-type: image/png");

imagepng($text);

imagedestroy($text);

?>

You can see the image is tailored to fit the text so there is no extra whitespace.  The only downside is that the ‘charwidth’ and ‘charheight’ variables have to be altered for different fonts.

With just this basic script you can turn text into an image, but how about returning to the overarching idea of dynamically turning text on a website into an image to utilize a desired font.  We’ll use some simple JavaScript for that.

Note: I’m using the most basic template of an HTML file to show the idea of the script.

<html>

<head>
<title>Text to Image Conversion</title>

<script type='text/javascript'>

function text2img() {

htwo = document.getElementsByTagName("h2");

for (i=0,tot=htwo.length;i<tot;i++) {

text = htwo.innerHTML;

htwo.innerHTML = "<img src='text2img.php?s="+text+"' alt='"+text+"' />";

}

</script>
<body onload="text2img();">

<h2>This will become an image</h2>

<p>This won't become an image.</p>

<h2>This will also become an image.</h2>

</body>
</html>

Referencing the PHP file we created in the JavaScript of this file will turn each ‘h2′ element into an image.  As I mentioned earlier, this will not mess with most search engines, though, because the text will remain for those where JavaScript is turned off.  Note, though, that that also means that users with JavaScript disabled will not see the fancy image either, just the plain text, so be sure to style it with CSS as well to insure the design of your website.

No related posts.

First of all, let’s talk about cropping and resizing images as the two use the same function, just in a slightly different way.  The function is imagecopyresampled().

<?php

imagecopyresampled($new,$orig,$newX,$newY,$oldX,$oldY,$newWidth,$newHeight,$oldWidth,$oldHeight);

?>

It’s quite a doozy, but all of the parameters are self-explanatory.  The variables ‘newX’ and ‘oldX’ refer to the new starting x-coordinates and old coordinate, respectively, and so on for the y-coordinates as well.

To crop an image, the idea is that we select a rectangular section of the original image and copy it to a new image.  Realize that in this case the ‘oldWidth’ and ‘oldHeight’ variables refer to the selection cropped, not the entire original image.  The process looks like this:

<?php

//Cropping an image
header("Content-type: image/jpeg");

$top = ...; //Define upper-most pixel of selection

$bottom = ...; //Define lower-most pixel of selection

$left = ...; //Define left-most pixel of selection

$right = ...; //Define right-most pixel of selection
$image = imagecreatefromjpeg("/path/to/image.jpg"); //Function matches file type

$new = imagecreatetruecolor(($right-$left),($bottom-$top)); //Becomes width,height

imagecopyresampled($new,$image,0,0,$left,$top,($right-$left),($bottom-$top),($right-$left),($bottom-$top));

imagejpeg($new,null,100);

imagedestroy($new);

imagedestroy($image);

?>

Next is the very similar resizing function.  The only difference with resizing is that you don’t need to pick a certain area of the image; the entire image will be copied, simply at a different width and height.

<?php

//Resizing an image
header("Content-type: image/jpeg");

$newWidth = ...; //Define new image's width

$newHeight = ...; //Define new image's height
$image = imagecreatefromjpeg("/path/to/image.jpg"); //Function matches file type

list($width,$height) = getimagesize("/path/to/image.jpg"); //Get old width and height

$new = imagecreatetruecolor($newWidth,$newHeight);

imagecopyresampled($new,$image,0,0,0,0,$newWidth,$newHeight,$width,$height);

imagejpeg($new,null,100);

imagedestroy($new);

imagedestroy($image);

?>

You can see that these two ideas are very closely related, so there isn’t much difference between the two functions.  Next, let’s talk about flipping images, both horizontally and vertically.

There are two new functions we’ll talk about here, one that gets the color of the image at a specified pixel, and the other sets the color of the image at a specified pixel.

<?php

$color = imagecolorat($image,$x,$y); //Get color

imagesetpixel($image,$x,$y,$color); //Set color

?>

The only other thing we need to talk about is the idea of rolling through each pixel, and we’ll do this using two simultaneous ‘for’ statements, one that runs through the image pixel-by-pixel horizontally, and another one that runs through each vertically at the same time.  This will allow us to get and set the color of each pixel in the image.

To flip an image horizontally, the left-most pixel becomes the right-most and vice-versa.  The top-most and bottom-most pixels switch when we flip vertically.  The process looks like this:

<?php

$type = ...; //Define flip type (horizontal or vertical)

$image = imagecreatefromjpeg("/path/to/image.jpg"); //Function matches file type
list($width,$height) = getimagesize($imagepath); //Get width and height
$new = imagecreatetruecolor($width,$height);  //Becomes new width and height
for ($x=0; $x<$width; $x++) {
for ($y=0; $y<$height; $y++) {
$color = imagecolorat($image,$x,$y); //Get pixel color
if ($type == "horizontal") {
imagesetpixel($new,(($width-1)-$x),$y,$color);
}
else { //Type is vertical
imagesetpixel($new,$x,(($height-1)-$y),$color);
}
}
}

imagejpeg($new,null,100);

imagedestroy($new);

imagedestroy($image);

?>

Last, but not least, I’ll show you how to apply several different types of effects to an image, and this doesn’t require any special calculations, just one function, imagefilter().  You can read about all of the different filters available, but the main ones are blurring, converting to gray scale, and changing contrast/brightness.

With these GD functions in tow, there is very little you can’t do with PHP.  Alright, so there’s still quite a bit that PHP can’t do with images practically, but it’s only a matter of time before programmers are able to apply even the most complex Photoshop functions to PHP.

No related posts.

The comparision operators are:

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.

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.

<?php

$grade = 93;

if ($grade >= 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.

<?php
$date = ...; //Obtain date in the form "mm/dd"

switch($date) {
case "01/01":
echo "Happy New Year";
break;
case "02/14":
echo "Happy Valentine's Day";
break;
case "05/10":
echo "Happy Mother's Day";
break;
default:
echo "Happy Day!";
break;
}
?>

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.

First of all, let’s detail the major all-in-one installers.  The two most popular are XAMPP and WAMP (notice the AMP they have in common).  XAMPP is an acronym, each letter standing for a feature of the package:

• X: means the package is cross-platform (Linux, Windows, etc)
• A: Apache HTTP Server
• M: MySQL
• P: PHP
• P: Perl

The XAMPP package, which can be easily downloaded and installed on Windows machines, includes the following features as well: mod_php, mod_perl, mod_ssl, OpenSSL, phpMyAdmin, Webalizer, Mercury Mail Transport System for Win32 and NetWare Systems v3.32, Ming, JpGraph, FileZilla FTP Server, mcrypt, eAccelerator, SQLite, and WEB-DAV + mod_auth_mysql.  It may seem like a lot because, well, it is!  Take my word for it:  if you’re looking for a quick, simply install with all of the necessities, XAMPP is great!

WAMP is also an acronym, where the AMP stands for Apache, MySQL, and PHP, and the W here specifies that it only works on Windows machines.  WAMP also includes phpMyAdmin but is much more stripped in its features.  I suggest WAMP if you want a lighter install with only the bare-bones features.

The next option is to install Apache and PHP on your own, though this solution is still rather easy.  By downloading the Apache installer (choose the last Win32 option) and running through the steps (detailed later), you can couple it with an easy PHP installer, either one available directly from the PHP website, located here, or one from a third-party source, like the EasyWindows Installer.  Following the steps they suggest will allow another quick installation option.  This is certainly the lightest quick installation available.

The last option is certainly the toughest, but I, as well as the PHP developers themselves, recommend it.  Installing PHP yourself allows you to take a close look at the files that configure it and work with them as well.  This may seem intimidating to some, so that’s why there are so many other options available.  You can follow the manual instructions at php.net or follow my instructions for installing Apache and PHP below.  I’ve sifted through PHP’s instructions to create the easiest-to-understand steps I could.

Let’s begin by configuring PHP.

1. Download the PHP package.  I suggest the latest Windows binary (5.2.8 as of this article).
2. Extract the entire package to a folder on your machine (e.g. C:/PHP).  Note that the latest releases of PHP do not create their own folder, so you must extract them to the folder you wish for PHP to reside in.
3. Make php5ts.dll available to the web server and CGI and CLI binaries through one of the three following options:
   • Copy the file to the windows system directory (C:/WINDOWS)
   • Copy the file to the web server’s directory
   • Add the path to PHP to the PATH environment variable by following these easy steps.
4. Set up a valid php.ini file. There are two available in your PHP folder: php.ini-recommended and php.ini-dist. The “recommended” file makes your installation more secure, but if you are installing on a home machine, the “dist” file is fine. Simply save the file as php.ini in your PHP folder.
5. Now, edit the php.ini file you just saved by finding the doc_root variable and setting it equal to the following: C:\Apache\htdocs
6. Find the extension_dir variable and set it equal to C:\PHP\ext
7. Be sure to use backslashes in the php.ini file.
8. Save the file and close it.

Now you can begin installing Apache and finishing configuration.

1. Download the latest release of Apache here (choose the last Win32 option).  Use the installer to set up Apache, and install it in C:/Apache.
2. To set up PHP to work as an Apache module, open the httpd.conf file (located in C:/Apache/conf/) and add the following lines to the bottom of the file:
   • LoadModule php5_module “c:/php/php5apache2_2.dll”
   • AddType application/x-httpd-php .php
   • PHPIniDir “C:/PHP”
3. Be sure to use forward slashes in the httpd.conf file.
4. Save the file and close it.
5. Restart Apache by double-clicking the icon in your system tray.  Click the “Restart” button, and if Apache restarts, everything is ready to work!  If not, try working back through the steps and make sure your settings are correct.

With Apache and PHP installed, visiting http://localhost/ will load the files from your C:/Apache/htdocs folder, usually by default with an HTML file saying It works!

Whatever method you employ, setting up Apache and PHP is rather easy and simple to do.  Choose the manner best suited for you, and follow the proper steps.  In no time, you’ll have your own Apache server with PHP set up on your computer.

No related posts.

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.

<html>
<body>
<form method="post" action="upload.php" enctype="multipart/form-data">
<input type="hidden" name="MAX_FILE_SIZE" value="500000" />
<input type="file" name="file" />
<input type="submit" name="submit" value="Submit" />
</form>
</body>
</html>

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.
• <input type=”hidden”…: 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).
• <input type=”file”…: 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.

<?php

$errors = array(1 => "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 "<p>".$error."  You are now being returned to the upload form.</p>";
}

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:

<?php
//The following array will hold all PHP error messages
$errors = array(1 => "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 "<p>".$error."  You are now being returned to the upload form.</p>";
}
//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.

So far in the GD library series, I’ve detailed several key functions that one should certainly know before diving in to an extensive project.  To review some of these functions as involved with an application, check out the series thus far.

Now that you know about declaring colors, fonts, and setting up the basics of the image, let’s get right to revealing the newest (and only new) function in this article, imagefilledarc(), declared like this:

<?php

...

imagefilledarc($img,$cX,$cY,$width,$height,$startDeg,$endDeg,$col,$style);

...

?>

Now, let’s break this down, as this is quite a hefty function:

• $img = The image you are working with, established with something like imagecreate()
• $cX, $cY = The coordinates of the pixel that will be the center of the arc, and in this case, the entire pie chart
• $width, $height = Quite obviously, the width and height of the arc, meaning the pixel span horizontally and then vertically
• $startDeg, $endDeg = The starting and ending point on the circle for the arc, in degrees
• $col = The color to fill the arc with, as established earlier with imagecolorallocate()
• $style = One of several styles available, including IMG_ARC_PIE, IMG_ARC_CHORD, IMG_ARC_NOFILL, IMG_ARC_EDGED, and in this article we’ll be focusing on IMG_ARC_PIE

With this basic understanding of the function, let’s put together a basic pie chart with everything we know.  We’ll begin, as we typically do, by establishing the image and creating a blank, white canvas to work with.

<?php

$pie = imagecreate(500,500);

$white = imagecolorallocate($pie,255,255,255);

imagefill($pie,0,0,$white);

...

?>

Obviously, if you were putting together an accurate pie chart, you would have actual data and statistics to work with, but in this case, we’re just running through the basics, so we’ll use rather even, easy percentages.  Next, we’ll create an array holding the five percentages that will define the five “slices” of the pie, and we’ll also load a font to use later with labeling.  You remember how to load a font, right?

<?php

...

$font = imageloadfont('arial.gdf');

$black = imagecolorallocate($pie,0,0,0);  //This is for the labeling also

$percentages = array("40","30","15","10","5");

...

?>

Next, we’ll put together that awesome pie (I understand if you’re starting to get hungry), and I like to use a simple for() loop.  Either you can manually set the loop values if you know how many values you will have at all times, or you can make it a bit more dynamic, letting PHP do the calculations.  Let’s do this slowly, simply setting up the loop and the calculations.

<?php

...

$x = 0;

for ($z=0, $c=count($percentages); $z<$c; $z++) {

$degrees = (($percentages[$z]/100)*360);

$color = imagecolorallocate($pie,mt_rand(20,255),mt_rand(20,255),mt_rand(20,255));

...

?>

With just this, we are ready to create the “slices” of the pie, but I want to be sure a couple of things about the loop are made clear.  First of all, if you are going to use the count() function to set the limit, establish it with the incrementing variable; otherwise, PHP will have to calculate it each time the loop is run through which demands more time and resources.  Also, make sure you understand the reason for the variable before the loop. With this, we establish ‘x’ as the starting degree and set it to ’0,’ as that is where we want to start.  When calculating the degrees for each element, you can actually just multiply the percentage by 3.6, but I wanted to be sure it was obvious what I was doing there.  Lastly, we dynamically set a color, as we want each “slice” to be different.  In reality, we could end up with two slices of the same color, but the chances are slim.  Feel free to take the necessary precautions to prevent this, if you wish.  Now, let’s get to the most important part, making, not baking, a pie:

<?php

...

$x = 0;

for ($z=0, $c=count($percentages); $z<$c; $z++) {

$degrees = (($percentages[$z]/100)*360);

$color = imagecolorallocate($pie,mt_rand(20,255),mt_rand(20,255),mt_rand(20,255));

imagefilledarc($pie,100,100,125,125,$x,($x+$degrees),$color,IMG_ARC_PIE);

imagefilledrectangle($pie,250,(50+(25*($z+1))),275,(75+(25*($z+1))),$color);

imagestring($pie,$font,276,(55+(25*($z+1))),$vals[$z]."%",$black);

$x+=$degrees;

}

header("Content-type: image/png");

imagepng($pie);

imagedestroy($pie);

?>

Finally, we have our pie chart.  We simply use the calculations we already found, along with whatever center, width, and height you wish to use to draw the pie.  Then, we simply label the pie with the corresponding percentages.  With a more complex script, you could easily label the pie with the actual descriptors for each “slice.”  Finally, we add on the total degrees to reset the starting value for the next section.  Then, output the image and your pie is ready to eat, or rather, look at.

I want to stress with this script that I titled it quite appropriately; this is a basic pie chart.  There are definitely ways to make it look more appealing, certainly, but with this basic setup, you are on your way to becoming a professional statistician, except for all that fancy math behind it.

Check out a sample pie chart; enter a list of percentages (that must add up to 100; there is nothing in place to check for this) and watch your pie come to life.

No related posts.