views:

379

answers:

3

I am planning to use PHP's autoload function to dynamicly load only class files that are needed. Now this could create a huge mess if every single function has a seperate file, So I am hoping and asking is there a way to have related classes remain in 1 class file and still be auto-loaded

function __autoload($class_name){
    include('classes/' . $class_name . '.class.php');
}

Let's say there is a class name animals and then another class named dogs. Dogs class extends animals class, now if I were to call the dogs class but NOT call the animals class, would the animals class file still be loaded?

A: 

Yes it will load unless you don't include/require the class file.

You have to always import any files that contain needed PHP code. PHP itself can't guess the name you gave to your class file. Unlike Java for instance, PHP doesn't have any file naming requirements for classes.

The common way so solve this problem is to group related classes in one single file. Creating a "module".

rogeriopvl
I think you misinterpreted the question slightly, I am not asking if php will guess where a file is or is named, I am asking if I have autoload set to load a file named the same as a class but then call a class that is in the same file as the class because it is just extending the class and doesn't have it's own name
jasondavis
+3  A: 

if I were to call the dogs class but NOT call the animals class, would the animals class file still be loaded?

Yes. When you load an class that extends another class, PHP must load the base class so it knows what it's extending.

re: the idea of storing multiple classes per file: This will not work with the autoload function you provided. One class per file is really the best practice, especially for autoloaded classes.

If you have more than one class in a file, you really shouldn't attempt to autoload any classes from that file.

Frank Farmer
+4  A: 

Have you considered explicit definitions of your class locations? Sometimes it makes a lot of sense to group related classes.

Here is a proven way of handling it.

This code is placed in an auto_prepend_file (or included first)

class Import
{
    public static $_AutoLoad = array();
    public static $_Imported = array();

    public static function Load($sName)
    {
        if(! isset(self::$_AutoLoad[$sName]))
            throw new ImportError("Cannot import module with name '$sName'.");

        if(! isset(self::$_Imported[$sName]))
        {
            self::$_Imported[$sName] = True;
            require(self::$_AutoLoad[$sName]);
        }
    }

    public static function Push($sName, $sPath)
    {
        self::$_AutoLoad[$sName] = $sPath;
    }

    public static function Auto()
    {
        function __autoload($sClass)
        {
            Import::Load($sClass);
        }
    }
}

And in your bootstrap file, define your classes, and what file they are in.

//Define autoload items
Import::Push('Admin_Layout',        App::$Path . '/PHP/Admin_Layout.php');
Import::Push('Admin_Layout_Dialog', App::$Path . '/PHP/Admin_Layout.php');
Import::Push('FileClient',          App::$Path . '/PHP/FileClient.php');

And lastly, enable AutoLoad by calling

Import::Auto()


One of the nice things is that you can define "Modules":

Import::Push('MyModule',          App::$Path . '/Module/MyModule/Init.php');

And then load them explicitly when needed:

Import::Load('MyModule');

And one of the best parts is you can have additional Import::Push lines in the module, which will define all of its classes at runtime.

gahooa