In software engineering, a design pattern is a general solution to a common problem in software design. A design pattern isn't a finished design that can be transformed directly into code, it is a description or template for how to solve a problem that can be used in many different situations.

One of these design patterns is called the Singleton. It's purpose can be described quite briefly as follows:

Ensure a class has only one instance and provide a global point of access to it.

It achieves this by only creating a new instance the first time it is referenced, and thereafter it simply returns the handle to the existing instance.

Why should you want this facility in the processing of a web page? There are several reasons:

You have references to an object in multiple places, and you do not want the overhead of creating a new instance of that object for each reference.

You may wish to pass the object's state from one reference to another rather than always starting from an initial state.

As with all design patterns there is more than one way in which it can be implemented, so in the following sections I will document some of the methods that I have encountered.

You should also be aware that the code samples in this document will work in both PHP 4 and PHP 5.

It must be defined within each and every (sub)class where it will be needed. Due to the way that it works it cannot be inherited from a superclass because a static method in a superclass does not know of the existence of any subclasses therefore cannot be used to instantiate a subclass.

It provides a single method which will work for any and all classes and subclasses.

It does not require a method to be duplicated within each class or subclass.

This method has the following disadvantages:

It requires that the class definition be pre-loaded. If the file name could be deduced or constructed from the class name then could be built into the getInstance() method.

Although the class names used with the new command are case-insensitive, when used as keys within an associative array they are not. This means that 'classname', 'ClassName' and 'CLASSNAME' would be treated as different keys in the array, therefore would return different instances.

Notice how most of the classes exist in files with a standard name (classes/$class.class.inc) but some have to be dealt with separately. This is not a problem if the number of variations is small.

The only disadvantage (that I am aware of) to this method is the one regarding case sensitivity, but I avoid this problem by insisting that all class names are in lower case, and that '_' (underscore) be used instead of CamelCaps.

Some of the terms used in this document may be new to you, so here are some explanations:

The use of the word 'static' with a local variable.

The scope of a variable is the context in which it is defined, in this case a function or a class method. Normally the contents of a local variable are lost when program execution leaves this scope, but by defining a variable as 'static' you allow it to retain its value so that when program execution returns the previous value is still there. This value may be modified as many times as is required (as in the third example with the expanding array), so the term 'static' should not be confused with 'fixed, stable, stationary, not changing or moving'.

The use of the double colon '::' to call a method.

This is known as the scope resolution operator and allows a class method to be executed without the need for instantiating an object of that class. So instead of $object->method() you use class::method().

As you can see there is no single way to implement this design pattern, and this is the most simple pattern there is! Some people say that the singleton pattern is bad and should never be used, but I disagree. My reasons can be found in Singletons are NOT evil.

Added '&' to the function name and the function call so that when executed in PHP 4 this will return a reference to the original instance instead of a clone (copy) of that instance. The '&' is not necessary in PHP 5 as passing objects 'by reference' is now the default behaviour, which means that creating a 'clone' requires extra effort.