PHP actually has two distinct uses for the static keyword. The first and most common usage is related class method and property scoping, the second to variable scoping within in a single function.

Static Methods and Properties

The static keyword allows you to define methods and properties scoped to the class in which they’re declared, rather than one particular object instance.

Let’s start by taking a look at some code examples.

<?php
class Planet {
	static $count = 0;
	public $name;
 
	function __construct($name) {
		$this->name;
		self::$count++;
	}
 
	public function getDescription() {
		return $this->name . ' is a ' . self::getShape();
	}
 
	public static function getShape() {
		return 'sphere';
	}
}
?>

What happens to the static property $count as we start creating instances?

<?php
//Outputs 0.
echo Planet::$count;
 
$earth = new Planet('Earth');
$pluto = new Planet('Pluto');
 
//Outputs 2.
echo Planet::$count;
?>

The static property $count is attached to the Planet class and not to either of the instances. It can be referenced at any time, even before $earth or $pluto are instantiated.

We used the self keyword in the constructor method to increment the counter with the expression self::$count++. Any instance method can access a static property through the self keyword – which works much like the $this variable does for referencing instance members. Using Planet::$count to access the static property would have also worked, but it’s best to avoid referencing our class by name when possible.

Let’s try calling the static method.

<?php
//Outputs 'sphere'.
echo Planet::getShape();
 
//Outputs 'Earth is a sphere'.
echo $earth->getDescription();
?>

Just like the static property, the static method can be referenced without the need to call against a specific object instance and is called via the self keyword in the statement self::getShape().

When to use static methods and properties

The static keyword is ideal for creating class-level utility methods and for share data between objects of the same type.

It also tend to get used in older code as a way of segregating code into modules, such as Log::message() or FileHelper::getFilePermissions($filename). PHP 5.3 introduced namespaces which are more appropriate for this use case and should be where if possible.

Unfortunately there are a few issues with how static methods and properties work with class inheritance. I’ve covered some of the nuances of static scoping inheritance in one of my previous posts, which looks at how PHP 5.3’s late static binding resolves the issues.

Static Variables

Despite sharing the static keyword, static variables are unrelated to PHP’s static methods and classes. In fact they have nothing to do with OOP at all. They allow you to define a variable that persists across method calls – effectively allowing you to attach state to any function.

<?php
function hello() {
	static $staticVar = 1;
	$normalVar = 1;
	return "Hello " . $staticVar++ . " " . $normalVar++ . "\r\n";
}
 
echo hello(); //Prints "Hello 1 1"
echo hello(); //Prints "Hello 2 1"
echo hello(); //Prints "Hello 3 1"
?>

Regular variables, like $normalVar, only exist within a single function call. As soon as the function returns, the variable falls out of scope and is discarded. This is why the value of $normalVar is always 1 on each call. Static variables like $staticVar, however, are only instantiated once. The same variable (and value) will be available on subsequent calls to the function.

The statment static $staticVar = 0; is only ever evaluated on the first call to the function. Because of this magic static variables can only be instantiated with scalar values (like 1, “Hello” or true) and not complex expressions (like arrays, object instances or result of a function call). If you do want to initialise a static variable with a non-scalar value then a little boiler-plate code is needed.

<?php
function hello() {
	static $world = null;
	if ($world === null) {
		$world = new Planet('Earth');
	}
	return "Hello " . $world->getName() . "\r\n";
}
?>

I find that static variables are often useful in memoizing expensive function call. The memoize function’s signature doesn’t have to change and I don’t have to resort to creating a class with private properties for a cache values or to using global variables to store the pre-calculated value. Ryan Day has posted an example and benchmark using this method.

<?php  $product_id = $_GET['product_id'];  $category_id = $_GET['category_id'];  include 'includes/product.php';  if ($_SERVER['HTTP_REQUEST_METHOD'] == 'POST') {  	include('includes/product_update.php';  }  $template->set('categories', $categories);
$template->set('errors', $errors);
$template->set('product', $product);
?>

The authors might try and justify this by saying that the includes allow for code reuse but can you really tell what’s happening here? Where are $categories, $errors and $product being defined? We can guess that $product is defined in product.php but is it being used or even modified within product_update.php? Could we safely refactor any of these files without fearing that we’ll created unintended consequences in a rarely-used code path?

Debugging the eCommerce package with Xdebug session showed that there were almost 50 different local variables in scope by the end of a typical script. I couldn’t be certain which variables were required and which weren’t, let alone where each was defined.

Why is inline code in includes a bad idea?

There are a few specific reasons we should rule this kind of code right out:

• Our main script can’t be sure of what variables are required by included files. You won’t be able to remove or refactor variables without checking each and every includes first.
• Likewise, our parent script can’t be sure if an include will modify local variables. Each included file could potentially change a global variable in a way that is required by subsequent scripts – either intentionally or unintentionally.
• If you’re using a server with register globals turned on then you’ll need to add if (!defined('APP_START')) die(); style guards to the start of every include, so they cant be requested directly by the end user. For most core this isn’t a problem, but commercial packages must code for the worst. If an include just contained function definitions this wouldn’t be a problem.

So how exactly should I be using includes?

Each include files should contain only:

• Configuration variables or constant definitions.
• A single class. The file should be named after the class. E.g. class Product is defined in Product.php.
• A set of related functions. Don’t create “do-everything” files; break your functions down into logical groups like database functions or HTML helpers

The only time I’d ever include inline code in an include file would be if I were defining config variables in code, including a PHP-based template or if I’m initialising environment configuration (such as defining error handlers, PHP ini settings and script timeouts).

Which include function should I use?

There are quite a few statements we can choose between for including files: include, include_once, require and require_once. Which should we be using?

If you follow the best practices and just have function and class definitions in an include then it becomes obvious that you wouldn’t want to include a file more than once. Doing so would force PHP to error when it attempts to redefine a function or class. Using include_once or require_once is obviously a better choice.

A missing function or class definition is something that you should know about sooner rather than later. For that reason I find require_once a better way to define dependencies.

The other function should be reserved for special cases, for example an autoloader function that would prefer to handle missing files without E_ERROR being raised.

Summing up

Rather than helping code reuse misusing includes turns your code base into a mass of spaghetti code, which would be bad enough on its own but is made worse by the code being spread over dozens of files with no hints as to what is where.

Apache Config

The easiest way to create dynamic subdomains is with the mod_vhost_alias. This module can be enabled in the conf/httpd.conf file by adding or uncommenting the following line.

LoadModule vhost_alias_module modules/mod_vhost_alias.so

Now I can define a single VirtualHost record that will work for all of our development domains. This can be either in the conf/httpd.conf file or in an included config file like conf/extra/vhost.conf.

<VirtualHost *:80>
     UseCanonicalName Off
     VirtualDocumentRoot C:\Users\Josh\Projects\%-3\
     VirtualScriptAlias C:\Users\Josh\Projects\%-3\
</VirtualHost>

The magic in this step is the %-3 wildcard. This will substitute the third last part of the hostname into the document root. So www.project-1.example.com would map to the path C:\Users\Josh\Projects\project-1\ on my development machine.

The wildcard can contain either positive or negative numbers to refer to parts of the hostname counting from either the start or end, respectively. The module document contains some examples. I find that using the third last part of the hostname is a good choice as the domain will work with or without a “www” prefix.

Creating a loopback host

This Apache vhost magic isn’t too useful without some way of pointing each dynamically created hostname to 127.0.01. Unfortunately the Window’s host file can only be used to add absolute aliases; wildcards just won’t work.

I could create a wildcard DNS entry against a domain I control, but it would be easier to just piggyback on the hard work of others. A quick Google turned up the following hosts which map back to 127.0.0.1.

• hexxie.com
• smackaho.st
• 42foo.com

So once the vhost magic is set up project-1.hexxie.com or even lots.oflots.of.subdomains.project-1.42foo.com will load the project stored in C:\Users\Josh\Projects\project-1\.

This useful behaviour can become frustrating when a carefully laid-out table encounters abnormal input and suddenly decides to stop paying attention to the cell widths we’ve specified. Luckily there is a simple solution to this. All the major browsers implement an alternative fixed table layout which is specified through the appropriately named table-layout CSS property.

The demo table below should be 200 pixels wide, with each column taking up 50% of the total width. With the default layout enabled the last word clearly pushes the table beyond these dimensions. You can toggle the table-layout between fixed and auto (the default) to see the differences.

Herr Rodriguez’s Top 5 Words

Set table-layout to fixed

On a related node, you’ll notice that overflow: hidden has no effect on table cells. You’ll have to wrap the cell contents in a container element if you want to crop it.

This simple CSS property tends to go a unnoticed, but when you need it you’ll definitely be thankful it’s there.

I put together a few test cases to compare the static and self keywords as well as to look at class introspection methods. You can see the code and results here. I’ll step through each of the tests and examine them in detail.

This post covers advanced behaviour of static scoping. An introduction to PHP’s static scoping gives a primer to readers who are looking for something simpler.

Self Keyword

The first example takes a look at PHP’s self keyword, which was introduced with PHP 5.0. It uses what is known as “compile time binding”. This essentially means that PHP’s compilation stage replaces any references to self with a reference to a specific class.

In our examples the calls to self::whoBase() and self::whoOverridden() will be compiled as though we had written A::whoBase() and A::whoOverridden(). Therefore calling B::testA() is always going to produce the same result as A::testA(); both telling us that the class name is A. Because of this a method which has non-trivial use of the self keyword is almost always useless when inherited.

There are two main reasons that inheriting static methods properly is not possible with compile time binding. Firstly the compilation process does not know which subclasses might inherit from class being compiled. Subclasses could be import-ed at any time in the future, so the compilation stage must ignore all subclasses for consistency. The second and more practical reason is that self references can only by replaced by a single class reference, so the compiler must choose the super class.

The takeaway from this is that you should assume that a self method call or property reference will be unaware of any subclasses.

Static Keyword

Obviously PHP developers weren’t happy with the limitations of self; even Zend ran into it’s limitations. The lack of usable inheritance meant the utility of static methods was greatly reduced. Thankfully PHP 5.3 introduced late static binding through the static keyword, which can be used interchangeably with self.

Late static binding means that the decision as to which class static references should resolve to is not made until the code is called. When B::testA() is called in our second example the PHP runtime makes a note that the method was called on class B. When the runtime encounters the call to static::whoOverridden() within that method it translates the static reference to class B, as that’s the class it noted earlier, and dispatches a call to B::whoOverridden().

Surprisingly PHP won’t forget that static should still resolve to B even if we add in self method calls in between the two steps. If we call the test method B::testAViaSelfReference(), which is defined in A, we might expect that the call to self::testA() would cause future static references to point to A. However we actually get the same result as we’d get without the self misdirection: the reference to class B is not lost. Only explicit references to a class by name will reset what static refers to. This is demonstrated by the test method B::testAViaExplicitReference().

You will have noticed that the static keyword is also used for static method and variable declaration. This dual usage only exists to save the language authors from defining a new PHP keyword, and shouldn’t be taken to mean any more than that.

The rule of thumb for static keywords is that they will always resolve to the class named explicitly in the calling code.

Static Method Variables

Static variables have been available since PHP 4 and allow you to define a persistent variable that is only accessible from the current function. This allows you to encapsulate state into a function or method and can eliminate the need for classes where a single function will suffice.

The third tests show that surprisingly, when a static variable is defined inside a class method they will always refer to the class on which the method was called. In doing this they act almost like properties referenced through static, though there are subtle differences.

Our test B::selfCount() increments A’s count, which indicates static variables can’t preserve the calling class scope like we just saw the static keyword do. I can see this being potentially problematic if have an inherited method containing a static variable that is called from both inside and outside it’s class.

If you find yourself doing this I’d suggest always using the static keyword rather than self for method calls inside the class, otherwise you will end up with two separate static variables in your method, one attached to the subclass and one to the super class. Alternatively, you could use static properties inside class methods and only use static variables from within plain functions.

Static Class Introspection

The final test classes look at the different ways we can check which class our current scope is attached to. The older get_class() method and __CLASS__ constant will always tell us where our methods are defined but not what class they are called against.

The function get_called_class() is new in PHP 5.3 and is the late static bound equivalent to get_class(). It returns the called class and has the same behaviour as the static keyword.

That’s All

I found this little experiment to give me a much better insight into those tricky corner cases I generally try and avoid because I’m unsure of how PHP will act.

The behaviour of static variables is still the most surprising result, though I’m sceptical to whether anything interesting can be done to make use of its abnormal behaviour (like using it to create pseudo late static binding for pre-PHP 5.3 setups). The side effect of using self with static variables has convinced me that the static keyword is probably a better choice when available. Singletons, pointing out that static variables defined within a method behave completely differently to regu

<?php
class Greeter {
	protected $count;
 
	private function __construct() {
		$this->count = 1;
	}
 
	public function hello() {
		return 'Hi ' . $this->count++;
	}
 
	public static function getInstance() {
		static $instance = null;
		if ($instance === null) {
			$class = get_called_class();
			$instance = new $class();
		}
		return $instance;
	}
}
 
class FrenchGreeter extends Greeter {
	public function hello() {
		return 'Bonjour ' . $this->count++;
	}
}
 
echo Greeter::getInstance()->hello(); //Outputs 'Hi 1'
echo Greeter::getInstance()->hello(); //Outputs 'Hi 2'
echo FrenchGreeter::getInstance()->hello(); //Outputs 'Bonjour 1'
?>

Now, there are a few fun snippets in this piece of code. Let’s start at the top:

Private constructors

private function __construct();

A private constructor? Yep. That means that only the Greeter class can construct a new instance of itself. You can try it if you’d like:

$bob = new Greeter();
Fatal error: Call to private Greeter::__construct() from invalid context in C:\Users\Josh\Examples\singletons.php on line 1

Told you so. So this prevents anyone from sneakily constructing a new instance of the class when we’re not looking. On to the next snippet.

Static variables

public static function getInstance() {
	static $instance = null;

Defining statically scopped variables within functions is a feature borrowed from C. All static variables, whether defined in a method or in the class definition, are bound to the function and will persist across calls. The initial assignment (setting the variable to null) is only executed once – when the variable is declared. You can only assign scalar values on a static variable declaraion so the null assignment and check are necessary to if we are to assign an object or array to the variable.

You can use static variables in instance methods and plain old functions too. If you do use them in an instance method then remember that the variable is bound to the class and not the instance. Take a look at the following code:

<?php
class Counter {
	function count() {
		static $count = 1;
		return $count++;
	}
}
 
class SubCounter extends Counter { 
}
 
$a = new Counter();
$b = new Counter();
$c = new SubCounter();
echo $a->count(); //Outputs 1
echo $b->count(); //Outputs 2
echo $c->count(); //Outputs 1

Even though $a and $b are two seperate instances the static $count variable is scoped to the method, which is in turn scoped to the class, so is shared between instances. When we call the method on $c our static variable is bound to SubCounter so we get the value of 1.

Fetching the current class name

$class = get_called_class();

The get_called_class method is a long overdue addition to PHP and was added in the 5.3 release with the introduction of late static binding. The function returns the class which the current method was invoked on. The older get_class (when called with no arguments) and __CLASS__ magic constant always return the name of the class where the current method was defined (compile time binding). Let’s take a look.

<?php
class A {
	public function who() {
		echo __CLASS__;
		echo get_class();
		echo get_class($this);
		echo get_called_class();
	}
 
	public static function whoStatic() {
		echo __CLASS__;
		echo get_class();
		echo get_called_class();
	}
}
 
class B extends A {
}
 
$a = new A(); 	
$b = new B(); 	
$a->who();          //Outputs AAAA
$b->who();          //Outputs AABB
A::whoStatic();    //AAA
B::whoStatic();    //Outputs AAB

The get_class() function is a kind-of dual purpose function. If an object is passed to the function then it returns the name of that object’s class. Otherwise it acts like __CLASS__.

Instance methods always give us an implicit $this variable, which we can easily pass to get_class(). However, static methods have no such luxury. Before the introduction of late static binding there was absolutely no way to determine which class a static method was called on.

Variable variable functions

$instance = new $class();

This is one of PHP’s niftier features. Any variable lookup, function call or class instantiation can be performed on a string value. PHP calls these Variable variables and Variable functions. Let’s check out some examples.

<?php
$var = 'city';
$city = 'London';
echo $$var;	//Outputs 'London'
 
$a = 'foo';
$b = 'bar';
$foobar = 'Found me';
echo ${$a . $b}; //Outputs 'Found me'
 
$a = 'b';
$b = 'c';
$c = 'd';
$d = 'The end';
echo $$$$a; //Outputs 'The end';
 
function greeting() { echo 'Hi'; }
$func = 'greeting';
$func(); //Outputs 'Hi'

This allows for some neat meta-programming. Though care should be taken not to abuse the functionality.

So there you have it, four advanced PHP examples from one design pattern (that you should never, ever use).

I’ve worked with PHP for over six years. It has it’s warts (and how) but it’s very much a known quantity at this point. On the other hand, when I have used Python it’s been a much more pleasant experience. The fact that this is a personal project makes the decision easier: let’s ditch old mate LAMPhp go with LAMPy. It’s almost dinner time and the latter sounds like it’d go well with an ale anyway. So, starting with a brand new dev box, where do I begin?

1. Go to the Python website
   Of course. So P-Y-T-H-O-N-DOT-C-O-M, Enter. Er. Not exactly what I was looking for (and not what you should be looking for if your boss is anywhere nearby). Let’s try that again. Google to the rescue. Apparently I want DOT-O-R-G.
2. Choose a binary
   OK, so I know from listening to the fine folks over at proggit that there is an attempted Python 2 to 3 migration happening at the moment. There is no point investing my time in an outdated version so I’ll grab the 3.1 download.
3. Install Python
   C:\Python31. Hmm. Python, I know that you have a high opinion of yourself but you’re not that important to me just yet. You can go play nice in Program Files with all the other programs.
4. Download Django
   Now it’s Django’s turn. There’s the installer. Python 2.3 or higher, you say. Well logically 3 is higher than 2.3, but doesn’t Python 3 have problems with it’s younger siblings? Let me just check with a hit of the old Google… yup, as I thought. We’ll have to go with the older version.
5. Install Python
   Python 2! It’s not quite as fun when you know your downloading an outdated model.
6. Install Django
   So I’ve downloaded Django and now I’ve got an archive full of Python files. How do I install them?
7. Read the instructions
   But I hate doing that!
8. Run setup.py
   So I have to run the included setup.py file? If I launch the file from Explorer it prints something then immediately exits. Let’s open up the command line, cd to the correct location and run it again.
9. Run setup.py install
   OK, I forgot the “install” argument. You could have just told my with a popup; slept after printing the error; or heaven forbid, prompted me for an action. At least it’s working… can’t copy!? What do you mean?
10. Run setup.py install as an administrator
    Ah, of course you can’t copy to my Program Files. Time to launch a new command window as an administrator, renavigate to the archive and install.
11. Start a Django project
    You have to love the feeling you get when something works first time.
12. Define database settings
    Edit my project settings, easy enough.
13. Run the Django server
    Error: MySQLdb blah blah blah. What does that mean? Wait, Python does come with MySQL extensions right? Right!? It’s not like it’s one of the the most popular RDBMS on the planet.
14. Google it
    Hi Google. Yes, I’m back again. Do you know which module I want? Wow. That’s a lot of results. Are these the same? I’m looking for MySQLdb, not MySQL-Python. Ah, I see. They’re the same.
15. Go to SourceForge
    Why is this on SourceForge? Who’s distributing it? Ah, screw it. There is a big download button. I’m sure it’s safe. I mean, the button is green. Green is good. Red is bad. I didn’t get this far without learning a few things.
16. These are not the files you are looking for
    What do you mean they are the C files? I want a binary installer dammit. I’m a Windows user. I’m like a ten year old who still has training wheels on his bike; I don’t know anything about make files and building binaries.
17. Get the binary
    At least I know where the binaries can be downloaded… don’t I? Why do the binaries stop at Python 2.5 on the SourceForge page?
18. Google it!
    Yes, Google, I know I was just here. Just tell me where I can get a binary. Please stop laughing at me.
19. Download a binary
    There are a bunch of unofficial installers. Which one do I choose? bobs-super-awesome-mysql-python-for-2.6.exe looks reputable.
20. Install MySQLdb
    Great, a proper installer this time. It looks a bit “Windows 95″ but beggers can’t be choosers. At least with an installer this should be eas… Hmmm, it’s frozen.
21. Think back
    Wait, the other installer didn’t like running in user mode either. Perhaps if I run as root. Ah ha. That’s done it.
22. Install Python
    How silly of me. It should be obvious that all the C extensions only offer win32 versions. What exactly is the point of having a 64 bit binary then? Let’s reinstall Python. Joy of joys.
23. Enjoy
    Success at last. Time to revel in my new found smugness as a Pythonista: “If the implementation is easy to explain, it may be a good idea.” You tell ‘em Guido.

The Takeaways

Sarcasm is fun! Fixing things is hard. Despite the tone of what I’ve said above there are quite a few frustrating  hurdles that face those new to Python and Django.

• If the .com variant of your website is a port site then you have problems. Developers might know to go to the right site but think of clueless managers.
• The Python download page should spell out the benefits and drawbacks to each binary download. Be realistic. It’s better that the developer gets the version they need first time rather than having to come back later on for seconds, or thirds.
• It’s not the 90’s any more. It’s not acceptable to expect to be installed to C:\ root.
• I didn’t mention it in the article but Python doesn’t add itself to my PATH. Having to dig around in my computer settings to be able to easily run Python from the command line is a pain.
• Win64 has existed for a long time now. Shouldn’t it be supported by common modules?
• Installers should be aware of restrictions introduced by Vista’s UAC model. This is basic stuff. Hanging on install without displaying errors is not acceptable.
• The MySQL module should not be a second-class citizen maintained by some third party. If you want to poach PHP developers then you have to speak their language.
• Setup tools could be a lot friendlier by prompting the user for an operation if an argument is not provided.
• The Django download page should make it clear that Python 3 is not supported. Dropping backwards compatibility is not actually that common in other languages.

for CHANGED in $(svn status | sed "s/^.......//" | awk "/.\./"); do
    echo $CHANGED;
    ls -l "$CHANGED";
done | cat > changes.txt

The sed naively removes the first nine characters from the file status from the svn status output, which should just leave the file name.

The awk removes all files and paths without an extension – this was necessary because I later fed the output through ls, and I didn’t want any folder listings.

The cat allows me to direct the output to a file. If you aren’t piping to a file then you can omit that part.

Finally, ls -l shows the mtime of the file. To show the atime I could have used ls -lu, though the results of this were a little inconsistant for me (some times were after the mtime, which seemed counter-intuative). I used ls because I couldn’t seem to find a replacement for stat that was available on a vanilla Solaris install.

If you’re on a Linux box the following should work just as well (without trying to filter by extension):

for CHANGED in $(svn status | sed "s/^.......//"); do
   stat "$CHANGED";
done | cat > changes.txt

Of course, I’m still new to bash coding so if you have a script that simplifies this I’d love to hear about it.

• Read both Atom and RSS feeds.
• Easy initialisation and feed iteration (one line for each).
• Cache URL contents (default is 60 minutes).
• Graceful degradation: fail gracefully on errors (errors result in a 0 item feed which can be iterated through).
• Single XML implementation for leaner code (SimpleXML).

Firstly, my usage examples:

$feed = new Feed('http://www.example.com/feed.rss');
 
//Get items with next() or current()
echo $feed->next()->title;           // "Blog post 1"
echo $feed->next()->title;           // "Blog post 2"
echo $feed->current()->title;        // "Blog post 2"
 
//Feed data returned
echo $feed->current()->title;        // "Blog post 2"
echo $feed->current()->date;         // int(1265569159)
echo $feed->current()->description;  // "Lorem ipsum dolar..."
echo $feed->current()->link;         // "http://www.example.com/blog/2"
echo $feed->current()->image;        // "http://www.example.com/blog/images/2.jpg"
 
//Get multiple items in single call
foreach ($feed->find(3) as $item) {
	echo $item->title;               // "Blog post 3" "Blog post 4" "Blog post 5"
}
 
//Reset internal counter
echo $feed->reset();
echo $feed->next()->title;           // "Blog post 1"
 
//Get random items, without repeating
echo $feed->random()->title;         // "Blog post 4"
echo $feed->random()->title;         // "Blog post 1"
 
//Total number of items
echo $feed->count();                 // int(10)

The implementation is below. I failed on the single-class requirement, instead choosing to use the Template design pattern and break the actual XML DOM navigation out into a seperate class for each feed type. This keeps the overall design a lot cleaner.

<?php
/**
 * Simple reader for RSS and Atom feeds. 
 * Requires: SimpleXML, fopen_wrappers
 * Limitations: Not content encoding support. 
 * 
 * Usage:
 *     $feed = new Feed('http://www.example.com/feed.rss');
 *
 *     //Get items with next() or current()
 *     echo $feed->next()->title;           // "Blog post 1"
 *     echo $feed->next()->title;           // "Blog post 1"
 *     echo $feed->next()->title;           // "Blog post 2"
 *     echo $feed->current()->title;        // "Blog post 2"
 *
 *     //Feed data returned
 *     echo $feed->current()->title;        // "Blog post 2"
 *     echo $feed->current()->date;         // int(1265569159)
 *     echo $feed->current()->description;  // "Lorem ipsum dolar..."
 *     echo $feed->current()->link;         // "http://www.example.com/blog/2"
 *     echo $feed->current()->image;        // "http://www.example.com/blog/images/2.jpg"
 *
 *     //Get multiple items in single call
 *     foreach ($feed->find(3) as $item) {
 *         echo $item->title;               // "Blog post 3" "Blog post 4" "Blog post 5"
 *     }
 *
 *     //Reset internal counter
 *     echo $feed->reset();
 *     echo $feed->next()->title;           // "Blog post 1"
 *
 *     //Get random items, without repeating
 *     echo $feed->random()->title;         // "Blog post 4"
 *     echo $feed->random()->title;         // "Blog post 3"
 *
 *     //Total number of items
 *     echo $feed->count();                 // int(10)
 */
class Feed {
	private $url;
	private $reader;
	private $current;
	private $remaining;
 
	public $cacheTime = 3600;
 
	/**
	 * Create Atom reader object.
	 *
	 * @param string $url
	 */
	public function __construct($url) {
		$this->url = $url;
		$this->reset();
	}
 
	/**
	 * Reset current item to first RSS item.
	 */
	public function reset() {
		$this->current = -1;
		$this->remaining = null;
	}
 
	/**
	 * Get the next item in the feed.
	 *
	 * @return stdClass Object representing the item. Will return null when the list is exhausted.
	 */
	public function next() {
		if ($this->current < $this->count()) {
			$this->current++;
			$next = $this->getReader()->item($this->current);
			return $next;
		}
	}
 
	/**
	 * Get the current item in the feed.
	 *
	 * @return stdClass Object representing the item. Will return null when the list is exhausted.
	 */
	public function current() {
		return $this->getReader()->item(max(0, $this->current));
	}
 
	/**
	 * Get random item from the feed. Will not return an item more than once.
	 *
	 * @return stdClass Object representing the item. Will return null when the list is exhausted.
	 */
	public function random() {
		if ($this->remaining === null) {
			$this->remaining = array();
			for ($i = 0; $i < $this->count(); $i++) {
				$this->remaining[] = $i;
			}
		}
 
		if (count($this->remaining)) {
			$picked = array_rand($this->remaining);
			$index = $this->remaining[$picked];
			unset($this->remaining[$picked]);
			return $this->getReader()->item($index);
		}
	}
 
	/**
	 * Get X items from feed. Will advance pointer.
	 *
	 * @param int $count
	 * @return array of stdClass
	 */
	public function find($count) {
		$items = array();
 
		while ($item = $this->next()) {
			$items[] = $item;
			if (count($items) >= $count) {
				break;
			}
		}
 
		return $items;
	}
 
	/**
	 * Get the number of items in the feed.
	 *
	 * @return int
	 */
	public function count() {
		return $this->getReader()->count();
	}
 
	/**
	 * Get FeedReader object for the feed.
	 *
	 * @return FeedReader
	 */
	private function getReader() {
		if (!$this->reader) {
			$xml = $this->getXML();
			if (RSSReader::canRead($xml)) {
				$this->reader = new RSSReader($xml);
			} else if (AtomReader::canRead($xml)) {
				$this->reader = new AtomReader($xml);
			} else {
				$this->reader = new NullReader($xml);
			}
		}
		return $this->reader;
	}
 
	/**
	 * Get XML element for the feed.
	 *
	 * @return SimpleXMLElement
	 */
	private function getXML() {
		if ($xml = $this->getCacheXML()) {
			return $xml;
		} else if ($xml = $this->getURLXML()) {
			return $xml;
		} else {
			return new SimpleXMLElement("");
		}
	}
 
	/**
	 * Get XML element for the feed from cache.
	 *
	 * @return SimpleXMLElement or null if cache doesn't exist.
	 */
	private function getCacheXML() {
		//Store URL data in local cache.
		$cacheFilename = $this->getCacheFilename();
		if (file_exists($cacheFilename) &amp;&amp; (time() - filemtime($cacheFilename)) < $this->cacheTime) {
			if ($data = file_get_contents($cacheFilename)) {
				return new SimpleXMLElement($data);
			}
		}
	}
 
	/**
	 * Get XML element from the feed from the live URL.
	 * Will cache XML data to disk.
	 *
	 * @return SimpleXMLElement or null if URL is unreachable.
	 */
	private function getURLXML() {
		if ($data = @file_get_contents($this->url)) {
			try {
				$xml = new SimpleXMLElement($data);
				file_put_contents($this->getCacheFilename(), $data);
				return $xml;
			} catch (Exception $e) {
				return null;
			}
		}
	}
 
	/**
	 * Name of the cache file for current URL.
	 *
	 * @return string
	 */
	private function getCacheFilename() {
		return sys_get_temp_dir() . '/' . md5($this->url) . '.feed.cache';
	}
}
 
/**
 * Interface for reading items from feed.
 */
interface FeedReader {
 
	/**
	 * Create reader from SimpleXMLElement.
	 *
	 * @param SimpleXMLElement $root
	 */
	public function __construct(SimpleXMLElement $root);
 
	/**
	 * Get single node.
	 *
	 * @return array or null.
	 */
	public function item($index);
 
	/**
	 * Get number of items.
	 *
	 * @return int.
	 */
	public function count();
 
	/**
	 * Can this reader understand the XML file?
	 *
	 * @param SimpleXMLElement $root
	 * @return bool
	 */
	public static function canRead(SimpleXMLElement $root);
 
}
 
/**
 * Concrete implementation of FeedReader that will never return an item.
 */
class NullReader implements FeedReader {
 
	public function __construct(SimpleXMLElement $root) {
		//Nothing
	}
 
	public function count() {
		return null;
	}
 
	public function item($index) {
		return null;
	}
 
	public static function canRead(SimpleXMLElement $root) {
		return true;
	}
}
 
/**
 * Concrete implementation of FeedReader that will read an Atom feed.
 */
class AtomReader implements FeedReader {
 
	private $root;
 
	public function __construct(SimpleXMLElement $root) {
		$this->root = $root;
	}
 
	public function count() {
		return count($this->root->entry);
	}
 
	public function item($index) {
		$node = $this->root->entry[$index];
 
		if (!$node) {
			return null;
		}
 
		$item = array(
			'title' => (string)$node->title,
			'description' => (string)$node->description,
			'image' => null,
			'link' => null,
			'date' => strtotime($node->published),
		);
 
		//Iterate through link nodes getting content URL and images.
		foreach ($node->link as $link) {
			if (strpos($link['type'], 'text') === 0 || $item['link'] === null) {
				$item['link'] = (string)$link['href'];
			}
			if (strpos($link['type'], 'image') === 0) {
				$item['image'] = (string)$link['href'];
			}
		}
 
		return (object)$item;
	}
 
	public static function canRead(SimpleXMLElement $root) {
		//Check for Atom namespace.
		return in_array('http://www.w3.org/2005/Atom', $root->getNamespaces());
	}
}
 
/**
 * Concrete implementation of FeedReader that will read an RSS feed.
 */
class RSSReader implements FeedReader {
 
	private $root;
 
	public function __construct(SimpleXMLElement $root) {
		$this->root = $root;
	}
 
	public function count() {
		return count($this->root->channel->item);
	}
 
	public function item($index) {
		$node = $this->root->channel->item[$index];
 
		if (!$node) {
			return null;
		}
 
		return (object)array(
			'title' => (string)$node->title,
			'description' => (string)$node->description,
			'url' => (string)$node->link,
			'image' => null,
			'date' => strtotime($node->pubDate),
		);
	}
 
	public static function canRead(SimpleXMLElement $root) {
		//RSS feeds name their root node 'rss'.
		return $root->getName() == 'rss';
	}
}

There are a few things missing, namely any kind of encoding awareness and correct error handling. It also requires SimpleXML and allow_url_fopen to be enabled. On the plus side the code is simple enough to hack in new features as they are needed.

I’m releasing this code under the BSD License, so feel free to take and modify it for any purposes.

To track a user I make use of three URLs: the container, which can be any website; a shim file, which contains a unique code; and a tracking page, which stores (and in this case displays) requests. The trick lies in making the browser cache the shim file indefinitely. When the file is requested for the first – and only – time a unique identifier is embedded in the page. The shim embeds the tracking page, passing it the unique ID every time it is loaded. See the source code (thanks to Nathan for pointing out the date error).

One neat thing about this method is that JavaScript is not strictly required. It is only used to pass the message and referrer to the tracker. It would probably be possible to replace the iframes with CSS and images to gain JS-free HTTP referrer logging but would lose the ability to store messages so easily.

As to how useful this actually is; the only use cases I can really think of are not exactly legitimate. The most obvious is to track users who won’t accept cookies. This does have advantages over cookies too; namely that this kind of tracking is completely silent. Virus scanners which search for an delete tracking cookies won’t affect sites using this method. Likewise, manually clearing cookies won’t work.

The most practical implementation would be to use this in concert with cookies to make tracking IDs more sticky, so they could outlast a user clearing their cookies. I’ve also been looking into adapting the link colour hack to store custom values in the browser history (this is easily doable). Combining these three techniques would mean a user would have to simultaneously clear their cache, their history and their cookies to circumvent tracking.