Zend_Loader_StandardAutoloader is designed as a PSR-0-compliant autoloader. It assumes a 1:1 mapping of the namespace+classname to the filesystem, wherein namespace separators and underscores are translated to directory separators. A simple statement that illustrates how resolution works is as follows: Previous incarnations of PSR-0-compliant autoloaders in Zend Framework have relied upon the include_path for file lookups. This has led to a number of issues: Due to the use of include, if the file is not found, a warning is raised -- even if another autoloader is capable of resolving the class later. Documenting how to setup the include_path has proven to be a difficult concept to convey. If multiple Zend Framework installations exist on the include_path, the first one on the path wins -- even if that was not the one the developer intended. To solve these problems, the StandardAutoloader by default requires that you explicitly register namespace/path pairs (or vendor prefix/path pairs), and will only load a file if it exists within the given path. Multiple pairs may be provided. As a measure of last resort, you may also use the StandardAutoloader as a "fallback" autoloader -- one that will look for classes of any namespace or vendor prefix on the include_path. This practice is not recommended, however, due to performance implications. Finally, as with all autoloaders in Zend Framework, the StandardAutoloader is capable of registering itself with PHP's SPL autoloader registry. In terms of autloading, a "namespace" corresponds to PHP's own definition of namespaces in PHP versions 5.3 and above. A "vendor prefix" refers to the practice, popularized in PHP versions prior to 5.3, of providing a pseudo-namespace in the form of underscore-separated words in class names. As an example, the class Phly_Couch_Document uses a vendor prefix of "Phly", and a component prefix of "Phly_Couch" -- but it is a class sitting in the global namespace within PHP 5.3. The StandardAutoloader is capable of loading either namespaced or vendor prefixed class names, but treats them separately when attempting to match them to an appropriate path. Basic use of the StandardAutoloader requires simply registering namespace/path pairs. This can either be done at instantiation, or via explicit method calls after the object has been initialized. Calling register() will register the autoloader with the SPL autoloader registry. By default, the class will register the "Zend" namespace to the directory above where its own classfile is located on the filesystem. registerNamespace('Phly', APPLICATION_PATH . '/../library/Phly'); // Register the "Scapi" vendor prefix: $loader->registerPrefix('Scapi', APPLICATION_PATH . '/../library/Scapi'); // Optionally, specify the autoloader as a "fallback" autoloader; // this is not recommended. $loader->setFallbackAutoloader(true); // Register with spl_autoload: $loader->register(); ]]> The StandardAutoloader may also be configured at instantiation. Please note: The argument passed may be either an array or a Traversable object (such as a Zend_Config object. The argument passed is also a valid argument for passing to the setOptions() method. The following is equivalent to the previous example. array( 'Phly' => APPLICATION_PATH . '/../library/Phly', ), 'prefixes' => array( 'Scapi' => APPLICATION_PATH . '/../library/Scapi', ), 'fallback_autoloader' => true, )); // Register with spl_autoload: $loader->register(); ]]> The StandardAutoloader defines the following options. namespaces An associative array of namespace/path pairs. The path should be an absolute path or path relative to the calling script, and contain only classes that live in that namespace (or its subnamespaces). By default, the "Zend" namespace is registered, pointing to the arent directory of the file defining the StandardAutoloader. prefixes An associative array of vendor prefix/path pairs. The path should be an absolute path or path relative to the calling script, and contain only classes that begin with the provided vendor prefix. fallback_autoloader A boolean value indicating whether or not this instance should act as a "fallback" autoloader (i.e., look for classes of any namespace or vendor prefix on the include_path). By default, false. __construct Initialize a new instance of the object __construct $options = null Takes an optional $options argument. This argument may be an associative array or Traversable object. If not null, the argument is passed to setOptions(). setOptions Set object state based on provided options. setOptions $options Takes an argument of either an associative array or Traversable object. Recognized keys are detailed under , with the following behaviors: The namespaces value will be passed to registerNamespaces(). The prefixes value will be passed to registerPrefixes(). The fallback_autoloader value will be passed to setFallbackAutoloader(). setFallbackAutoloader Enable/disable fallback autoloader status setFallbackAutoloader $flag Takes a boolean flag indicating whether or not to act as a fallback autoloader when registered with the SPL autoloader. isFallbackAutoloader Query fallback autoloader status isFallbackAutoloader Indicates whether or not this instance is flagged as a fallback autoloader. registerNamespace Register a namespace with the autoloader registerNamespace $namespace, $directory Register a namespace with the autoloader, pointing it to a specific directory on the filesystem for class resolution. For classes matching that initial namespace, the autoloader will then perform lookups within that directory. registerNamespaces Register multiple namespaces with the autoloader registerNamespaces $namespaces Accepts either an array or Traversable object. It will then iterate through the argument, and pass each item to registerNamespace(). registerPrefix Register a vendor prefix with the autoloader. registerPrefix $prefix, $directory Register a vendor prefix with the autoloader, pointing it to a specific directory on the filesystem for class resolution. For classes matching that initial vendor prefix, the autoloader will then perform lookups within that directory. registerPrefixes Register many vendor prefixes with the autoloader registerPrefixes $prefixes Accepts either an array or Traversable object. It will then iterate through the argument, and pass each item to registerPrefix(). autoload Attempt to load a class. autoload $class Attempts to load the class specified. Returns a boolean false on failure, or a string indicating the class loaded on success. register Register with spl_autoload. register Registers the autoload() method of the current instance with spl_autoload_register(). Please review the examples in the quick start for usage.