TL;DR: Replace global variables with dependency injection to improve testability and reduce coupling. ๐
Problems Addressed ๐
Steps ๐ ๏ธ
- Identify global variables used across your codebase.
- Create a real-world abstraction to encapsulate these variables.
- Pass dependencies explicitly via function parameters or constructors.
- Refactor existing code to use the new dependency-injected structure.
- Remove the original global variable declarations.
Sample Code ๐ป
Before โ
const globalConfig = { apiUrl: "https://api.severance.com" };
function fetchOuties() {
return fetch(`${globalConfig.apiUrl}/outies`);
}
After ๐
function fetchOuties(parameterConfig) {
return fetch(`${parameterConfig.apiUrl}/outies`);
}
const applicationConfig = { apiUrl: "https://api.severance.com" };
fetchOuties(applicationConfig);
A Step Beyond: API Reification
class ApiService {
constructor(parameterConfig) {
this.variableConfig = parameterConfig;
}
fetchOuties() {
return fetch(`${this.variableConfig.apiUrl}/outies`);
}
}
const apiService =
new ApiService({ apiUrl: "https://api.severance.com" });
apiService.fetchOuties();
Type ๐
[X] Semi-Automatic
Safety ๐ก๏ธ
This refactoring is safe if you audit all global variable references and thoroughly test the code after injection.
Why is the Code Better? ๐ฑ
Testability: Dependencies can be replaced (not mocked) for unit tests.
Explicit Contracts: Functions declare what they need.
Scalability: Configuration changes donโt require code edits.
Coupling: Code is less coupled.
How Does it Improve the Bijection? ๐บ๏ธ
By making dependencies explicit, the code mirrors real-world interactions where components rely on declared inputs, not hidden state.
You also reduce Coupling which is usually the more important problem you must solve.
Limitations โ ๏ธ
Over-injection can lead to parameter bloat.
Common Misconceptions
"But it's just a parameter!"
- Exactly! Passing dependencies via parameters is Dependency Injection. Frameworks often obscure this basic principle.
"This is too simple to be DI!"
- Dependency Injection doesn't require complex frameworks. This is a pure, framework-less injection.
"Dependency Injection vs Dependency Inversion"
- Inversion is the principle (why). It tells you to depend on abstractions to reduce coupling.
- Injection is the practice (how). Itโs one way (there are many others) to apply the principle by passing dependencies from outside instead of creating them inside a class.
Refactor with AI ๐ค
You can use AI tools to analyze your codebase and identify global variables.
The AI can suggest where to implement dependency injection and help generate the necessary interfaces or classes for your dependencies.
Try Them! ๐
Remember: AI Assistants make lots of mistakes
Suggested Prompt: 1. Identify global variables used across your codebase.2. Create a real-world abstraction to encapsulate these variables. 3. Pass dependencies explicitly via function parameters or constructors. 4. Refactor existing code to use the new dependency-injected structure. 5. Remove the original global variable declarations.
Level ๐
[X] Intermediate
See also ๐
Credits ๐
Image by Petra on Pixabay
This article is part of the Refactoring Series.
