PHP's automatic loading methods include PSR-0, PSR-4, classmap and files. The core purpose is to implement automatic loading of classes without manually introducing files. 1. PSR-0 is an early standard, and automatically loads through class names and file path mapping, but because the naming specifications are strict and the support for underscores is rarely used as directory separators; 2. PSR-4 is a modern standard, which adopts a more concise namespace and directory mapping method, allowing a namespace to correspond to multiple directories and does not support underscore separation, becoming the mainstream choice; 3. classmap generates a static mapping table of class names and paths by scanning the specified directory, which is suitable for legacy code that does not follow the PSR specification, but new files need to be regenerated and are less efficient for large directories; 4. The files method directly contains specified files, which are often used for global function or constant loading, but excessive use will affect performance and dependency management. In actual development, PSR-4 should be preferred, and special situations should be handled in combination with other methods.

When working with PHP projects, especially those using Composer, you'll come across different autoloading strategies like PSR-0, PSR-4, classmap, and files. Each has its own use case, and knowing when to use which can save you time and avoid confusion.

What's the point of these autoloading methods?

They all serve one main purpose: helping your app load classes automatically without manually including every file. But they do it in different ways — some rely on naming conventions, others scan files or just include everything upfront.

PSR-0: The old standard

PSR-0 was the first widely adopted autoloading standard. It defines a mapping between class names and file paths. For example, a class named Vendor\Package\ClassName would map to Vendor/Package/ClassName.php .

It's pretty strict about namespace and class name formatting. Also, underscores in class names had special meaning (like directory separators), which made things confusing sometimes.

You don't see it used much anymore because PSR-4 is simpler and more flexible.

PSR-4: The modern way

PSR-4 is the current standard and what most new PHP projects use. Like PSR-0, it maps namespaces to directories, but it drops support for underscores as directory separators and is generally cleaner.

For example, if you define:

 "psr-4": {
    "App\\": "src/"
}

Then a class App\Controller\HomeController should be found at src/Controller/HomeController.php .

Some key points:

• It allows multiple directories per namespace
• You can define multiple namespace mappings
• Much easier to work with than PSR-0

This strategy works well when your code follows consistent namespace and folder structure patterns.

Classmap: Brute-force scanning

Classmap autoloading works by scanning specified directories for PHP files and building a map from class names to file paths.

You might use this when dealing with legacy code that doesn't follow PSR standards, or when you have a mix of old and new code.

In composer.json , it looks like:

 "classmap": ["legacy/", "database/migrations/"]

Composer scans all .php files in those folders and builds a static lookup table. This makes autoloading fast once built, but there's a cost:

• Initial dump may take longer
• If you add a new file, you need to re-dump autoload ( composer dump )
• Not ideal for large directories with many files

Useful when you can't change the code to fit PSR-4.

Files: Just include them all

The "files" autoloader simply includes specific files every time. No class lookup, no scanning — just loads the scripts you specify.

Typically used for functions or constants that aren't tied to any class:

 "files": ["helpers.php", "functions/general.php"]

This method ensures those helper functions are always available. But overusing it can slow down performance and make dependencies messy.

So best practice is:

• Keep it minimum
• Only use for global functions/autoloaded logic
• Don't use it as a substitute for proper class loading

Depending on your project setup and codebase style, you might use one or a combination of these methods. PSR-4 is usually the go-to choice unless you're dealing with older code. Classmap helps when structure isn't predictable, and files are great for utility scripts.

Basically that's it.

The above is the detailed content of What are the different autoloading strategies (PSR-0, PSR-4, classmap, files)?. For more information, please follow other related articles on the PHP Chinese website!