I slightly remember that autoload worked with the new statement. Now how about when I have several utility classes and I want to autoload these? And I only use static methods?
Like:
MathGuru::calculateFoo($bar);
Would autoload load MathGuru here? Or must I include it manually?
The autoloading mechanism works exactly the same way with static classes that it does with non-static one :
Actually, the autoloader doesn't even have to "know" if it is called to load a static or a dynamic class, as its role is to load the PHP code that contains the class' definition -- and not instantiate it or anything.
Yes it would trigger __autoload.
It's not just 'new' that triggers autoloading - any reference to an unknown class will do it. Even something like using class_exists will trigger the autoloader (this isn't always desirable behaviour, which is why class_exists has a second parameter to disable autoloading)
Surely the best, and fastest way is to try it?
From the docs there is nothing that mentions new being needed.
I had the exact same question as the original poster after autoloading of classes by calling their static methods didn't work. I was using Php 5.3.5 and came up with the following solution.
function autoload($class_name) {
$directories = array(
'php/classes/',
'php/vendor/'
);
foreach ($directories as $directory) {
if (file_exists($directory . $class_name . '.php')) {
require_once($directory . $class_name . '.php');
return;
}
}
}
spl_autoload_register('autoload');
Note: the spl_autoload_register function has been used instead of __autoload which seems to have been the solution.
The goal of an autoloader is to load a class whenever it is needed. So, if your client code needs a class because you want to access a static class member, and it has not loaded yet, boom, it loads it and puts it in play.
Logically then, the first thing that should work are calls to static members. Using a constructor to instantiate an object typically happens after a class has loaded. So, the static case should be first in your heart (but there are too many books and such that under-utilize static class members). :-)
I had one issue with this where a very minor syntax error gave a pretty unclear error message where it looked like __autoload() wasn't being called.
SomeClass:callStaticMethod(); // Doesn't call autoload for "SomeClass"
SomeClass::callStaticMethod(); // Successfully calls autoload for "SomeClass"
PHP strangely interprets the single ":" (instead of the correct double "::") as nothing. It treats callStaticMethod() as a global method call, meaning it skips the __autoload.
