PHP Starter

Loading INI Files in PHP

Andrew — Tue, 14 Apr 2009 12:00:23 +0000

PHP parses the php.ini file for the global PHP settings, but you can create an INI file that is specific to your own PHP application. You can also load those settings into as associate array with a native PHP function. How cool is that?

Why?

Having your config settings in a INI file makes it easier to edit, especially for those that don’t have PHP experience. It also comes in handy if you have protected PHP scripts, and you want someone to have the option of changing settings without having access to any of the PHP code. There are a couple negative effects though. Obviously, there is going to be some performance overhead because PHP will have to parse this file for each and every request made by a site visitor. Also, you can’t assign any dynamic values here, like time(), etc. You will have to make the call to determine if this method is best for you.

How it Works

Below is a sample INI file that the later examples will be loading. Notice the syntax used. The double quotes are not needed, but I am in the habit of using them because they are required if any special characters are in the values.

;some general settings not related to anything else
[general]
home_url = "http://www.example.com/"
contact_email = "contact@example.com"
app_path = "/path/to/app/root"
name = "application name"

;settings required to connect to a MySQL database
[database]
host = "localhost"
name = "database_name"
user = "db_user"
pass = "db_password"

;show we can have an array
[arrays]
test[] = "value1"
test[] = "value2"
test[] = "value3"

In the first load example, we are going to load all of the settings in one block. In other words, we are going to ignore the sections, defined in the ‘[ ]‘ characters.

Run This Example

*/

In the above example, we have a problem. Notice that we have the setting “name” in more than one block, and because of that, we had a name conflict and lost one of the values. To avoid this, we can put these setting blocks in their own associative array with the following statement.

Run This Example

*/

Now all the setting blocks are separated, and easily accessible.

So there you have it – a different type of configuration file that may be an option for your next PHP application. It’s pretty simple, and you really only need one function call to load all the settings, so the learning curve is minimal. If you want more information on this PHP function, check out the function reference.

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.

Working with AJAX

Kurtis — Thu, 05 Mar 2009 06:00:24 +0000

AJAX is all over the internet today, and though completely unnecessary, a website with it can function much more quickly. Data can be transferred to and from users efficiently, but a major drawback is the extra code needed and some security issues inherent. Nevertheless, for certain applications, AJAX is great to know and take your project to a new level.The truth is that tutorials for learning the basics of AJAX are all over the internet. For the quick setup of JavaScript, check out any of these. What I want to focus on are more practical applications of the PHP end of AJAX. Surely you can understand the basics of passing variables to a PHP processing page, but let’s go over a few examples to understand what AJAX can accomplish for us.
First of all, a soon-to-come feature on JeoReview is on the page where boards can be created. The issue is that there is a chance that someone will pick a board name that is already in use, and while the PHP is set up to catch the error, I would like for JavaScript to be able to handle it earlier and more quickly to prevent posting to pages over and over again. So we will set up the JavaScript much like the examples show:

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:

...

Please enter a name for your board.

...

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:

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.

More Examples with Parsing NDFD Data in PHP

Andrew — Tue, 03 Mar 2009 11:00:10 +0000

I covered how to Parse Weather Forecast Data (from the NDFD) in PHP in a previous article, but due to the amount of questions I received, I decided to show some more usage techniques and examples. In this article, I will cover the time-series option as well as some methods on how to make some data more presentable.

Fetching Time-Series Data from the NDFD

This was covered as an appendix in the previous article, but I will include it here as well in case you are only reading it in the feeds or by email.

Requesting the time-series data returns a whole bunch more information. As requested, here is an example on how to fetch it. Change the desired parameters to ‘true’. The other examples on how to parse the time layouts and formatting data works on this XML, too.

Run This Example

 'time-series',
					'latitude'  => 41.879535,
					'longitude'	=> -87.624333,
					'weatherParameters' => array(
					
	'maxt' => true,			'mint' => false,		'temp' => false,			'dew' => false,	
	'appt' => true,			'pop12' => false,		'qpf' => false,				'snow' => false,	
	'sky' => false,			'rh' => false,			'wspd' => false,			'wdir' => false,	
	'wx' => false,			'icons' => false,		'waveh' => false,			'incw34' => false,	
	'incw50' => false,		'incw64' => false,		'cumw34' => false,			'cumw50' => false,	
	'cumw64' => false,		'wgust' => false,		'conhazo' => false,			'ptornado' => false,	
	'phail' => false,		'ptstmwinds' => false,	'pxtornado' => false,		'pxhail' => false,	
	'pxtstmwinds' => false,	'ptotsvrtstm' => false,	'pxtotsvrtstm' => false,	'tmpabv14d' => false,	
	'tmpblw14d' => false,	'tmpabv30d' => false,	'tmpblw30d' => false,		'tmpabv90d' => false,	
	'tmpblw90d' => false,	'prcpabv14d' => false,	'prcpblw14d' => false,		'prcpabv30d' => false,	
	'prcpblw30d' => false,	'prcpabv90d' => false,	'prcpblw90d' => false,		'precipa_r' => false,	
	'sky_r' => false,		'td_r' => false,		'temp_r' => false,			'wdir_r' => false,	
	'wwa' => false,			'wspd_r' => false)
	
					);

try
{
	/* create the nuSOAP object */
	$c = new nusoap_client('http://www.weather.gov/forecasts/xml/DWMLgen/wsdl/ndfdXML.wsdl', 'wsdl');
	
	/* make the request */
	$result = $c->call('NDFDgen', $parameters);
}
catch (Exception $ex)
{
	/* nuSOAP throws an exception is there was a problem fetching the data */
	echo 'failed';
}

header('Content-type: text/xml');
echo $result;

/* ?> */

Merging Sets of Data with Different Time Layouts

The different sets of data in the NDFD are most likely going to be wanted to be displayed together. For example, on this page, you will see that I have the conditions icons, max temps, and min temps all showing at the same time intervals. But how is that possible?

In this example case, we are going to match up the high temperatures with their conditions icon. This may not give an accurate weather condition for the day because we are going to pick the icon that is the closest to the time stamp given for that temperature. In other words, the condition icons are for every hour or so, and the temperatures are only twice a day. We have to pick two of those icons to match up with the two temperatures. So for example, if the forecast for the day is “sunny in the morning, then t’storms in the afternoon”, the icon will show up as sunny.

Run This Example



NDFD Usage Example w/ Different Time Layouts

Show High Temps with Icons
 $temp): ?>


" />

High:

In the above example, the array_next() function is the one that allows us to match up the data arrays. The first parameter is the array of the weather data that we are trying to find…or in our case, the conditions icon. The second parameter is the key that we want to get close to…or in our case, the timestamp for the temperature we are displaying. So, we loop through the temperatures and search for the closest icon for each one.

Collecting and Using the Time Labels

Depending on that kind of data you are requesting, some of the time layouts contain the time labels. I had those time labels displayed in a data array called time_labels in a previous example, but I didn’t explain how I did it. Basically, I wrote a function that sifts through all of the time layouts. If it finds one with a “period-name” attribute, it saves that timestamp and the period name in a data array similar to the other data items (temp, conditions, etc).

Run This Example

xpath("//start-valid-time");
	$times = array();
	
	foreach ($data as $field => $value)
	{
		if ((string)$value['period-name'])
		{
			$index = (string)$value;
			$times[$index] = (string)$value['period-name'];
		}
	}
	
	ksort($times);
	
	return $times;
}

/* working with stale data, but why query for it every time */
$xml = file_get_contents('ndfd_forecast.xml');
$xml = new SimpleXMLElement($xml);

$time_labels = get_time_labels($xml);

header('Content-type: text/plain');
var_dump($time_labels);

/**
 * Why do I comment out the PHP closing tag?
 * See: http://phpstarter.net/2009/01/omit-the-php-closing-tag/
 */
/* ?> */

We can apply it with the Merging Sets of Data example, and end up with something like this:

Run This Example



Show Condition Icons with Time Labels

Show Condition Icons with Time Labels
 $label): ?>


" />

So there you have it – more possible applications and examples with this abundant weather forecast data. As with all other advanced articles on phpstarter.net, this is not intended provide you with copy-and-paste code to paste right in your web applications with little or no modifications. You really need to understand how this all works, and adapt it as necessary or rewrite the examples completely based on what you learned here and what you need to use it for. The point is to get you to understand the concepts used here so you can apply them to your web applications. Happy coding!

Parse Current Weather Conditions Data from the NWS in PHP

Andrew — Thu, 26 Feb 2009 12:00:36 +0000

In a previous article, I covered 5 Sources of Free Weather Data for your Site, but did not provide any actual code to use the data. Last week, I covered source #1 and showed how to Parse Weather Forecast Data (from the NDFD) in PHP. For this article, I will show how to parse source #2 – the current weather conditions data as provided by the National Weather Service.

Fetching the Data for One Station at a Time

This is ideal for a website that wants to show the current conditions for one location. Go to the XML Feeds page, and find your station. We need to know the station id for your area, so select your state, and then find the closest station to you.

The example below shows how easy it is to fetch the XML and format it into something we can read.

fetch('http://www.weather.gov/xml/current_obs/' . $station_id . '.xml', $xml_tmp . $station_id . '.xml');
	
	if (!$snoopy->results)
	{
		/* oops */
		return false;
	}
	
	$data = $snoopy->results;
	
	try
	{
		/* convert the XML into a data object */
		$xml = @new SimpleXMLElement($data);
		/* convert that data object into an array, and return it */
		return get_object_vars($xml);
	}
	catch (Exception $e)
	{
		/* we got an empty or invalid XML file */
		return false;
	}
}

$conditions = load_single_station('KLOT', $xml);
var_dump($conditions);

/**
 * Why do I comment out the PHP closing tag?
 * See: http://phpstarter.net/2009/01/omit-the-php-closing-tag/
 */
/* ?> */

Although that example gets the job done, we are going to want to do some caching. It’s a bit pointless to be fetching that XML file every time a page is requested. With a little bit of database code, we can make it relatively easy. First, setup a database that your script has access to, and create this table:

CREATE TABLE `Current` (
  `suggested_pickup` varchar(55) NOT NULL,
  `last_update` timestamp NOT NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP,
  `suggested_pickup_period` smallint(6) NOT NULL,
  `location` varchar(55) NOT NULL,
  `station_id` varchar(10) NOT NULL,
  `latitude` decimal(5,2) NOT NULL,
  `longitude` decimal(5,2) NOT NULL,
  `observation_time` varchar(255) NOT NULL,
  `observation_time_rfc822` varchar(255) NOT NULL,
  `weather` varchar(55) NOT NULL,
  `temperature_string` varchar(55) NOT NULL,
  `temp_f` smallint(6) NOT NULL,
  `temp_c` smallint(6) NOT NULL,
  `relative_humidity` tinyint(4) NOT NULL,
  `wind_string` varchar(55) NOT NULL,
  `wind_dir` varchar(55) NOT NULL,
  `wind_degrees` smallint(6) NOT NULL,
  `wind_mph` smallint(6) NOT NULL,
  `wind_gust_mph` smallint(6) NOT NULL,
  `pressure_string` varchar(55) NOT NULL,
  `pressure_mb` smallint(6) NOT NULL,
  `pressure_in` decimal(5,2) NOT NULL,
  `dewpoint_string` varchar(55) NOT NULL,
  `dewpoint_f` smallint(6) NOT NULL,
  `dewpoint_c` smallint(6) NOT NULL,
  `heat_index_string` varchar(55) NOT NULL,
  `heat_index_f` smallint(6) NOT NULL,
  `heat_index_c` smallint(6) NOT NULL,
  `windchill_string` varchar(55) NOT NULL,
  `windchill_f` smallint(6) NOT NULL,
  `windchill_c` smallint(6) NOT NULL,
  `visibility_mi` decimal(5,2) NOT NULL,
  `icon_url_base` varchar(255) NOT NULL,
  `icon_url_name` varchar(55) NOT NULL,
  `two_day_history_url` varchar(255) NOT NULL,
  `ob_url` varchar(255) NOT NULL,
  PRIMARY KEY  (`station_id`),
  KEY `latitude` (`latitude`,`longitude`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

After that MySQL table is created, have a look at this next example. It’s the same as the last one, but with two new functions: load_single_station_cache() & save_conditions(). The load_single_station_cache() function checks the table for a non-stale record for the specified station. If it finds one, it returns that database record, and no XML file is downloaded. If it doesn’t find one, it calls up load_single_station(), just like the first example, and then saves that data with the save_conditions() function.

Run This Example

fetch('http://www.weather.gov/xml/current_obs/' . $station_id . '.xml', $xml_tmp . $station_id . '.xml');
	
	if (!$snoopy->results)
	{
		/* oops */
		return false;
	}
	
	$data = $snoopy->results;
	
	try
	{
		/* convert the XML into a data object */
		$xml = @new SimpleXMLElement($data);
		/* convert that data object into an array, and return it */
		return get_object_vars($xml);
	}
	catch (Exception $e)
	{
		/* we got an empty or invalid XML file */
		return false;
	}
}

/**
 * Save the weather conditions to the database table.
 */
function save_conditions($conditions)
{
	/**
	 * Get the columns and interect that list with the data array, 
	 * so we don't try to insert some fields that don't exist
	 */
	$query = "SHOW COLUMNS FROM Current";
	$result = mysql_query($query);
	$fields = array();
	
	for ($i = 0, $n = mysql_num_rows($result); $i < $n; $i++)
	{
		$row = mysql_fetch_row($result);
		$fields[] = $row[0];
	}
	$fields = array_flip($fields);
	$conditions = array_intersect_key($conditions, $fields);
	
	/**
	 * Form the data pairs into query format.
	 * Uncomment the echo statement below to see what it's doing.
	 */
	$fields = $values = '';
	foreach ($conditions as $field => $value)
	{
		$fields .= $field . ",";
		$values .= "'" . mysql_real_escape_string($value) . "',";
	}

	/* remove the last comma from both variables */
	$fields = substr($fields, 0, strlen($fields) - 1);
	$values = substr($values, 0, strlen($values) - 1);
	
	$query = "DELETE FROM Current WHERE station_id = '{$conditions['station_id']}' LIMIT 1";
	mysql_query($query);
	$query = "INSERT INTO Current ($fields) VALUES ($values)";
	//echo $query;
	$result = mysql_query($query);
	if (!$result) die(mysql_error());
}

/**
 * Load the weather conditions from the DB table, and make the necessary 
 * calls if a recent record does not exist.
 */
function load_single_station_cache($station_id, &$xml)
{
	$station_id_esc = mysql_real_escape_string($station_id);
	
	/* no results will be returned if there is no record, *or* if 
		the record is more than 5400 seconds (90 minutes) old */
	$query = "SELECT * FROM Current WHERE station_id = '$station_id_esc' && last_update + 5400 > NOW() LIMIT 1";
	$result = mysql_query($query);
	if (!$result) die(mysql_error());
	
	if (mysql_num_rows($result) == 0)
	{
		/* load a fresh set of conditions */
		$conditions = load_single_station($station_id, &$xml);
		
		/* don't forget to save it for later */
		save_conditions($conditions);
		
		return $conditions;
	}
	else
	{
		/* we got it */
		return mysql_fetch_assoc($result);
	}
}

$conditions = load_single_station_cache('KLOT', $xml);
header('Content-type: text/plain');
var_dump($conditions);

/**
 * Why do I comment out the PHP closing tag?
 * See: http://phpstarter.net/2009/01/omit-the-php-closing-tag/
 */
/* ?> */

Fetching the Data for all Stations

Higher traffic sites that show conditions for all or most of the available stations may want to download all of the stations at once from their data feeds page, and import them into a database. To do this, we are going to need to download the zip file from the website, and then extract it. I am not going to provide specific code, because it’s unique to the server environment. Binary files can be downloaded via cURL or fsockopen() as an alternative. Once downloaded, use PHP’s Zip functions to extract the files to a temp directory. Zlib is required to open a zip archive in PHP, so if you don’t have it, you can use the shell_exec() function to run the necessary unzip functions in the shell, assuming that your server supports it.

Once you have the XML files at your disposal, use something like the scandir() function and import all files using something like the single-station example.

So there you have it – XML files turned into an easy to manage, cache-able associative array.

If these examples were enough to make your head spin, there are easy alternatives to show current conditions on your website. Check out these free weather stickers that are easier to use, although not as customizable.

Regular Expressions May Cause Irregularity

Kurtis — Tue, 24 Feb 2009 06:00:14 +0000

Regular expressions seem rather complex, even like a foreign language to beginning programmers. The mixture of symbols and characters can bring you to tears if you have a limited understanding, but with the knowledge of the significance of each symbol and construct, regular expressions can bring you from irregularity to peaceful contention bliss.A regular expression (regex for short) is a pattern describing a string of text. There are levels of complexity for regular expressions, from simple strings of literal characters to repetition and grouping.

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

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)

Parse Weather Forecast Data (from the NDFD) in PHP

Andrew — Thu, 19 Feb 2009 12:00:44 +0000

In a previous article, I covered 5 Sources of Free Weather Data for your Site, but did not provide any actual code to use the data. Starting with this article, I will post instructions on how to handle this data as well as sample code. For this article, we will start with the National Digital Forecast Database (NDFD) Simple Object Access Protocol (SOAP) Web Service.

Where to Find the Data

See weather.gov/xml for full details and available data. We will be using the 24 Hourly format, which gives us temperatures, cloud cover %, weather type (rain, snow, etc), hazardous conditions, and even weather icons.

Code to Fetch the Data

Below is some sample code that will fetch the data. The lat/lon coordinates need to be changed for your desired location on lines 10-11. Currently, it is set for Chicago, IL.

 'glance',
					'numDays'   => 5,
					'format'    => '24 hourly',
					'latitude'  => 41.879535,
					'longitude'	=> -87.624333);

try
{
	/* create the nuSOAP object */
	$c = new nusoap_client('http://www.weather.gov/forecasts/xml/DWMLgen/wsdl/ndfdXML.wsdl', 'wsdl');
	
	/* make the request */
	$result = $c->call('NDFDgen', $parameters);
}
catch (Exception $ex)
{
	/* nuSOAP throws an exception is there was a problem fetching the data */
	echo 'failed';
}

header('Content-type: text/xml');
echo $result;

/* ?> */

This is by no means a production sample. You are going to want to cache the results somehow so you aren’t querying the NDFD every time you need this information. It is only updated every hour at most, so there is no need to query it more frequent than that.

Understanding the XML Output

It took me a great deal of staring and reading to figure out how this XML output is organized. Have a look at this sample output, as I will refer to this specific example to explain the sections. I recommend loading the sample XML file in Firefox or any other web browser that allows you to collapse and expand the XML tree.

First, collapse the “head” area by clicking on the minus next to the “head” tag. Everything in there is pretty self-explanatory. Our focus is going to be in the “data” tag. Next, collapse all tags inside the “data” tag, except for the “parameters” tag, but collapse everything inside the “parameters” tag so we can see everything in there w/o scrolling. Here is what your view should look like:

Now we are at a point where we can see how this is all grouped together. As we can see, the “parameters” section shows the products that are available, which are temperature (minimum), temperature (maximum), cloud-amount, weather, conditions-icon, and hazards. Each of them is associated with a time layout because most products are on a different time scale. For example, max temps are during the afternoon & once a day, min temps are at night & once a day, the conditions icons are at several points throughout the next several days, etc. It is separated out this way because not all products have a different time scale – some are the same, like “weather” and “conditions-icon” in our example.

Time to match each product to their time layout. We see that the maximum temps have the time layout of “k-p24h-n7-1″, so we go up to the time layouts and find one with the layout-key of “k-p24h-n7-1″.

We have to code a way to merge all data sets with their corresponding time layout. This may look complicated, but I will show you a somewhat easy way to parse this in PHP.

Run This Example

 $value)
	{
		$arr[] = (string)$value;
	}
	
	return $arr;
}

/*****************************/
/* actual script starts here */
/*****************************/

/* load our example from http://phpstarter.net/samples/348/ndfd_forecast.xml */
$xml_data = file_get_contents('ndfd_forecast.xml');

/* parse the XML data into a giant data object */
try
{
	$xml = new SimpleXMLElement($xml_data);
}
catch (Exception $ex)
{
	/* the XML was probably invalid */
	die('Failed to parse the XML');
}

/* all time layouts go in here with the layout-key as the array keys */
$times = array();

/* loop through the time-layouts in the XML */
foreach ($xml->xpath('//time-layout') as $field => $value)
{
	/* get the layout-key to make it the array key value */
	$layout = (string)$value->{'layout-key'};
	
	
	$times[$layout] = array('start' => get_values($value->xpath('start-valid-time')), 
							'end' => get_values($value->xpath('end-valid-time')));
}

header('Content-type: text/plain');
var_dump($times);


/**
 * Why do I comment out the PHP closing tag?
 * See: http://phpstarter.net/2009/01/omit-the-php-closing-tag/
 */
/* ?> */

Now we have all the time layouts in a way we can manage it. The next task is to match it up to the data to their respective time layouts. This next example includes the code to organize the time layouts, and then organize the data to correspond with the times. Running the example below will show that the data is now neatly organized in a way that it can be easily used.

Run This Example

 $value)
	{
		$arr[] = (string)$value;
	}
	
	return $arr;
}

/**
 * Combine a time layout with a product
 * 
 * @param string $data_xpath the xpath to the data set
 * @param string $time_xpath the xpath to the time layout
 * @param array $times the big assoc array of all the time layouts
 */
function merge_times_data($data_xpath, $time_xpath, $times, $xml)
{
	$data = get_values($xml->xpath($data_xpath));
	$time_layout = $xml->xpath($time_xpath);
	if (!$time_layout) return false;
	$time_layout = (string)$time_layout[0]['time-layout'];
	$data = array_combine($times[$time_layout]['start'], $data);
	
	return $data;
}

/**
 * get the time layouts in an array form
 * 
 * @param string $xml
 * @return mixed
 */
function get_time_labels($xml)
{
	$data = $xml->xpath("//start-valid-time");
	$times = array();
	
	foreach ($data as $field => $value)
	{
		if ((string)$value['period-name'])
		{
			$index = (string)$value;
			$times[$index] = (string)$value['period-name'];
		}
	}
	
	ksort($times);
	
	return $times;
}

/*****************************/
/* actual script starts here */
/*****************************/

/* load our example from http://phpstarter.net/samples/348/ndfd_forecast.xml */
$xml_data = file_get_contents('ndfd_forecast.xml');

/* parse the XML data into a giant data object */
try
{
	$xml = new SimpleXMLElement($xml_data);
}
catch (Exception $ex)
{
	/* the XML was probably invalid */
	die('Failed to parse the XML');
}

/* all time layouts go in here with the layout-key as the array keys */
$times = array();

/* loop through the time-layouts */
foreach ($xml->xpath('//time-layout') as $field => $value)
{
	/* get the layout-key to make it the array key value */
	$layout = (string)$value->{'layout-key'};
	
	
	$times[$layout] = array('start' => get_values($value->xpath('start-valid-time')), 
							'end' => get_values($value->xpath('end-valid-time')));
}

$forecast['max_temps'] = merge_times_data("//parameters/temperature[@type='maximum']/value", 
	"//parameters/temperature[@type='maximum']", $times, $xml);
$forecast['min_temps'] = merge_times_data("//parameters/temperature[@type='minimum']/value", 
	"//parameters/temperature[@type='minimum']", $times, $xml);
$forecast['temps'] = array_merge($forecast['min_temps'], $forecast['max_temps']);
$forecast['icons'] = merge_times_data("//parameters/conditions-icon/icon-link", 
	"//parameters/conditions-icon", $times, $xml);
$forecast['time_labels'] = get_time_labels($xml);

header('Content-type: text/plain');
var_dump($forecast);

/**
 * Why do I comment out the PHP closing tag?
 * See: http://phpstarter.net/2009/01/omit-the-php-closing-tag/
 */
/* ?> */

There is another function in that example that associates the times to the time labels that you see in the XML. Some of them has a parameter called “period-name”, which is the day of the week or holiday name, if applicable.

How to Use the Formatted Data

For this last example, I will show you in the simplest terms how to use this data. Remember, we are not pulling data from the NDFD live – this is using the XML from our earlier example, so the temps are for mid-winter in NW Indiana.

Run This Example

 $value)
{
	echo 'High temp for ' . $forecast['time_labels'][$field] . ': ' . $value . "
\n";
}

foreach ($forecast['min_temps'] as $field => $value)
{
	echo 'Low temp for ' . $forecast['time_labels'][$field] . ': ' . $value . "
\n";
}

/**
 * Why do I comment out the PHP closing tag?
 * See: http://phpstarter.net/2009/01/omit-the-php-closing-tag/
 */
/* ?> */

So there you have it – an XML parsing nightmare made easy. This method is in my opinion the best way to receive and parse this data from the National Weather Service. It may not be the best way for everyone, so if you have something better to add, please post a comment!

(Added 2009/02/20) Fetching Time-Series Data from the NDFD

 'time-series',
					'latitude'  => 41.879535,
					'longitude'	=> -87.624333,
					'weatherParameters' => array(
					
	'maxt' => true,			'mint' => false,		'temp' => false,			'dew' => false,	
	'appt' => true,			'pop12' => false,		'qpf' => false,				'snow' => false,	
	'sky' => false,			'rh' => false,			'wspd' => false,			'wdir' => false,	
	'wx' => false,			'icons' => false,		'waveh' => false,			'incw34' => false,	
	'incw50' => false,		'incw64' => false,		'cumw34' => false,			'cumw50' => false,	
	'cumw64' => false,		'wgust' => false,		'conhazo' => false,			'ptornado' => false,	
	'phail' => false,		'ptstmwinds' => false,	'pxtornado' => false,		'pxhail' => false,	
	'pxtstmwinds' => false,	'ptotsvrtstm' => false,	'pxtotsvrtstm' => false,	'tmpabv14d' => false,	
	'tmpblw14d' => false,	'tmpabv30d' => false,	'tmpblw30d' => false,		'tmpabv90d' => false,	
	'tmpblw90d' => false,	'prcpabv14d' => false,	'prcpblw14d' => false,		'prcpabv30d' => false,	
	'prcpblw30d' => false,	'prcpabv90d' => false,	'prcpblw90d' => false,		'precipa_r' => false,	
	'sky_r' => false,		'td_r' => false,		'temp_r' => false,			'wdir_r' => false,	
	'wwa' => false,			'wspd_r' => false)
	
					);

try
{
	/* create the nuSOAP object */
	$c = new nusoap_client('http://www.weather.gov/forecasts/xml/DWMLgen/wsdl/ndfdXML.wsdl', 'wsdl');
	
	/* make the request */
	$result = $c->call('NDFDgen', $parameters);
}
catch (Exception $ex)
{
	/* nuSOAP throws an exception is there was a problem fetching the data */
	echo 'failed';
}

header('Content-type: text/xml');
echo $result;

/* ?> */

More tips can now be found here: More Examples with Parsing NDFD Data in 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!

Create Dynamic Banner Ads for Blogs & News Sites

Andrew — Thu, 12 Feb 2009 12:00:48 +0000

When you visit a site, their usual advertisers might catch your eye once or twice, but after that, you forget it’s there. Designing a banner ad that automatically updates with information such as current sales or latest blog posts is a great way to get repeat clicks and return visitors. In this article, I’m going to explain the code behind a dynamic ad implementation I use right here on this site.

If you go look at our Promote this Site page, you will see that a dynamic ad is offered that shows the most recent article on this site. This is accomplished by creating a PHP script that reads this site’s RSS Feed, finding the latest post title, and overlaying it onto a graphic template.

I think this concept has potential with blogs and news sites because static banner ads become holes in the page to repeat visitors. If I get somebody interested in this site once, then that banner will continue to catch their eyes when the article changes, and if they see a title that interests them again, they will visit the site again to read the latest article.

Here is some sample code based on what I have implemented on this site’s advertising page:

Run This Example

fetch('http://phpstarter.net/feed/');
		
		/* save this to a local cache file so the RSS feed isn't called too often */
		file_put_contents('feed.cache', $snoopy->results);
	}
	
	/**
	 * We will use lastRSS to parse the feed.
	 * See: http://phpstarter.net/2009/01/load-rss-feeds-into-php-arrays-with-lastrss/
	 */
	require('../includes/lastRSS.php');
	$rss = new lastRss();
	
	/* load the cached file */
	$feed = $rss->get('feed.cache');
	
	/* this is the banner add that we will overlay the text on top of */
	$im = imagecreatefromgif('banner_ad_article.gif');
	
	/* set some colors */
	$black = imagecolorallocate($im, 0, 0, 0);
	$white = imagecolorallocate($im, 255, 255, 255);
	$orange = imagecolorallocate($im, 249, 160, 33);
	
	/* load the font we want to use */
	$f_domestic = '../includes/Domestic_Manners.ttf';
	
	/* this is the title taken from the RSS feed's first (or most recent) item */
	$title = $feed['items'][0]['title'];
	
	/* get the width of the to-be-printed text so we can center it */
	$bbox = imagettfbbox(12, 0, $f_domestic, $title);
	$x = $bbox[0] + (imagesx($im) / 2) - ($bbox[4] / 2);
	
	/* write the text to the base image */
	imagettftext($im, 12, 0, $x, 52, $orange, $f_domestic, $title);
	
	/* tell the browser that we are outputting a GIF image */
	header('Content-type: image/gif');
	
	/* render the image */
	imagegif($im);
?>

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.