Dependency injection concept in PHP - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main benefit of dependency injection?

Consider a PHP class that needs to use a database connection. What is the main benefit of using dependency injection to provide the database connection to the class?

A It makes the class tightly coupled to a specific database implementation.

B It allows the class to receive the database connection from outside, making it easier to test and change dependencies.

C It allows the class to create the database connection internally whenever needed.

D It forces the class to manage the lifecycle of the database connection.

💡 Hint

Think about how receiving dependencies from outside helps with testing and flexibility.

Dependency injection means giving a class the objects it needs instead of creating them inside. This makes the class easier to test and change because it does not depend on specific implementations.

❓ component_behavior

intermediate

What will this PHP code output when using dependency injection?

Given the following PHP code, what will be the output?

PHP

<?php
class Logger {
    public function log($msg) {
        echo "Log: $msg";
    }
}

class User {
    private $logger;
    public function __construct(Logger $logger) {
        $this->logger = $logger;
    }
    public function create() {
        $this->logger->log('User created');
    }
}

$logger = new Logger();
$user = new User($logger);
$user->create();
?>

A Fatal error: Uncaught Error: Class 'Logger' not found

B User created

C Log:

D Log: User created

💡 Hint

Look at how the logger is passed to the User class and used in the create method.

The User class receives a Logger instance via its constructor (dependency injection). When create() is called, it calls the log method on the Logger, which prints "Log: User created".

📝 Syntax

advanced

Which option correctly injects a dependency in PHP constructor?

Which of the following PHP code snippets correctly injects a dependency into a class constructor?

A class Service { public function __construct(Database $db) { $this->db = $db; } }

B class Service { public function __construct($db) { $db = $this->db; } }

C class Service { function __construct(Database $db) { $this->db == $db; } }

D class Service { public function __construct(Database $db) { $db->this = $this; } }

💡 Hint

Check the assignment direction and parameter typing.

Option A correctly types the parameter and assigns it to the class property. Option A reverses assignment. Option A uses '==' instead of '='. Option A tries to assign to the parameter object incorrectly.

🔧 Debug

advanced

Why does this dependency injection code cause an error?

Given this PHP code, why does it cause a fatal error?

PHP

<?php
class Mailer {}
class Notification {
    private $mailer;
    public function __construct() {
        $this->mailer = new Mailer();
    }
}

$notification = new Notification(new Mailer());
?>

A Notification constructor does not accept any parameters but is called with one.

B Mailer class is not defined before use.

C Notification class tries to inject Mailer but does not assign it.

D Mailer class constructor requires parameters but none are given.

💡 Hint

Look at the constructor signature and how the object is instantiated.

The Notification constructor does not accept any parameters, but the code tries to pass a Mailer object when creating Notification, causing a fatal error.

❓ lifecycle

expert

How does dependency injection affect object lifecycle in PHP?

In PHP, when using dependency injection, which statement best describes how the lifecycle of injected objects is managed?

A Injected objects are always created inside the dependent class and destroyed with it.

B Injected objects must be static to survive beyond the dependent class lifecycle.

C Injected objects are created outside and can be shared or reused independently of the dependent class lifecycle.

D Injected objects are cloned automatically when injected to avoid shared state.

💡 Hint

Think about who creates the injected object and how that affects its lifetime.

Dependency injection means the dependent class receives objects created elsewhere. This allows sharing or reusing those objects independently of the dependent class lifecycle.