spl_autoload_functions - PHP code example

Using the PHP Function spl_autoload_functions

PHP supports a number of functions for loading classes and interfaces. However, most developers writing object oriented applications create one PHP source file per class definition and must include (via set_include_path()) a long list of needed includes at the beginning of each script. This is not only inconvenient but also slows down the execution of your application. Using the spl_autoload_functions function you can register autoloaders which allow you to skip these unnecessary include operations.

Unlike the __autoload() magic method which can only be called once spl_autoload_register() allows you to register multiple autoloaders. These autoloaders are loaded in the order they are registered and can be activated by calling spl_autoload(). This allows you to implement a very flexible solution for class loading in your application.

spl_autoload_register() accepts a callable as argument which is executed when the autoload stack is activated. This callable may return a closure or any other value. This value will be used to search for the required class or interface.

An optional parameter can be specified which allows you to specify a list of file extensions that the built in __autoload() fallback function will use to look for classes. If this parameter is not provided the default list of extensions is ",". This is very useful when you want to avoid duplicated coding of your class names in your application code. You can also modify the list of extension at run time by invoking spl_autoload_register() again with the new list of file extensions.

spl_autoload_functions example

    /** * Wraps all autoloaders. */
    public static function enable(): void
    {
        // Ensures we don't hit https://bugs.php.net/42098         class_exists(\Symfony\Component\ErrorHandler\ErrorHandler::class);
        class_exists(\Psr\Log\LogLevel::class);

        if (!\is_array($functions = spl_autoload_functions())) {
            return;
        }

        foreach ($functions as $function) {
            spl_autoload_unregister($function);
        }

        foreach ($functions as $function) {
            if (!\is_array($function) || !$function[0] instanceof self) {
                $function = [new static($function), 'loadClass'];
            }

if ($shouldCacheValue) {
            $this->exportedVariables[$value] = $export;
        }

        return $export;
    }

    private function getAutoloadFile(): ?string
    {
        $file = null;

        foreach (spl_autoload_functions() as $autoloader) {
            if (!\is_array($autoloader)) {
                continue;
            }

            if ($autoloader[0] instanceof DebugClassLoader) {
                $autoloader = $autoloader[0]->getClassLoader();
            }

            if (!\is_array($autoloader) || !$autoloader[0] instanceof ClassLoader || !$autoloader[0]->findFile(__CLASS__)) {
                continue;
            }

namespace Drupal\Component\ClassFinder;

/** * A Utility class that uses active autoloaders to find a file for a class. */
class ClassFinder implements ClassFinderInterface {

  /** * {@inheritdoc} */
  public function findFile($class) {
    $loaders = spl_autoload_functions();
    foreach ($loaders as $loader) {
      if (is_array($loader) && isset($loader[0]) && is_object($loader[0]) && method_exists($loader[0], 'findFile')) {
        $file = call_user_func_array([$loader[0], 'findFile'], [$class]);
        // Different implementations return different empty values. For example,         // \Composer\Autoload\ClassLoader::findFile() returns FALSE whilst         // \Drupal\Component\ClassFinder\ClassFinderInterface::findFile()         // documents that a NULL should be returned.         if (!empty($file)) {
          return $file;
        }
      }
    }

    private function getClassCandidates(string $class): array
    {
        if (!\is_array($functions = spl_autoload_functions())) {
            return [];
        }

        // find Symfony and Composer autoloaders         $classes = [];

        foreach ($functions as $function) {
            if (!\is_array($function)) {
                continue;
            }
            // get class loaders wrapped by DebugClassLoader

$expanded[] = $class;
            }
        }

        return array_unique($expanded);
    }

    private function getClassesInComposerClassMaps(): array
    {
        $classes = [];

        foreach (spl_autoload_functions() as $function) {
            if (!\is_array($function)) {
                continue;
            }

            if ($function[0] instanceof DebugClassLoader) {
                $function = $function[0]->getClassLoader();
            }

            if (\is_array($function) && $function[0] instanceof ClassLoader) {
                $classes += array_filter($function[0]->getClassMap());
            }
        }

putenv('SYMFONY_PATCH_TYPE_DECLARATIONS'.(false !== $this->patchTypes ? '='.$this->patchTypes : ''));
    }

    /** * @runInSeparateProcess */
    public function testIdempotence()
    {
        DebugClassLoader::enable();
        DebugClassLoader::enable();

        $functions = spl_autoload_functions();
        foreach ($functions as $function) {
            if (\is_array($function) && $function[0] instanceof DebugClassLoader) {
                $reflClass = new \ReflectionClass($function[0]);
                $reflProp = $reflClass->getProperty('classLoader');

                $this->assertNotInstanceOf(DebugClassLoader::class, $reflProp->getValue($function[0]));

                return;
            }
        }

if ($shouldCacheValue) {
            $this->exportedVariables[$value] = $export;
        }

        return $export;
    }

    private function getAutoloadFile(): ?string
    {
        $file = null;

        foreach (spl_autoload_functions() as $autoloader) {
            if (!\is_array($autoloader)) {
                continue;
            }

            if ($autoloader[0] instanceof DebugClassLoader || $autoloader[0] instanceof LegacyDebugClassLoader) {
                $autoloader = $autoloader[0]->getClassLoader();
            }

            if (!\is_array($autoloader) || !$autoloader[0] instanceof ClassLoader || !$autoloader[0]->findFile(__CLASS__)) {
                continue;
            }

use Composer\Autoload\ClassLoader as ComposerClassLoader;
use PHPUnit\Framework\TestCase;
use Symfony\Component\ErrorHandler\DebugClassLoader;
use Symfony\Component\ErrorHandler\Error\ClassNotFoundError;
use Symfony\Component\ErrorHandler\Error\FatalError;
use Symfony\Component\ErrorHandler\ErrorEnhancer\ClassNotFoundErrorEnhancer;

class ClassNotFoundErrorEnhancerTest extends TestCase
{
    public static function setUpBeforeClass(): void
    {
        foreach (spl_autoload_functions() as $function) {
            if (!\is_array($function)) {
                continue;
            }

            // get class loaders wrapped by DebugClassLoader             if ($function[0] instanceof DebugClassLoader) {
                $function = $function[0]->getClassLoader();

                if (!\is_array($function)) {
                    continue;
                }
            }