Dependency Injection in JavaScript: A Complete Guide for Beginners

Dependency Injection in JavaScript: what it is and why you need it

In the world of modern development with JavaScript (Node.js), code cleanliness and maintainability are critically important. One of the key principles that helps achieve this is Dependency Injection (DI). This article is created specifically for beginners to explain the concept in simple language with practical examples.

Imagine you are assembling a computer. Instead of soldering the graphics card directly onto the motherboard permanently, you use PCI-E slots. This allows you to easily replace the graphics card with a more powerful one or use a different one for testing. Dependency Injection works on the same principle: you do not create dependencies inside a class (you don't "solder" them in), but pass them from the outside.

The problem without Dependency Injection

Consider a typical example in Node.js where the code becomes tightly coupled:

class Logger {    log(message) {        console.log(`[LOG]: ${message}`);    }}

class UserService {    constructor() {        this.logger = new Logger(); // Tight coupling    }

    createUser(name) {        this.logger.log(`User created: ${name}`);        // User creation logic    }}

const service = new UserService();service.createUser('Anna');

Here, UserService creates an instance of Logger itself. If we want to replace console.log with writing to a file or database, we will have to modify the UserService code. This violates the Open/Closed Principle from SOLID.

Basics of Dependency Injection in JavaScript

What is Dependency Injection?

Dependency Injection (DI) is a design pattern where an object receives its dependencies from an external source rather than creating them itself. In the context of JavaScript, this means passing dependencies through a constructor, setter, or method parameter.

Three main ways to inject dependencies

In JavaScript and Node.js, three approaches are used:

• Constructor Injection: dependencies are passed through the class constructor.
• Setter Injection: dependencies are set through a separate method (setter).
• Method Injection: dependencies are passed directly to the method that uses them.

The most popular and recommended approach is Constructor Injection, as it makes dependencies explicit and immutable after the object is created.

Practical examples of Dependency Injection in Node.js

Example 1: Constructor Injection

Let's rewrite our example using Dependency Injection:

class Logger {    log(message) {        console.log(`[LOG]: ${message}`);    }}

class FileLogger {    log(message) {        // Simulating writing to a file        console.log(`[FILE]: ${message}`);    }}

class UserService {    constructor(logger) {        this.logger = logger; // Dependency is passed from outside    }

    createUser(name) {        this.logger.log(`User created: ${name}`);        // User creation logic    }}

// Usage with different loggersconst consoleLogger = new Logger();const fileLogger = new FileLogger();

const serviceWithConsole = new UserService(consoleLogger);serviceWithConsole.createUser('Anna'); // [LOG]: User created: Anna

const serviceWithFile = new UserService(fileLogger);serviceWithFile.createUser('Ivan'); // [FILE]: User created: Ivan

Now UserService does not know which specific logger is being used. We