#Adam.Blog# » PHP http://blog.adampresley.com I'm bringin' nerdy back. Fri, 03 Sep 2010 15:59:26 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 Sorting a Complex Array of Products in PHP http://blog.adampresley.com/2009/sorting-complex-array-of-products-in-php/ http://blog.adampresley.com/2009/sorting-complex-array-of-products-in-php/#comments Tue, 17 Nov 2009 16:39:30 +0000 Adam Presley http://blog.adampresley.com/?p=679 I’ve blogged twice recently about sorting an array of structures in ColdFusion, using both pure CF, and dipping into Groovy. This time we’ll look at how we can easily do the same task in PHP. In this post I will take the same problem, a complex array containing a structure (in PHP, an associative array), and sort it. The sort criteria in this case is that if the product IDs are the same, we compare the prices of the products and sort there. So we have a two-level sort: Product ID, then price.

To do this in PHP the method usort will come in handy. The usort method takes two parameters. The first parameter is the array to be sorted (passed by reference, so make sure you keep a copy if you need the original), and a function to compare two items.

The comparator function simply takes two items. It is up to us to compare them how we like, and return zero (0) for equal, one (1) for the first item being greater (or after) the second item, or negative one (-1) for the first item coming before the second item, or less than. Let’s take a look at how that function would work.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

function comparator($a, $b)
{
	$productId1 = $a["productId"];
	$productId2 = $b["productId"];
 
	$price1 = $a["price"];
	$price2 = $b["price"];
 
	if ($productId1 == $productId2)
	{
		if ($price1 == $price2)
			return 0;
		else
			return ($price1 > $price2) ? 1 : -1;
	}
	else
		return ($productId1 > $productId2) ? 1 : -1;
}

As you can see, we compare item $a and item $b. If the the two product IDs are the same, we’ll compare prices. To use this is quite easy. You pass an array into the usort method, and watch the magic happen. This is how that works.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

function comparator($a, $b)
{
	$productId1 = $a["productId"];
	$productId2 = $b["productId"];
 
	$price1 = $a["price"];
	$price2 = $b["price"];
 
	if ($productId1 == $productId2)
	{
		if ($price1 == $price2)
			return 0;
		else
			return ($price1 > $price2) ? 1 : -1;
	}
	else
		return ($productId1 > $productId2) ? 1 : -1;
}
 
$unsorted = array(
	array(
		"productId" => 3,
		"title" => "Widget #3",
		"price" => 6.95,
		"discounted" => true
	),
	array(
		"productId" => 4,
		"title" => "Widget #4",
		"price" => 6.75,
		"discounted" => false
	),
	array(
		"productId" => 1,
		"title" => "Widget #1",
		"price" => 10.95,
		"discounted" => false
	),
	array(
		"productId" => 2,
		"title" => "Widget #2",
		"price" => 11.95
	),
	array(
		"productId" => 3,
		"title" => "Widget #3",
		"price" => 5.95,
		"discounted" => false
	)
);
 
$sorted = $unsorted;
usort($sorted, comparator);

Notice how we create a copy of $unsorted as a variable named $sorted first. This is because the usort method works by reference, and will modify the original array. So we need a copy first to preserver the original (unless of course you don’t care about the original).

And that is all! Below is the code sample in full. Cheers, and happy coding!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

<?php
 
	function comparator($a, $b)
	{
		$productId1 = $a["productId"];
		$productId2 = $b["productId"];
 
		$price1 = $a["price"];
		$price2 = $b["price"];
 
		if ($productId1 == $productId2)
		{
			if ($price1 == $price2)
				return 0;
			else
				return ($price1 > $price2) ? 1 : -1;
		}
		else
			return ($productId1 > $productId2) ? 1 : -1;
	}
 
	$unsorted = array(
		array(
			"productId" => 3,
			"title" => "Widget #3",
			"price" => 6.95,
			"discounted" => true
		),
		array(
			"productId" => 4,
			"title" => "Widget #4",
			"price" => 6.75,
			"discounted" => false
		),
		array(
			"productId" => 1,
			"title" => "Widget #1",
			"price" => 10.95,
			"discounted" => false
		),
		array(
			"productId" => 2,
			"title" => "Widget #2",
			"price" => 11.95
		),
		array(
			"productId" => 3,
			"title" => "Widget #3",
			"price" => 5.95,
			"discounted" => false
		)
	);
 
	$sorted = $unsorted;
	usort($sorted, comparator);
 
?>
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
	<title>Sorting</title>
</head>
 
<body>
	<h1>Sorting</h1>
 
	<strong>Unsorted:</strong><br />
	<ul>
		<?php
 
			foreach ($unsorted as $item)
			{
				printf("<li>%s (%s) - %s</li>\n", $item["title"], $item["productId"], $item["price"]);
			}
 
		?>
	</ul>
	<br />
 
	<strong>Sorted:</strong><br />
	<ul>
		<?php
 
			foreach ($sorted as $item)
			{
				printf("<li>%s (%s) - %s</li>\n", $item["title"], $item["productId"], $item["price"]);
			}
 
		?>
	</ul>
 
</body>
</html>

No related posts.

]]> http://blog.adampresley.com/2009/sorting-complex-array-of-products-in-php/feed/ 0 Simple LRU Cache Class in PHP http://blog.adampresley.com/2009/simple-lru-cache-class-in-php/ http://blog.adampresley.com/2009/simple-lru-cache-class-in-php/#comments Wed, 27 May 2009 22:58:33 +0000 Adam Presley http://blog.adampresley.com/?p=398 In my ongoing effort to further enhance my PHP framework I started recently working on a caching mechanism. For the time being I am using the PEAR library’s Cache_Lite (I’ve blogged on this before, so check it out) to handle the details of persisting the cache data, locking, and all that fun jazz. Cache_Lite, however, is a pretty simple library and does not implement any particular algorithm regarding how much cache to keep, or what stays in cache and what goes. It offers an expiration mechanism, but that’s about it.So with that in mind I set off to learn about various caching and paging algorithms. They range, I found out, from simple to complex.

In this blog entry I will demonstrate the creation of a very simple LRU, or Least Recently Used, caching algorithm. I will provide downloads for PHP source code at the end of this entry.

First let’s talk about how the algorithm works. The concept behind LRU is that you have a finite set of slots in some container. Our container will be an array for simplicity. The LRU algorithm works off the premise that you keep only the most recently used items in your container, and those that get accessed are moved to the top of the array. Adding a new item to the container will be put in at the top of the array, and all subsequent items are shifted down. Any item at the bottom of the array is dropped off from the container.

Items in the LRU array are going to be stored as a structure (array in PHP) consisting of a key and element, which we will call a node. The element is simply whatever data is to be stored. The key is the identifier for the data element, and how we are able to insert and retrieve elements, or items, from the array.

There are two primary operations to supprt this: get and put. Let’s start with put as it is the simplest in concept. The first thing the put operation must do is evict any element at the bottom of the array, then shift all of the elements above down one notch. So, for example, of you have an array of 5 slots, and you are adding a new element, you will remove the last item in the array (slot 4), then shift items in slots 0 through 3 down into slots 1 through 4. From here you then insert the new item into slot 0.  Let’s take a look at how that works.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public function put($key, $element)
{
	$this->__evict();
	$this->__container[0] = $this->__createNode($key, $element);
}
 
private function __evict()
{
	$index = 0;
	$newPosition = 0;
 
	array_pop($this->__container);				// Drop off the element in the last slot.
	array_unshift($this->__container, "");		// Shift every element down one, and insert blank at the top.
}
 
private function __createNode($key, $element)
{
	return array(
		"key" => $key,
		"element" => $element
	);
}

Ok, that was easy enough. Now let’s talk about the get operation. Get starts with taking a single argument called key. It then attempts to find the correct node by looping over the container array, retrieving a node each iteration, then comparing the node’s key to the argument key. If we have a match we want to MOVE this node to the top of the array since it is the most recently used node. Once this is done we return the node. Here’s what that looks like.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public function get($key)
{
	$index = 0;
	$node = "";
 
	for ($index = 0; $index < $this->__maxElements; $index++)
	{
		$node = $this->__container[$index];
 
		if (is_array($node))
		{
			if ($node["key"] === $key)
			{
				$this->__moveToHead($index);
				$this->__stats["cacheHits"]++;
				return $node["element"];
			}
		}
	}
 
	$this->__stats["cacheMisses"]++;
	return false;
}
 
private function __moveToHead($index)
{
	if ($index == 0) return;
 
	$element = array_splice($this->__container, $index, 1);
	array_unshift($this->__container, $element[0]);
}

Using this class is pretty easy, so here is a simple test that provides a series of data items, and a comma-delimited pattern of indexes to those data items. The code then iterates over this list, simulating some part of a program that is being asked for some data, and it attempts to get the data from the cache. If it does not have it the code then puts the data into the cache.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<?php 
 
	require_once("LRUCache.php");
 
	$lru = new LRUCache(5);
 
	$db = array(
		"This is item 0",
		"This is item 1",
		"This is item 2",
		"This is item 3",
		"This is item 4",
		"This is item 5"
	);
 
	$testPattern = "0,2,4,1,0,5,3,1,5,3,0,1,5,2,5,1,4";
 
	// Implement test pattern.
	foreach (explode(",", $testPattern) as $index)
	{
		$item = $lru->get($index);
 
		if ($item !== false)
		{
			printf("<strong>Cache hit.</strong> - %s\n", $item);
		}
		else
		{
			printf("<strong>Cache miss</strong> for key %s. Adding %s to cache.\n", $index, $db[$index]);
			$lru->put($index, $db[$index]);
		}
	}
 
	printf("");
 
	$stats = $lru->getCacheStats();
 
	printf("Hits: %s", $stats["cacheHits"]);
	printf("Misses: %s", $stats["cacheMisses"]);
 
?>

Go ahead, mess with the test pattern and see how many cache hits vs cache misses there are. Kinda neat.

Download the class code here!

Happy coding!

No related posts.

]]> http://blog.adampresley.com/2009/simple-lru-cache-class-in-php/feed/ 0 Useful Date/Time Class for PHP http://blog.adampresley.com/2009/useful-datetime-class-for-php/ http://blog.adampresley.com/2009/useful-datetime-class-for-php/#comments Mon, 02 Feb 2009 05:56:03 +0000 Adam Presley http://blog.adampresley.com/?p=361 As programmers we should always strive to better ourselves by improving our craft by taking pride that what we build is not only useful, but can continue to be useful for a long time to come. Part of this strategy involves writing code that exhibits resuse, high cohesion, and loose coupling. Therefore every developer should, over time, develop, or at least acquire, sets of tools and code to help achive this goal.

Concepts like frameworks and design patterns help us achieve this. I have been working a few contract projects in PHP lately and have had many opportunities to tweak, fine tune, and improve my home-brewed PHP framework. One of these days I will share this work as a complete framework for download and use, but for now it will simply have to suffice to drop small pieces to the public.

One common task a developer will find themselves doing is manipulating dates. This could be for the purposes of display, SQL queries, or a plethora of other needs, but regardless of the reason having a useful set of classes and functions for manipulating dates and times is handy.

In my framework I have built a simple class to do the most common date tasks that I find myself repeating over and over. In my case I have opted for a class that implements all static methods, so this is not meant to be instantiated. And it is also only intended for PHP 5.2 and higher.

Most the of the functions are pretty simple to follow, and there is ample documentation attached. A couple of items worth noting are the date_parse and the mktime functions. In PHP, the date function is what allows us to format a date into whatever string we desire to craft. The mktime function allows us to specify the values for each part of a date and time string, such as the day, month, year, hour, and so on.

What is usually tricky is making functions to format a date from various sources. For example, a SQL date string usually looks like 2009-02-01, where a user in the United States might enter a value on a form like 2/1/2009. This is where the date_parse function comes in handy. It is smart enough to take these various types of input and split them into their appropriate parts. The end result is an array of its parts. For example.

1
2
3
4
5
6

$date = "02/01/2009";
$split = date_parse($date);
 
// $split["month"] = "02"
// $split["day"] = "01"
// $split["year"] = "2009"

As we can see the date has been split up into each of its parts. We can then take these parts and pass them to mktime to build the value necessay to pass to the date function for formatting.

I have linked to a download containing my date/time class, as well as the documentation for it. Enjoy, and happy coding!

Download code

No related posts.

]]> http://blog.adampresley.com/2009/useful-datetime-class-for-php/feed/ 0 Parsing PHP-style Placeholders for SQL Scripts http://blog.adampresley.com/2008/parsing-php-style-placeholders-for-sql-scripts/ http://blog.adampresley.com/2008/parsing-php-style-placeholders-for-sql-scripts/#comments Fri, 05 Sep 2008 05:12:49 +0000 Adam Presley http://blog.adampresley.com/?p=276 If you’ve ever used PHP, you’ve probably used, or at least seen, the PRINTF and/or SPRINTF functions. These oldie, but goodie, functions are stolen… err… borrowed from the old C language world. Both functions support the abililty to have placeholders, which when evaluated, are replaced with the value in a comma-delimited list in the appropriate position. For example:

1

printf("My name is %s. I am %i years old", $name, $age);

This code, given that $name equals “Adam”, and $age equals “30″ will output “My name is Adam. I am 30 years old”. A nifty feature.

Below is a bit of code that provides a class that will take a given input SQL string, an array of arguments, and spit out a parsed SQL string. An example of usage would look like so:

1
2
3

$userId = 30;
$parser = new SqlScriptParser("SELECT name, email, active FROM users WHERE userId=%i", array($userId));
$result = $parser->Parse();

The resulting string would look like:

SELECT name, email, active FROM users WHERE userId=30

The code: http://www.adampresley.com/downloads/code/php/sqlScriptParser.zip

No related posts.

]]> http://blog.adampresley.com/2008/parsing-php-style-placeholders-for-sql-scripts/feed/ 1 New Tutorial on Complex Objects in PHP Sessions http://blog.adampresley.com/2008/new-tutorial-on-complex-objects-in-php-sessions/ http://blog.adampresley.com/2008/new-tutorial-on-complex-objects-in-php-sessions/#comments Mon, 07 Apr 2008 03:42:39 +0000 Adam Presley http://blog.adampresley.com/?p=154 For those PHP programmers out there new to the language I have posted a new tutorial (just a little one :) ) on how to store and retrieve complex objects (classes) in PHP session ($_SESSION). You can find it under Software Development, or go straight to it here. Cheers!

No related posts.

]]> http://blog.adampresley.com/2008/new-tutorial-on-complex-objects-in-php-sessions/feed/ 1 My First Plugin http://blog.adampresley.com/2007/my-first-plugin/ http://blog.adampresley.com/2007/my-first-plugin/#comments Tue, 16 Oct 2007 14:57:43 +0000 Adam Presley http://blog.adampresley.com/?p=126 Yes, ladies and gentlemen, I have started learning how to write WordPress plugins. My first plugin is one that removes the word “Private: ” from the beginning of blog and page titles (when they are saved with a status of private).

The way this works is by creating a function that takes one argument. I then used a regular expression to remove the offending words. The regex I used was /^(private:\s*)/i and then I simply replaced any match with a blank string, removing it from the source text. And in WordPress there are two types of plugins: Action hooks, and Filter hooks.

In this case I used a filter hook, since filter hooks alter text coming or going from the WordPress database. So to make my filter work you have to use the add_filter function to register my function to handle the filter hook “the_title“. This hook alters the title of posts and pages before they go out to the browser. You can find my plugin at http://blog.adampresley.com/wordpress-mods/hide-private-in-title/. Now, here’s the code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

/*
	Plugin Name: Hide "Private" In Title
	Plugin URI: http://blog.adampresley.com/?page_id=124
	Description: Removes the word "private:" from the beginning of blog entry
				 	and page titles.
	Version: 1.0
	Author: Adam Presley
	Author URI: http://www.adampresley.com
 
	Copyright 2007  Adam Presley  (email : psykoprogrammer@yahoo.com)
 
	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.
 
	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.
 
	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
//--------------------------------------------------------------------------
// Name: filter_hidePrivateInTitle
// Auth: Adam Presley
// Desc: Removes the word "private:" from blog and page titles.
//--------------------------------------------------------------------------
function filter_hidePrivateInTitle($content)
{
	return preg_replace('/^(private:\s*)/i', "", $content);
}
 
//---------------------------
// Add the hook to WordPress.
//---------------------------
add_filter('the_title', 'filter_hidePrivateInTitle');

No related posts.

]]> http://blog.adampresley.com/2007/my-first-plugin/feed/ 0 Caching in PHP: Cache_Lite http://blog.adampresley.com/2007/caching-in-php-cache_lite/ http://blog.adampresley.com/2007/caching-in-php-cache_lite/#comments Wed, 30 May 2007 22:28:25 +0000 Adam Presley http://blog.adampresley.com/?p=67 For many web application developers the concept of caching is foreign. Most of us build our pages, query our databases, and spit out the results. This is usually sufficient as the content is entirely dynamic. There are times, however, when the data, although not static, doesn’t change very frequently, and can benefit from caching.

Caching can come in many complex flavors, but in this blog I will talk about a very simple caching mechanism accomplished by using the PEAR library’s Cache_Lite class. Cache_Lite allows you to cache some specific piece of data, or page content, or whatever, and retrieve it quickly for reuse.

As an example let us say you have a database table with all of your customers and information about them. This table is not likely to change TOO quickly, so perhaps a web page that allows you to search and manage these customers would benefit from caching. Let us also say that this table is named customers, and you have one on 2 different database servers, because you have several clusters. Lets also assume you have an XML file that is the master list of all customers across all clusters.

If you are building a web page that can search for customer by providing information in a search criteria, you would have to read the XML file, and then go to the customer table for each cluster to find the information you want. Well, perhaps there is a better way. In this example I am using an imaginary XML file which would look like this:

1
2
3
4
5

<customer>
	<customerName>customerA</customerName>
	<server>DB100</server>
	<active>1</active>
</customer>

With this information we can then go the customer table on the database server that each customer is on to retrieve additional information.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

require_once("Cache/Lite.php");
 
$cacheId = "UniqueCacheId";
$cacheXmlGroup = "xmlGroup";
$cacheCustomerGroup = "customerGroup";
 
$cacheOptions = array(
   "lifeTime" => 3600,
   "automaticSerialization" => true
);
 
$cache = new Cache_Lite($cacheOptions);
 
//--------------------------------------------------------------
// Read the XML master customer file. If the data is already in the
// cache use that.
//--------------------------------------------------------------
if ($cacheData = $cache->get($cacheId, $cacheXmlGroup))
   $xmlCustomerList = $cacheData;
else
{
   $xmlCustomerList = simplexml_load_file("customerXmlFile.xml");
   $cache->save($xmlCustomerList, $cacheId, $cacheXmlGroup);
}
 
//----------------------------------------------------------------------------
// Get the detail information from the database server/cluster this customer is on.
// Assume we are already connected to each cluster database, and get all the
// data. We'll pretend we have an array of mysql connections. If this data
// is already cached, use that.
//----------------------------------------------------------------------------
if ($cacheData = $cache->get($cacheId, $cacheCustomerGroup))
   $customerArray = $cacheData;
else
{
   foreach ($connectionArray as $connection)
   {
      $qry = mysql_query("SELECT * FROM customers", $connection);
 
      while ($row = mysql_fetch_object($qry))
      {
         $customerArray[$row->customerName]["additionalInfo1"] = $row->additionalInfo1;
         $customerArray[$row->customerName]["additionalInfo2"] = $row->additionalInfo2;
      }
   }
 
   $cache->save($customerArray, $cacheId, $cacheCustomerGroup);
}

In this example we are loading two pieces of data. The first is an XML file with a master customer list, containing all customers across multiple clusters. Each cluster has a database server with a customer table that has detailed information about customer on IT’S cluster. With this data retrieved you can then do just about anything with that data. Search on it… Manipulate it… Data mining… whatever.

The COOL thing about this is the caching. While the cache file is still valid the XML and customer information data is pulled from the cache file instead of reading the XML and querying the database EACH time. This is a significant speed boost.

No related posts.

]]> http://blog.adampresley.com/2007/caching-in-php-cache_lite/feed/ 2