One of the nice things about using class methods as opposed to functions is that the former allows you finer-grained control over your namespace: if $foo and $bar are instances of different classes, then $foo->clone() and $bar->clone() can be different methods and you don't have to keep in mind which one is appropriate in each situation (which you would if they were global-scope functions that did different things, because they'd need different names).
The difference is largely a matter of semantics (which is why PHP4 can offer OO-like programming even though it's not an OO language).
if foo is an instance of class Foo, with properties $bar and $baz, and methods wibble() and womble, i.e.,
class Foo {
var $bar, $baz;
function Foo(){...}
function wibble($arg){...}
function womble(){...}
}
with various uses along the lines of:
$foo = new Foo();
$foo->wibble($arg);
echo $foo->bar;
you can do it all without OO by having $foo be an associative array with keys 'bar' and 'baz', and some functions - each prefixed with "Foo_" so as to prevent the functions from different ersatz classes from having the same name:
function Foo(&$instance) {...}
function Foo_wibble(&$instance, $arg){...}
function Foo_womble(&$instance, $arg){...}
Foo($foo);
wibble($foo, $arg);
echo $foo['bar'];
You've just got to remember that your $foo is an instance of class Foo,
and hence you need to use the appropriate Foo_*() functions on it (the
effect of other functions being ill-defined), which each take a
reference to $foo as their first argument. Every time you want to use $foo's wibble() method, you'd need to say to yourself "now this is an instance of Foo, so I'll have to use Foo_wibble()".
Just imagine what it might be like if $someobject could an instance of any one of several classes that all had a clone() method. Simulating it without OO, you'd have to poke around inside it (it's an associative array, remember) to find out what sort of "object" it is, and then pick out the appropriate *_clone() function. Maybe you'd want to add a new property - $foo->class (or, rather, $foo['class']).
