Dependency injection (DI) is superior to using $GLOBALS because it makes dependencies explicit, whereas $GLOBALS hides them. 2. DI improves testability by allowing easy mocking of dependencies, unlike $GLOBALS which requires manipulating global state. 3. DI reduces tight coupling by decoupling components from global scope, while $GLOBALS creates unpredictable side effects and namespace pollution. 4. DI supports Inversion of Control (IoC) through containers used in modern frameworks like Laravel and Symfony, enabling scalable and maintainable architectures. 5. Transitioning from $GLOBALS to DI can be done incrementally by refactoring functions to accept dependencies as parameters and adopting constructor injection in new classes. 6. Constructor injection is the preferred DI pattern as it ensures required dependencies are provided at instantiation. Ultimately, DI leads to cleaner, more modular, and professional code, making it the best practice for any serious PHP application beyond simple scripts.

Using dependency injection instead of relying on $GLOBALS is a more maintainable, testable, and scalable approach in modern PHP development. While $GLOBALS offers global access to variables across scopes, it introduces tight coupling, makes code harder to debug, and undermines predictability. Dependency injection (DI) solves these issues by explicitly providing dependencies to components that need them.

Why $GLOBALS Falls Short

$GLOBALS is a superglobal array in PHP that contains references to all variables defined in the global scope. While convenient, it encourages poor practices:

• Hidden dependencies: When a function pulls data from $GLOBALS, it's not obvious what it depends on just by looking at its signature.
• Hard to test: You can't easily mock or isolate behavior in unit tests because the function relies on external global state.
• Namespace pollution: Any part of the code can modify $GLOBALS, leading to unexpected side effects and bugs that are difficult to trace.
• Tight coupling: Components become dependent on global state rather than receiving what they need through clear interfaces.

For example:

function processOrder() {
    $db = $GLOBALS['database'];
    $db->query("...");
}

This function has no declared dependency on a database—it just assumes one exists in $GLOBALS. That makes it fragile and unclear.

How Dependency Injection Improves Code Quality

Dependency injection means passing dependencies (like services, configurations, or objects) into a class or function from the outside, rather than letting it fetch them internally.

1. Explicit Dependencies

With DI, dependencies are clear from the function or constructor signature:

class OrderProcessor {
    private $database;

    public function __construct($database) {
        $this->database = $database;
    }

    public function process() {
        $this->database->query("...");
    }
}

Now it’s immediately obvious that OrderProcessor needs a database to work.

2. Better Testing

You can easily inject a mock database during testing:

$mockDb = $this->createMock(Database::class);
$mockDb->method('query')->willReturn(true);

$processor = new OrderProcessor($mockDb);
$result = $processor->process();

No need to set up global state or worry about side effects.

3. Looser Coupling and Reusability

Classes aren’t tied to global variables or specific implementations. You can swap out the database, logger, or config manager without changing internal logic.

4. Support for Inversion of Control (IoC)

DI works well with IoC containers, which manage object creation and dependency resolution automatically. Frameworks like Laravel, Symfony, and Slim use DI containers extensively to streamline application architecture.

Example using a simple container:

$container = new Container();
$container->set('Database', function() {
    return new Database($host, $user, $pass);
});

$container->set('OrderProcessor', function($c) {
    return new OrderProcessor($c->get('Database'));
});

This keeps object creation centralized and configurable.

Common DI Patterns

There are three main ways to inject dependencies:

• Constructor injection: Pass dependencies via the constructor (most common and recommended).
• Setter injection: Use setter methods to inject optional or replaceable dependencies.
• Interface injection: Less common in PHP; involves implementing an interface that defines how dependencies are injected.

Constructor injection is preferred because it ensures required dependencies are present from the start.

Transitioning from $GLOBALS to DI

Moving away from $GLOBALS doesn’t have to happen all at once. Start small:

• Identify functions that use $GLOBALS.
• Refactor them to accept parameters instead.
• Use dependency injection in new classes from the beginning.
• Gradually introduce a DI container for managing complex object graphs.

For instance, replace this:

function sendEmail($to, $subject) {
    $mailer = $GLOBALS['mailer'];
    $mailer->send($to, $subject);
}

With:

function sendEmail($to, $subject, Mailer $mailer) {
    $mailer->send($to, $subject);
}

Or better yet, encapsulate in a class with constructor injection.

Bottom Line

Dependency injection promotes cleaner, more modular, and testable code. While $GLOBALS might seem like a quick way to share data, it leads to technical debt and fragile applications. DI requires a bit more upfront effort but pays off in long-term maintainability and flexibility.

It’s not just a trend—it’s a foundational practice in professional PHP development. Once you start using DI consistently, going back to global variables feels like stepping into the past.

Basically, if you're building anything beyond a simple script, DI is the way to go.

The above is the detailed content of Dependency Injection: The Superior Alternative to $GLOBALS. For more information, please follow other related articles on the PHP Chinese website!